• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.bigquery.analyticshub.v1;
18 
19 import static com.google.cloud.bigquery.analyticshub.v1.AnalyticsHubServiceClient.ListDataExchangesPagedResponse;
20 import static com.google.cloud.bigquery.analyticshub.v1.AnalyticsHubServiceClient.ListListingsPagedResponse;
21 import static com.google.cloud.bigquery.analyticshub.v1.AnalyticsHubServiceClient.ListOrgDataExchangesPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
25 import com.google.api.gax.httpjson.testing.MockHttpService;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.ApiException;
28 import com.google.api.gax.rpc.ApiExceptionFactory;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.api.gax.rpc.testing.FakeStatusCode;
32 import com.google.cloud.bigquery.analyticshub.v1.stub.HttpJsonAnalyticsHubServiceStub;
33 import com.google.common.collect.Lists;
34 import com.google.iam.v1.AuditConfig;
35 import com.google.iam.v1.Binding;
36 import com.google.iam.v1.GetIamPolicyRequest;
37 import com.google.iam.v1.GetPolicyOptions;
38 import com.google.iam.v1.Policy;
39 import com.google.iam.v1.SetIamPolicyRequest;
40 import com.google.iam.v1.TestIamPermissionsRequest;
41 import com.google.iam.v1.TestIamPermissionsResponse;
42 import com.google.protobuf.ByteString;
43 import com.google.protobuf.Empty;
44 import com.google.protobuf.FieldMask;
45 import java.io.IOException;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.List;
49 import javax.annotation.Generated;
50 import org.junit.After;
51 import org.junit.AfterClass;
52 import org.junit.Assert;
53 import org.junit.Before;
54 import org.junit.BeforeClass;
55 import org.junit.Test;
56 
57 @Generated("by gapic-generator-java")
58 public class AnalyticsHubServiceClientHttpJsonTest {
59   private static MockHttpService mockService;
60   private static AnalyticsHubServiceClient client;
61 
62   @BeforeClass
startStaticServer()63   public static void startStaticServer() throws IOException {
64     mockService =
65         new MockHttpService(
66             HttpJsonAnalyticsHubServiceStub.getMethodDescriptors(),
67             AnalyticsHubServiceSettings.getDefaultEndpoint());
68     AnalyticsHubServiceSettings settings =
69         AnalyticsHubServiceSettings.newHttpJsonBuilder()
70             .setTransportChannelProvider(
71                 AnalyticsHubServiceSettings.defaultHttpJsonTransportProviderBuilder()
72                     .setHttpTransport(mockService)
73                     .build())
74             .setCredentialsProvider(NoCredentialsProvider.create())
75             .build();
76     client = AnalyticsHubServiceClient.create(settings);
77   }
78 
79   @AfterClass
stopServer()80   public static void stopServer() {
81     client.close();
82   }
83 
84   @Before
setUp()85   public void setUp() {}
86 
87   @After
tearDown()88   public void tearDown() throws Exception {
89     mockService.reset();
90   }
91 
92   @Test
listDataExchangesTest()93   public void listDataExchangesTest() throws Exception {
94     DataExchange responsesElement = DataExchange.newBuilder().build();
95     ListDataExchangesResponse expectedResponse =
96         ListDataExchangesResponse.newBuilder()
97             .setNextPageToken("")
98             .addAllDataExchanges(Arrays.asList(responsesElement))
99             .build();
100     mockService.addResponse(expectedResponse);
101 
102     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
103 
104     ListDataExchangesPagedResponse pagedListResponse = client.listDataExchanges(parent);
105 
106     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
107 
108     Assert.assertEquals(1, resources.size());
109     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
110 
111     List<String> actualRequests = mockService.getRequestPaths();
112     Assert.assertEquals(1, actualRequests.size());
113 
114     String apiClientHeaderKey =
115         mockService
116             .getRequestHeaders()
117             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
118             .iterator()
119             .next();
120     Assert.assertTrue(
121         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
122             .matcher(apiClientHeaderKey)
123             .matches());
124   }
125 
126   @Test
listDataExchangesExceptionTest()127   public void listDataExchangesExceptionTest() throws Exception {
128     ApiException exception =
129         ApiExceptionFactory.createException(
130             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
131     mockService.addException(exception);
132 
133     try {
134       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
135       client.listDataExchanges(parent);
136       Assert.fail("No exception raised");
137     } catch (InvalidArgumentException e) {
138       // Expected exception.
139     }
140   }
141 
142   @Test
listDataExchangesTest2()143   public void listDataExchangesTest2() throws Exception {
144     DataExchange responsesElement = DataExchange.newBuilder().build();
145     ListDataExchangesResponse expectedResponse =
146         ListDataExchangesResponse.newBuilder()
147             .setNextPageToken("")
148             .addAllDataExchanges(Arrays.asList(responsesElement))
149             .build();
150     mockService.addResponse(expectedResponse);
151 
152     String parent = "projects/project-5833/locations/location-5833";
153 
154     ListDataExchangesPagedResponse pagedListResponse = client.listDataExchanges(parent);
155 
156     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
157 
158     Assert.assertEquals(1, resources.size());
159     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
160 
161     List<String> actualRequests = mockService.getRequestPaths();
162     Assert.assertEquals(1, actualRequests.size());
163 
164     String apiClientHeaderKey =
165         mockService
166             .getRequestHeaders()
167             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
168             .iterator()
169             .next();
170     Assert.assertTrue(
171         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
172             .matcher(apiClientHeaderKey)
173             .matches());
174   }
175 
176   @Test
listDataExchangesExceptionTest2()177   public void listDataExchangesExceptionTest2() throws Exception {
178     ApiException exception =
179         ApiExceptionFactory.createException(
180             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
181     mockService.addException(exception);
182 
183     try {
184       String parent = "projects/project-5833/locations/location-5833";
185       client.listDataExchanges(parent);
186       Assert.fail("No exception raised");
187     } catch (InvalidArgumentException e) {
188       // Expected exception.
189     }
190   }
191 
192   @Test
listOrgDataExchangesTest()193   public void listOrgDataExchangesTest() throws Exception {
194     DataExchange responsesElement = DataExchange.newBuilder().build();
195     ListOrgDataExchangesResponse expectedResponse =
196         ListOrgDataExchangesResponse.newBuilder()
197             .setNextPageToken("")
198             .addAllDataExchanges(Arrays.asList(responsesElement))
199             .build();
200     mockService.addResponse(expectedResponse);
201 
202     String organization = "organizations/organization-686/locations/location-686";
203 
204     ListOrgDataExchangesPagedResponse pagedListResponse = client.listOrgDataExchanges(organization);
205 
206     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
207 
208     Assert.assertEquals(1, resources.size());
209     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
210 
211     List<String> actualRequests = mockService.getRequestPaths();
212     Assert.assertEquals(1, actualRequests.size());
213 
214     String apiClientHeaderKey =
215         mockService
216             .getRequestHeaders()
217             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
218             .iterator()
219             .next();
220     Assert.assertTrue(
221         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
222             .matcher(apiClientHeaderKey)
223             .matches());
224   }
225 
226   @Test
listOrgDataExchangesExceptionTest()227   public void listOrgDataExchangesExceptionTest() throws Exception {
228     ApiException exception =
229         ApiExceptionFactory.createException(
230             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
231     mockService.addException(exception);
232 
233     try {
234       String organization = "organizations/organization-686/locations/location-686";
235       client.listOrgDataExchanges(organization);
236       Assert.fail("No exception raised");
237     } catch (InvalidArgumentException e) {
238       // Expected exception.
239     }
240   }
241 
242   @Test
getDataExchangeTest()243   public void getDataExchangeTest() throws Exception {
244     DataExchange expectedResponse =
245         DataExchange.newBuilder()
246             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
247             .setDisplayName("displayName1714148973")
248             .setDescription("description-1724546052")
249             .setPrimaryContact("primaryContact-532068418")
250             .setDocumentation("documentation1587405498")
251             .setListingCount(-1101038700)
252             .setIcon(ByteString.EMPTY)
253             .build();
254     mockService.addResponse(expectedResponse);
255 
256     DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
257 
258     DataExchange actualResponse = client.getDataExchange(name);
259     Assert.assertEquals(expectedResponse, actualResponse);
260 
261     List<String> actualRequests = mockService.getRequestPaths();
262     Assert.assertEquals(1, actualRequests.size());
263 
264     String apiClientHeaderKey =
265         mockService
266             .getRequestHeaders()
267             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
268             .iterator()
269             .next();
270     Assert.assertTrue(
271         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
272             .matcher(apiClientHeaderKey)
273             .matches());
274   }
275 
276   @Test
getDataExchangeExceptionTest()277   public void getDataExchangeExceptionTest() throws Exception {
278     ApiException exception =
279         ApiExceptionFactory.createException(
280             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
281     mockService.addException(exception);
282 
283     try {
284       DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
285       client.getDataExchange(name);
286       Assert.fail("No exception raised");
287     } catch (InvalidArgumentException e) {
288       // Expected exception.
289     }
290   }
291 
292   @Test
getDataExchangeTest2()293   public void getDataExchangeTest2() throws Exception {
294     DataExchange expectedResponse =
295         DataExchange.newBuilder()
296             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
297             .setDisplayName("displayName1714148973")
298             .setDescription("description-1724546052")
299             .setPrimaryContact("primaryContact-532068418")
300             .setDocumentation("documentation1587405498")
301             .setListingCount(-1101038700)
302             .setIcon(ByteString.EMPTY)
303             .build();
304     mockService.addResponse(expectedResponse);
305 
306     String name = "projects/project-1196/locations/location-1196/dataExchanges/dataExchange-1196";
307 
308     DataExchange actualResponse = client.getDataExchange(name);
309     Assert.assertEquals(expectedResponse, actualResponse);
310 
311     List<String> actualRequests = mockService.getRequestPaths();
312     Assert.assertEquals(1, actualRequests.size());
313 
314     String apiClientHeaderKey =
315         mockService
316             .getRequestHeaders()
317             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
318             .iterator()
319             .next();
320     Assert.assertTrue(
321         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
322             .matcher(apiClientHeaderKey)
323             .matches());
324   }
325 
326   @Test
getDataExchangeExceptionTest2()327   public void getDataExchangeExceptionTest2() throws Exception {
328     ApiException exception =
329         ApiExceptionFactory.createException(
330             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
331     mockService.addException(exception);
332 
333     try {
334       String name = "projects/project-1196/locations/location-1196/dataExchanges/dataExchange-1196";
335       client.getDataExchange(name);
336       Assert.fail("No exception raised");
337     } catch (InvalidArgumentException e) {
338       // Expected exception.
339     }
340   }
341 
342   @Test
createDataExchangeTest()343   public void createDataExchangeTest() throws Exception {
344     DataExchange expectedResponse =
345         DataExchange.newBuilder()
346             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
347             .setDisplayName("displayName1714148973")
348             .setDescription("description-1724546052")
349             .setPrimaryContact("primaryContact-532068418")
350             .setDocumentation("documentation1587405498")
351             .setListingCount(-1101038700)
352             .setIcon(ByteString.EMPTY)
353             .build();
354     mockService.addResponse(expectedResponse);
355 
356     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
357     DataExchange dataExchange = DataExchange.newBuilder().build();
358 
359     DataExchange actualResponse = client.createDataExchange(parent, dataExchange);
360     Assert.assertEquals(expectedResponse, actualResponse);
361 
362     List<String> actualRequests = mockService.getRequestPaths();
363     Assert.assertEquals(1, actualRequests.size());
364 
365     String apiClientHeaderKey =
366         mockService
367             .getRequestHeaders()
368             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
369             .iterator()
370             .next();
371     Assert.assertTrue(
372         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
373             .matcher(apiClientHeaderKey)
374             .matches());
375   }
376 
377   @Test
createDataExchangeExceptionTest()378   public void createDataExchangeExceptionTest() throws Exception {
379     ApiException exception =
380         ApiExceptionFactory.createException(
381             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
382     mockService.addException(exception);
383 
384     try {
385       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
386       DataExchange dataExchange = DataExchange.newBuilder().build();
387       client.createDataExchange(parent, dataExchange);
388       Assert.fail("No exception raised");
389     } catch (InvalidArgumentException e) {
390       // Expected exception.
391     }
392   }
393 
394   @Test
createDataExchangeTest2()395   public void createDataExchangeTest2() throws Exception {
396     DataExchange expectedResponse =
397         DataExchange.newBuilder()
398             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
399             .setDisplayName("displayName1714148973")
400             .setDescription("description-1724546052")
401             .setPrimaryContact("primaryContact-532068418")
402             .setDocumentation("documentation1587405498")
403             .setListingCount(-1101038700)
404             .setIcon(ByteString.EMPTY)
405             .build();
406     mockService.addResponse(expectedResponse);
407 
408     String parent = "projects/project-5833/locations/location-5833";
409     DataExchange dataExchange = DataExchange.newBuilder().build();
410 
411     DataExchange actualResponse = client.createDataExchange(parent, dataExchange);
412     Assert.assertEquals(expectedResponse, actualResponse);
413 
414     List<String> actualRequests = mockService.getRequestPaths();
415     Assert.assertEquals(1, actualRequests.size());
416 
417     String apiClientHeaderKey =
418         mockService
419             .getRequestHeaders()
420             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
421             .iterator()
422             .next();
423     Assert.assertTrue(
424         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
425             .matcher(apiClientHeaderKey)
426             .matches());
427   }
428 
429   @Test
createDataExchangeExceptionTest2()430   public void createDataExchangeExceptionTest2() throws Exception {
431     ApiException exception =
432         ApiExceptionFactory.createException(
433             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
434     mockService.addException(exception);
435 
436     try {
437       String parent = "projects/project-5833/locations/location-5833";
438       DataExchange dataExchange = DataExchange.newBuilder().build();
439       client.createDataExchange(parent, dataExchange);
440       Assert.fail("No exception raised");
441     } catch (InvalidArgumentException e) {
442       // Expected exception.
443     }
444   }
445 
446   @Test
updateDataExchangeTest()447   public void updateDataExchangeTest() throws Exception {
448     DataExchange expectedResponse =
449         DataExchange.newBuilder()
450             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
451             .setDisplayName("displayName1714148973")
452             .setDescription("description-1724546052")
453             .setPrimaryContact("primaryContact-532068418")
454             .setDocumentation("documentation1587405498")
455             .setListingCount(-1101038700)
456             .setIcon(ByteString.EMPTY)
457             .build();
458     mockService.addResponse(expectedResponse);
459 
460     DataExchange dataExchange =
461         DataExchange.newBuilder()
462             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
463             .setDisplayName("displayName1714148973")
464             .setDescription("description-1724546052")
465             .setPrimaryContact("primaryContact-532068418")
466             .setDocumentation("documentation1587405498")
467             .setListingCount(-1101038700)
468             .setIcon(ByteString.EMPTY)
469             .build();
470     FieldMask updateMask = FieldMask.newBuilder().build();
471 
472     DataExchange actualResponse = client.updateDataExchange(dataExchange, updateMask);
473     Assert.assertEquals(expectedResponse, actualResponse);
474 
475     List<String> actualRequests = mockService.getRequestPaths();
476     Assert.assertEquals(1, actualRequests.size());
477 
478     String apiClientHeaderKey =
479         mockService
480             .getRequestHeaders()
481             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
482             .iterator()
483             .next();
484     Assert.assertTrue(
485         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
486             .matcher(apiClientHeaderKey)
487             .matches());
488   }
489 
490   @Test
updateDataExchangeExceptionTest()491   public void updateDataExchangeExceptionTest() throws Exception {
492     ApiException exception =
493         ApiExceptionFactory.createException(
494             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
495     mockService.addException(exception);
496 
497     try {
498       DataExchange dataExchange =
499           DataExchange.newBuilder()
500               .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
501               .setDisplayName("displayName1714148973")
502               .setDescription("description-1724546052")
503               .setPrimaryContact("primaryContact-532068418")
504               .setDocumentation("documentation1587405498")
505               .setListingCount(-1101038700)
506               .setIcon(ByteString.EMPTY)
507               .build();
508       FieldMask updateMask = FieldMask.newBuilder().build();
509       client.updateDataExchange(dataExchange, updateMask);
510       Assert.fail("No exception raised");
511     } catch (InvalidArgumentException e) {
512       // Expected exception.
513     }
514   }
515 
516   @Test
deleteDataExchangeTest()517   public void deleteDataExchangeTest() throws Exception {
518     Empty expectedResponse = Empty.newBuilder().build();
519     mockService.addResponse(expectedResponse);
520 
521     DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
522 
523     client.deleteDataExchange(name);
524 
525     List<String> actualRequests = mockService.getRequestPaths();
526     Assert.assertEquals(1, actualRequests.size());
527 
528     String apiClientHeaderKey =
529         mockService
530             .getRequestHeaders()
531             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
532             .iterator()
533             .next();
534     Assert.assertTrue(
535         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
536             .matcher(apiClientHeaderKey)
537             .matches());
538   }
539 
540   @Test
deleteDataExchangeExceptionTest()541   public void deleteDataExchangeExceptionTest() throws Exception {
542     ApiException exception =
543         ApiExceptionFactory.createException(
544             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
545     mockService.addException(exception);
546 
547     try {
548       DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
549       client.deleteDataExchange(name);
550       Assert.fail("No exception raised");
551     } catch (InvalidArgumentException e) {
552       // Expected exception.
553     }
554   }
555 
556   @Test
deleteDataExchangeTest2()557   public void deleteDataExchangeTest2() throws Exception {
558     Empty expectedResponse = Empty.newBuilder().build();
559     mockService.addResponse(expectedResponse);
560 
561     String name = "projects/project-1196/locations/location-1196/dataExchanges/dataExchange-1196";
562 
563     client.deleteDataExchange(name);
564 
565     List<String> actualRequests = mockService.getRequestPaths();
566     Assert.assertEquals(1, actualRequests.size());
567 
568     String apiClientHeaderKey =
569         mockService
570             .getRequestHeaders()
571             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
572             .iterator()
573             .next();
574     Assert.assertTrue(
575         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
576             .matcher(apiClientHeaderKey)
577             .matches());
578   }
579 
580   @Test
deleteDataExchangeExceptionTest2()581   public void deleteDataExchangeExceptionTest2() throws Exception {
582     ApiException exception =
583         ApiExceptionFactory.createException(
584             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
585     mockService.addException(exception);
586 
587     try {
588       String name = "projects/project-1196/locations/location-1196/dataExchanges/dataExchange-1196";
589       client.deleteDataExchange(name);
590       Assert.fail("No exception raised");
591     } catch (InvalidArgumentException e) {
592       // Expected exception.
593     }
594   }
595 
596   @Test
listListingsTest()597   public void listListingsTest() throws Exception {
598     Listing responsesElement = Listing.newBuilder().build();
599     ListListingsResponse expectedResponse =
600         ListListingsResponse.newBuilder()
601             .setNextPageToken("")
602             .addAllListings(Arrays.asList(responsesElement))
603             .build();
604     mockService.addResponse(expectedResponse);
605 
606     DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
607 
608     ListListingsPagedResponse pagedListResponse = client.listListings(parent);
609 
610     List<Listing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
611 
612     Assert.assertEquals(1, resources.size());
613     Assert.assertEquals(expectedResponse.getListingsList().get(0), resources.get(0));
614 
615     List<String> actualRequests = mockService.getRequestPaths();
616     Assert.assertEquals(1, actualRequests.size());
617 
618     String apiClientHeaderKey =
619         mockService
620             .getRequestHeaders()
621             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
622             .iterator()
623             .next();
624     Assert.assertTrue(
625         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
626             .matcher(apiClientHeaderKey)
627             .matches());
628   }
629 
630   @Test
listListingsExceptionTest()631   public void listListingsExceptionTest() throws Exception {
632     ApiException exception =
633         ApiExceptionFactory.createException(
634             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
635     mockService.addException(exception);
636 
637     try {
638       DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
639       client.listListings(parent);
640       Assert.fail("No exception raised");
641     } catch (InvalidArgumentException e) {
642       // Expected exception.
643     }
644   }
645 
646   @Test
listListingsTest2()647   public void listListingsTest2() throws Exception {
648     Listing responsesElement = Listing.newBuilder().build();
649     ListListingsResponse expectedResponse =
650         ListListingsResponse.newBuilder()
651             .setNextPageToken("")
652             .addAllListings(Arrays.asList(responsesElement))
653             .build();
654     mockService.addResponse(expectedResponse);
655 
656     String parent = "projects/project-4709/locations/location-4709/dataExchanges/dataExchange-4709";
657 
658     ListListingsPagedResponse pagedListResponse = client.listListings(parent);
659 
660     List<Listing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
661 
662     Assert.assertEquals(1, resources.size());
663     Assert.assertEquals(expectedResponse.getListingsList().get(0), resources.get(0));
664 
665     List<String> actualRequests = mockService.getRequestPaths();
666     Assert.assertEquals(1, actualRequests.size());
667 
668     String apiClientHeaderKey =
669         mockService
670             .getRequestHeaders()
671             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
672             .iterator()
673             .next();
674     Assert.assertTrue(
675         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
676             .matcher(apiClientHeaderKey)
677             .matches());
678   }
679 
680   @Test
listListingsExceptionTest2()681   public void listListingsExceptionTest2() throws Exception {
682     ApiException exception =
683         ApiExceptionFactory.createException(
684             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
685     mockService.addException(exception);
686 
687     try {
688       String parent =
689           "projects/project-4709/locations/location-4709/dataExchanges/dataExchange-4709";
690       client.listListings(parent);
691       Assert.fail("No exception raised");
692     } catch (InvalidArgumentException e) {
693       // Expected exception.
694     }
695   }
696 
697   @Test
getListingTest()698   public void getListingTest() throws Exception {
699     Listing expectedResponse =
700         Listing.newBuilder()
701             .setName(
702                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
703                     .toString())
704             .setDisplayName("displayName1714148973")
705             .setDescription("description-1724546052")
706             .setPrimaryContact("primaryContact-532068418")
707             .setDocumentation("documentation1587405498")
708             .setIcon(ByteString.EMPTY)
709             .setDataProvider(DataProvider.newBuilder().build())
710             .addAllCategories(new ArrayList<Listing.Category>())
711             .setPublisher(Publisher.newBuilder().build())
712             .setRequestAccess("requestAccess871967955")
713             .build();
714     mockService.addResponse(expectedResponse);
715 
716     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
717 
718     Listing actualResponse = client.getListing(name);
719     Assert.assertEquals(expectedResponse, actualResponse);
720 
721     List<String> actualRequests = mockService.getRequestPaths();
722     Assert.assertEquals(1, actualRequests.size());
723 
724     String apiClientHeaderKey =
725         mockService
726             .getRequestHeaders()
727             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
728             .iterator()
729             .next();
730     Assert.assertTrue(
731         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
732             .matcher(apiClientHeaderKey)
733             .matches());
734   }
735 
736   @Test
getListingExceptionTest()737   public void getListingExceptionTest() throws Exception {
738     ApiException exception =
739         ApiExceptionFactory.createException(
740             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
741     mockService.addException(exception);
742 
743     try {
744       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
745       client.getListing(name);
746       Assert.fail("No exception raised");
747     } catch (InvalidArgumentException e) {
748       // Expected exception.
749     }
750   }
751 
752   @Test
getListingTest2()753   public void getListingTest2() throws Exception {
754     Listing expectedResponse =
755         Listing.newBuilder()
756             .setName(
757                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
758                     .toString())
759             .setDisplayName("displayName1714148973")
760             .setDescription("description-1724546052")
761             .setPrimaryContact("primaryContact-532068418")
762             .setDocumentation("documentation1587405498")
763             .setIcon(ByteString.EMPTY)
764             .setDataProvider(DataProvider.newBuilder().build())
765             .addAllCategories(new ArrayList<Listing.Category>())
766             .setPublisher(Publisher.newBuilder().build())
767             .setRequestAccess("requestAccess871967955")
768             .build();
769     mockService.addResponse(expectedResponse);
770 
771     String name =
772         "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
773 
774     Listing actualResponse = client.getListing(name);
775     Assert.assertEquals(expectedResponse, actualResponse);
776 
777     List<String> actualRequests = mockService.getRequestPaths();
778     Assert.assertEquals(1, actualRequests.size());
779 
780     String apiClientHeaderKey =
781         mockService
782             .getRequestHeaders()
783             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
784             .iterator()
785             .next();
786     Assert.assertTrue(
787         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
788             .matcher(apiClientHeaderKey)
789             .matches());
790   }
791 
792   @Test
getListingExceptionTest2()793   public void getListingExceptionTest2() throws Exception {
794     ApiException exception =
795         ApiExceptionFactory.createException(
796             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
797     mockService.addException(exception);
798 
799     try {
800       String name =
801           "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
802       client.getListing(name);
803       Assert.fail("No exception raised");
804     } catch (InvalidArgumentException e) {
805       // Expected exception.
806     }
807   }
808 
809   @Test
createListingTest()810   public void createListingTest() throws Exception {
811     Listing expectedResponse =
812         Listing.newBuilder()
813             .setName(
814                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
815                     .toString())
816             .setDisplayName("displayName1714148973")
817             .setDescription("description-1724546052")
818             .setPrimaryContact("primaryContact-532068418")
819             .setDocumentation("documentation1587405498")
820             .setIcon(ByteString.EMPTY)
821             .setDataProvider(DataProvider.newBuilder().build())
822             .addAllCategories(new ArrayList<Listing.Category>())
823             .setPublisher(Publisher.newBuilder().build())
824             .setRequestAccess("requestAccess871967955")
825             .build();
826     mockService.addResponse(expectedResponse);
827 
828     DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
829     Listing listing = Listing.newBuilder().build();
830 
831     Listing actualResponse = client.createListing(parent, listing);
832     Assert.assertEquals(expectedResponse, actualResponse);
833 
834     List<String> actualRequests = mockService.getRequestPaths();
835     Assert.assertEquals(1, actualRequests.size());
836 
837     String apiClientHeaderKey =
838         mockService
839             .getRequestHeaders()
840             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
841             .iterator()
842             .next();
843     Assert.assertTrue(
844         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
845             .matcher(apiClientHeaderKey)
846             .matches());
847   }
848 
849   @Test
createListingExceptionTest()850   public void createListingExceptionTest() throws Exception {
851     ApiException exception =
852         ApiExceptionFactory.createException(
853             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
854     mockService.addException(exception);
855 
856     try {
857       DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
858       Listing listing = Listing.newBuilder().build();
859       client.createListing(parent, listing);
860       Assert.fail("No exception raised");
861     } catch (InvalidArgumentException e) {
862       // Expected exception.
863     }
864   }
865 
866   @Test
createListingTest2()867   public void createListingTest2() throws Exception {
868     Listing expectedResponse =
869         Listing.newBuilder()
870             .setName(
871                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
872                     .toString())
873             .setDisplayName("displayName1714148973")
874             .setDescription("description-1724546052")
875             .setPrimaryContact("primaryContact-532068418")
876             .setDocumentation("documentation1587405498")
877             .setIcon(ByteString.EMPTY)
878             .setDataProvider(DataProvider.newBuilder().build())
879             .addAllCategories(new ArrayList<Listing.Category>())
880             .setPublisher(Publisher.newBuilder().build())
881             .setRequestAccess("requestAccess871967955")
882             .build();
883     mockService.addResponse(expectedResponse);
884 
885     String parent = "projects/project-4709/locations/location-4709/dataExchanges/dataExchange-4709";
886     Listing listing = Listing.newBuilder().build();
887 
888     Listing actualResponse = client.createListing(parent, listing);
889     Assert.assertEquals(expectedResponse, actualResponse);
890 
891     List<String> actualRequests = mockService.getRequestPaths();
892     Assert.assertEquals(1, actualRequests.size());
893 
894     String apiClientHeaderKey =
895         mockService
896             .getRequestHeaders()
897             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
898             .iterator()
899             .next();
900     Assert.assertTrue(
901         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
902             .matcher(apiClientHeaderKey)
903             .matches());
904   }
905 
906   @Test
createListingExceptionTest2()907   public void createListingExceptionTest2() throws Exception {
908     ApiException exception =
909         ApiExceptionFactory.createException(
910             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
911     mockService.addException(exception);
912 
913     try {
914       String parent =
915           "projects/project-4709/locations/location-4709/dataExchanges/dataExchange-4709";
916       Listing listing = Listing.newBuilder().build();
917       client.createListing(parent, listing);
918       Assert.fail("No exception raised");
919     } catch (InvalidArgumentException e) {
920       // Expected exception.
921     }
922   }
923 
924   @Test
updateListingTest()925   public void updateListingTest() throws Exception {
926     Listing expectedResponse =
927         Listing.newBuilder()
928             .setName(
929                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
930                     .toString())
931             .setDisplayName("displayName1714148973")
932             .setDescription("description-1724546052")
933             .setPrimaryContact("primaryContact-532068418")
934             .setDocumentation("documentation1587405498")
935             .setIcon(ByteString.EMPTY)
936             .setDataProvider(DataProvider.newBuilder().build())
937             .addAllCategories(new ArrayList<Listing.Category>())
938             .setPublisher(Publisher.newBuilder().build())
939             .setRequestAccess("requestAccess871967955")
940             .build();
941     mockService.addResponse(expectedResponse);
942 
943     Listing listing =
944         Listing.newBuilder()
945             .setName(
946                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
947                     .toString())
948             .setDisplayName("displayName1714148973")
949             .setDescription("description-1724546052")
950             .setPrimaryContact("primaryContact-532068418")
951             .setDocumentation("documentation1587405498")
952             .setIcon(ByteString.EMPTY)
953             .setDataProvider(DataProvider.newBuilder().build())
954             .addAllCategories(new ArrayList<Listing.Category>())
955             .setPublisher(Publisher.newBuilder().build())
956             .setRequestAccess("requestAccess871967955")
957             .build();
958     FieldMask updateMask = FieldMask.newBuilder().build();
959 
960     Listing actualResponse = client.updateListing(listing, updateMask);
961     Assert.assertEquals(expectedResponse, actualResponse);
962 
963     List<String> actualRequests = mockService.getRequestPaths();
964     Assert.assertEquals(1, actualRequests.size());
965 
966     String apiClientHeaderKey =
967         mockService
968             .getRequestHeaders()
969             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
970             .iterator()
971             .next();
972     Assert.assertTrue(
973         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
974             .matcher(apiClientHeaderKey)
975             .matches());
976   }
977 
978   @Test
updateListingExceptionTest()979   public void updateListingExceptionTest() throws Exception {
980     ApiException exception =
981         ApiExceptionFactory.createException(
982             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
983     mockService.addException(exception);
984 
985     try {
986       Listing listing =
987           Listing.newBuilder()
988               .setName(
989                   ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
990                       .toString())
991               .setDisplayName("displayName1714148973")
992               .setDescription("description-1724546052")
993               .setPrimaryContact("primaryContact-532068418")
994               .setDocumentation("documentation1587405498")
995               .setIcon(ByteString.EMPTY)
996               .setDataProvider(DataProvider.newBuilder().build())
997               .addAllCategories(new ArrayList<Listing.Category>())
998               .setPublisher(Publisher.newBuilder().build())
999               .setRequestAccess("requestAccess871967955")
1000               .build();
1001       FieldMask updateMask = FieldMask.newBuilder().build();
1002       client.updateListing(listing, updateMask);
1003       Assert.fail("No exception raised");
1004     } catch (InvalidArgumentException e) {
1005       // Expected exception.
1006     }
1007   }
1008 
1009   @Test
deleteListingTest()1010   public void deleteListingTest() throws Exception {
1011     Empty expectedResponse = Empty.newBuilder().build();
1012     mockService.addResponse(expectedResponse);
1013 
1014     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
1015 
1016     client.deleteListing(name);
1017 
1018     List<String> actualRequests = mockService.getRequestPaths();
1019     Assert.assertEquals(1, actualRequests.size());
1020 
1021     String apiClientHeaderKey =
1022         mockService
1023             .getRequestHeaders()
1024             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1025             .iterator()
1026             .next();
1027     Assert.assertTrue(
1028         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1029             .matcher(apiClientHeaderKey)
1030             .matches());
1031   }
1032 
1033   @Test
deleteListingExceptionTest()1034   public void deleteListingExceptionTest() throws Exception {
1035     ApiException exception =
1036         ApiExceptionFactory.createException(
1037             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1038     mockService.addException(exception);
1039 
1040     try {
1041       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
1042       client.deleteListing(name);
1043       Assert.fail("No exception raised");
1044     } catch (InvalidArgumentException e) {
1045       // Expected exception.
1046     }
1047   }
1048 
1049   @Test
deleteListingTest2()1050   public void deleteListingTest2() throws Exception {
1051     Empty expectedResponse = Empty.newBuilder().build();
1052     mockService.addResponse(expectedResponse);
1053 
1054     String name =
1055         "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
1056 
1057     client.deleteListing(name);
1058 
1059     List<String> actualRequests = mockService.getRequestPaths();
1060     Assert.assertEquals(1, actualRequests.size());
1061 
1062     String apiClientHeaderKey =
1063         mockService
1064             .getRequestHeaders()
1065             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1066             .iterator()
1067             .next();
1068     Assert.assertTrue(
1069         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1070             .matcher(apiClientHeaderKey)
1071             .matches());
1072   }
1073 
1074   @Test
deleteListingExceptionTest2()1075   public void deleteListingExceptionTest2() throws Exception {
1076     ApiException exception =
1077         ApiExceptionFactory.createException(
1078             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1079     mockService.addException(exception);
1080 
1081     try {
1082       String name =
1083           "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
1084       client.deleteListing(name);
1085       Assert.fail("No exception raised");
1086     } catch (InvalidArgumentException e) {
1087       // Expected exception.
1088     }
1089   }
1090 
1091   @Test
subscribeListingTest()1092   public void subscribeListingTest() throws Exception {
1093     SubscribeListingResponse expectedResponse = SubscribeListingResponse.newBuilder().build();
1094     mockService.addResponse(expectedResponse);
1095 
1096     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
1097 
1098     SubscribeListingResponse actualResponse = client.subscribeListing(name);
1099     Assert.assertEquals(expectedResponse, actualResponse);
1100 
1101     List<String> actualRequests = mockService.getRequestPaths();
1102     Assert.assertEquals(1, actualRequests.size());
1103 
1104     String apiClientHeaderKey =
1105         mockService
1106             .getRequestHeaders()
1107             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1108             .iterator()
1109             .next();
1110     Assert.assertTrue(
1111         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1112             .matcher(apiClientHeaderKey)
1113             .matches());
1114   }
1115 
1116   @Test
subscribeListingExceptionTest()1117   public void subscribeListingExceptionTest() throws Exception {
1118     ApiException exception =
1119         ApiExceptionFactory.createException(
1120             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1121     mockService.addException(exception);
1122 
1123     try {
1124       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
1125       client.subscribeListing(name);
1126       Assert.fail("No exception raised");
1127     } catch (InvalidArgumentException e) {
1128       // Expected exception.
1129     }
1130   }
1131 
1132   @Test
subscribeListingTest2()1133   public void subscribeListingTest2() throws Exception {
1134     SubscribeListingResponse expectedResponse = SubscribeListingResponse.newBuilder().build();
1135     mockService.addResponse(expectedResponse);
1136 
1137     String name =
1138         "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
1139 
1140     SubscribeListingResponse actualResponse = client.subscribeListing(name);
1141     Assert.assertEquals(expectedResponse, actualResponse);
1142 
1143     List<String> actualRequests = mockService.getRequestPaths();
1144     Assert.assertEquals(1, actualRequests.size());
1145 
1146     String apiClientHeaderKey =
1147         mockService
1148             .getRequestHeaders()
1149             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1150             .iterator()
1151             .next();
1152     Assert.assertTrue(
1153         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1154             .matcher(apiClientHeaderKey)
1155             .matches());
1156   }
1157 
1158   @Test
subscribeListingExceptionTest2()1159   public void subscribeListingExceptionTest2() throws Exception {
1160     ApiException exception =
1161         ApiExceptionFactory.createException(
1162             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1163     mockService.addException(exception);
1164 
1165     try {
1166       String name =
1167           "projects/project-9891/locations/location-9891/dataExchanges/dataExchange-9891/listings/listing-9891";
1168       client.subscribeListing(name);
1169       Assert.fail("No exception raised");
1170     } catch (InvalidArgumentException e) {
1171       // Expected exception.
1172     }
1173   }
1174 
1175   @Test
getIamPolicyTest()1176   public void getIamPolicyTest() throws Exception {
1177     Policy expectedResponse =
1178         Policy.newBuilder()
1179             .setVersion(351608024)
1180             .addAllBindings(new ArrayList<Binding>())
1181             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1182             .setEtag(ByteString.EMPTY)
1183             .build();
1184     mockService.addResponse(expectedResponse);
1185 
1186     GetIamPolicyRequest request =
1187         GetIamPolicyRequest.newBuilder()
1188             .setResource(
1189                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1190             .setOptions(GetPolicyOptions.newBuilder().build())
1191             .build();
1192 
1193     Policy actualResponse = client.getIamPolicy(request);
1194     Assert.assertEquals(expectedResponse, actualResponse);
1195 
1196     List<String> actualRequests = mockService.getRequestPaths();
1197     Assert.assertEquals(1, actualRequests.size());
1198 
1199     String apiClientHeaderKey =
1200         mockService
1201             .getRequestHeaders()
1202             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1203             .iterator()
1204             .next();
1205     Assert.assertTrue(
1206         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1207             .matcher(apiClientHeaderKey)
1208             .matches());
1209   }
1210 
1211   @Test
getIamPolicyExceptionTest()1212   public void getIamPolicyExceptionTest() throws Exception {
1213     ApiException exception =
1214         ApiExceptionFactory.createException(
1215             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1216     mockService.addException(exception);
1217 
1218     try {
1219       GetIamPolicyRequest request =
1220           GetIamPolicyRequest.newBuilder()
1221               .setResource(
1222                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1223               .setOptions(GetPolicyOptions.newBuilder().build())
1224               .build();
1225       client.getIamPolicy(request);
1226       Assert.fail("No exception raised");
1227     } catch (InvalidArgumentException e) {
1228       // Expected exception.
1229     }
1230   }
1231 
1232   @Test
setIamPolicyTest()1233   public void setIamPolicyTest() throws Exception {
1234     Policy expectedResponse =
1235         Policy.newBuilder()
1236             .setVersion(351608024)
1237             .addAllBindings(new ArrayList<Binding>())
1238             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1239             .setEtag(ByteString.EMPTY)
1240             .build();
1241     mockService.addResponse(expectedResponse);
1242 
1243     SetIamPolicyRequest request =
1244         SetIamPolicyRequest.newBuilder()
1245             .setResource(
1246                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1247             .setPolicy(Policy.newBuilder().build())
1248             .setUpdateMask(FieldMask.newBuilder().build())
1249             .build();
1250 
1251     Policy actualResponse = client.setIamPolicy(request);
1252     Assert.assertEquals(expectedResponse, actualResponse);
1253 
1254     List<String> actualRequests = mockService.getRequestPaths();
1255     Assert.assertEquals(1, actualRequests.size());
1256 
1257     String apiClientHeaderKey =
1258         mockService
1259             .getRequestHeaders()
1260             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1261             .iterator()
1262             .next();
1263     Assert.assertTrue(
1264         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1265             .matcher(apiClientHeaderKey)
1266             .matches());
1267   }
1268 
1269   @Test
setIamPolicyExceptionTest()1270   public void setIamPolicyExceptionTest() throws Exception {
1271     ApiException exception =
1272         ApiExceptionFactory.createException(
1273             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1274     mockService.addException(exception);
1275 
1276     try {
1277       SetIamPolicyRequest request =
1278           SetIamPolicyRequest.newBuilder()
1279               .setResource(
1280                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1281               .setPolicy(Policy.newBuilder().build())
1282               .setUpdateMask(FieldMask.newBuilder().build())
1283               .build();
1284       client.setIamPolicy(request);
1285       Assert.fail("No exception raised");
1286     } catch (InvalidArgumentException e) {
1287       // Expected exception.
1288     }
1289   }
1290 
1291   @Test
testIamPermissionsTest()1292   public void testIamPermissionsTest() throws Exception {
1293     TestIamPermissionsResponse expectedResponse =
1294         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1295     mockService.addResponse(expectedResponse);
1296 
1297     TestIamPermissionsRequest request =
1298         TestIamPermissionsRequest.newBuilder()
1299             .setResource(
1300                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1301             .addAllPermissions(new ArrayList<String>())
1302             .build();
1303 
1304     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1305     Assert.assertEquals(expectedResponse, actualResponse);
1306 
1307     List<String> actualRequests = mockService.getRequestPaths();
1308     Assert.assertEquals(1, actualRequests.size());
1309 
1310     String apiClientHeaderKey =
1311         mockService
1312             .getRequestHeaders()
1313             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1314             .iterator()
1315             .next();
1316     Assert.assertTrue(
1317         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1318             .matcher(apiClientHeaderKey)
1319             .matches());
1320   }
1321 
1322   @Test
testIamPermissionsExceptionTest()1323   public void testIamPermissionsExceptionTest() throws Exception {
1324     ApiException exception =
1325         ApiExceptionFactory.createException(
1326             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1327     mockService.addException(exception);
1328 
1329     try {
1330       TestIamPermissionsRequest request =
1331           TestIamPermissionsRequest.newBuilder()
1332               .setResource(
1333                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1334               .addAllPermissions(new ArrayList<String>())
1335               .build();
1336       client.testIamPermissions(request);
1337       Assert.fail("No exception raised");
1338     } catch (InvalidArgumentException e) {
1339       // Expected exception.
1340     }
1341   }
1342 }
1343