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