• 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.grpc.GaxGrpcProperties;
25 import com.google.api.gax.grpc.testing.LocalChannelProvider;
26 import com.google.api.gax.grpc.testing.MockGrpcService;
27 import com.google.api.gax.grpc.testing.MockServiceHelper;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.common.collect.Lists;
31 import com.google.iam.v1.AuditConfig;
32 import com.google.iam.v1.Binding;
33 import com.google.iam.v1.GetIamPolicyRequest;
34 import com.google.iam.v1.GetPolicyOptions;
35 import com.google.iam.v1.Policy;
36 import com.google.iam.v1.SetIamPolicyRequest;
37 import com.google.iam.v1.TestIamPermissionsRequest;
38 import com.google.iam.v1.TestIamPermissionsResponse;
39 import com.google.protobuf.AbstractMessage;
40 import com.google.protobuf.ByteString;
41 import com.google.protobuf.Empty;
42 import com.google.protobuf.FieldMask;
43 import io.grpc.StatusRuntimeException;
44 import java.io.IOException;
45 import java.util.ArrayList;
46 import java.util.Arrays;
47 import java.util.List;
48 import java.util.UUID;
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 AnalyticsHubServiceClientTest {
59   private static MockAnalyticsHubService mockAnalyticsHubService;
60   private static MockServiceHelper mockServiceHelper;
61   private LocalChannelProvider channelProvider;
62   private AnalyticsHubServiceClient client;
63 
64   @BeforeClass
startStaticServer()65   public static void startStaticServer() {
66     mockAnalyticsHubService = new MockAnalyticsHubService();
67     mockServiceHelper =
68         new MockServiceHelper(
69             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockAnalyticsHubService));
70     mockServiceHelper.start();
71   }
72 
73   @AfterClass
stopServer()74   public static void stopServer() {
75     mockServiceHelper.stop();
76   }
77 
78   @Before
setUp()79   public void setUp() throws IOException {
80     mockServiceHelper.reset();
81     channelProvider = mockServiceHelper.createChannelProvider();
82     AnalyticsHubServiceSettings settings =
83         AnalyticsHubServiceSettings.newBuilder()
84             .setTransportChannelProvider(channelProvider)
85             .setCredentialsProvider(NoCredentialsProvider.create())
86             .build();
87     client = AnalyticsHubServiceClient.create(settings);
88   }
89 
90   @After
tearDown()91   public void tearDown() throws Exception {
92     client.close();
93   }
94 
95   @Test
listDataExchangesTest()96   public void listDataExchangesTest() throws Exception {
97     DataExchange responsesElement = DataExchange.newBuilder().build();
98     ListDataExchangesResponse expectedResponse =
99         ListDataExchangesResponse.newBuilder()
100             .setNextPageToken("")
101             .addAllDataExchanges(Arrays.asList(responsesElement))
102             .build();
103     mockAnalyticsHubService.addResponse(expectedResponse);
104 
105     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
106 
107     ListDataExchangesPagedResponse pagedListResponse = client.listDataExchanges(parent);
108 
109     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
110 
111     Assert.assertEquals(1, resources.size());
112     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
113 
114     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
115     Assert.assertEquals(1, actualRequests.size());
116     ListDataExchangesRequest actualRequest = ((ListDataExchangesRequest) actualRequests.get(0));
117 
118     Assert.assertEquals(parent.toString(), actualRequest.getParent());
119     Assert.assertTrue(
120         channelProvider.isHeaderSent(
121             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
122             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
123   }
124 
125   @Test
listDataExchangesExceptionTest()126   public void listDataExchangesExceptionTest() throws Exception {
127     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
128     mockAnalyticsHubService.addException(exception);
129 
130     try {
131       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
132       client.listDataExchanges(parent);
133       Assert.fail("No exception raised");
134     } catch (InvalidArgumentException e) {
135       // Expected exception.
136     }
137   }
138 
139   @Test
listDataExchangesTest2()140   public void listDataExchangesTest2() throws Exception {
141     DataExchange responsesElement = DataExchange.newBuilder().build();
142     ListDataExchangesResponse expectedResponse =
143         ListDataExchangesResponse.newBuilder()
144             .setNextPageToken("")
145             .addAllDataExchanges(Arrays.asList(responsesElement))
146             .build();
147     mockAnalyticsHubService.addResponse(expectedResponse);
148 
149     String parent = "parent-995424086";
150 
151     ListDataExchangesPagedResponse pagedListResponse = client.listDataExchanges(parent);
152 
153     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
154 
155     Assert.assertEquals(1, resources.size());
156     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
157 
158     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
159     Assert.assertEquals(1, actualRequests.size());
160     ListDataExchangesRequest actualRequest = ((ListDataExchangesRequest) actualRequests.get(0));
161 
162     Assert.assertEquals(parent, actualRequest.getParent());
163     Assert.assertTrue(
164         channelProvider.isHeaderSent(
165             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
166             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
167   }
168 
169   @Test
listDataExchangesExceptionTest2()170   public void listDataExchangesExceptionTest2() throws Exception {
171     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
172     mockAnalyticsHubService.addException(exception);
173 
174     try {
175       String parent = "parent-995424086";
176       client.listDataExchanges(parent);
177       Assert.fail("No exception raised");
178     } catch (InvalidArgumentException e) {
179       // Expected exception.
180     }
181   }
182 
183   @Test
listOrgDataExchangesTest()184   public void listOrgDataExchangesTest() throws Exception {
185     DataExchange responsesElement = DataExchange.newBuilder().build();
186     ListOrgDataExchangesResponse expectedResponse =
187         ListOrgDataExchangesResponse.newBuilder()
188             .setNextPageToken("")
189             .addAllDataExchanges(Arrays.asList(responsesElement))
190             .build();
191     mockAnalyticsHubService.addResponse(expectedResponse);
192 
193     String organization = "organization1178922291";
194 
195     ListOrgDataExchangesPagedResponse pagedListResponse = client.listOrgDataExchanges(organization);
196 
197     List<DataExchange> resources = Lists.newArrayList(pagedListResponse.iterateAll());
198 
199     Assert.assertEquals(1, resources.size());
200     Assert.assertEquals(expectedResponse.getDataExchangesList().get(0), resources.get(0));
201 
202     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
203     Assert.assertEquals(1, actualRequests.size());
204     ListOrgDataExchangesRequest actualRequest =
205         ((ListOrgDataExchangesRequest) actualRequests.get(0));
206 
207     Assert.assertEquals(organization, actualRequest.getOrganization());
208     Assert.assertTrue(
209         channelProvider.isHeaderSent(
210             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
211             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
212   }
213 
214   @Test
listOrgDataExchangesExceptionTest()215   public void listOrgDataExchangesExceptionTest() throws Exception {
216     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
217     mockAnalyticsHubService.addException(exception);
218 
219     try {
220       String organization = "organization1178922291";
221       client.listOrgDataExchanges(organization);
222       Assert.fail("No exception raised");
223     } catch (InvalidArgumentException e) {
224       // Expected exception.
225     }
226   }
227 
228   @Test
getDataExchangeTest()229   public void getDataExchangeTest() throws Exception {
230     DataExchange expectedResponse =
231         DataExchange.newBuilder()
232             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
233             .setDisplayName("displayName1714148973")
234             .setDescription("description-1724546052")
235             .setPrimaryContact("primaryContact-532068418")
236             .setDocumentation("documentation1587405498")
237             .setListingCount(-1101038700)
238             .setIcon(ByteString.EMPTY)
239             .build();
240     mockAnalyticsHubService.addResponse(expectedResponse);
241 
242     DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
243 
244     DataExchange actualResponse = client.getDataExchange(name);
245     Assert.assertEquals(expectedResponse, actualResponse);
246 
247     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
248     Assert.assertEquals(1, actualRequests.size());
249     GetDataExchangeRequest actualRequest = ((GetDataExchangeRequest) actualRequests.get(0));
250 
251     Assert.assertEquals(name.toString(), actualRequest.getName());
252     Assert.assertTrue(
253         channelProvider.isHeaderSent(
254             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
255             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
256   }
257 
258   @Test
getDataExchangeExceptionTest()259   public void getDataExchangeExceptionTest() throws Exception {
260     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
261     mockAnalyticsHubService.addException(exception);
262 
263     try {
264       DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
265       client.getDataExchange(name);
266       Assert.fail("No exception raised");
267     } catch (InvalidArgumentException e) {
268       // Expected exception.
269     }
270   }
271 
272   @Test
getDataExchangeTest2()273   public void getDataExchangeTest2() throws Exception {
274     DataExchange expectedResponse =
275         DataExchange.newBuilder()
276             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
277             .setDisplayName("displayName1714148973")
278             .setDescription("description-1724546052")
279             .setPrimaryContact("primaryContact-532068418")
280             .setDocumentation("documentation1587405498")
281             .setListingCount(-1101038700)
282             .setIcon(ByteString.EMPTY)
283             .build();
284     mockAnalyticsHubService.addResponse(expectedResponse);
285 
286     String name = "name3373707";
287 
288     DataExchange actualResponse = client.getDataExchange(name);
289     Assert.assertEquals(expectedResponse, actualResponse);
290 
291     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
292     Assert.assertEquals(1, actualRequests.size());
293     GetDataExchangeRequest actualRequest = ((GetDataExchangeRequest) actualRequests.get(0));
294 
295     Assert.assertEquals(name, actualRequest.getName());
296     Assert.assertTrue(
297         channelProvider.isHeaderSent(
298             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
299             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
300   }
301 
302   @Test
getDataExchangeExceptionTest2()303   public void getDataExchangeExceptionTest2() throws Exception {
304     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
305     mockAnalyticsHubService.addException(exception);
306 
307     try {
308       String name = "name3373707";
309       client.getDataExchange(name);
310       Assert.fail("No exception raised");
311     } catch (InvalidArgumentException e) {
312       // Expected exception.
313     }
314   }
315 
316   @Test
createDataExchangeTest()317   public void createDataExchangeTest() throws Exception {
318     DataExchange expectedResponse =
319         DataExchange.newBuilder()
320             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
321             .setDisplayName("displayName1714148973")
322             .setDescription("description-1724546052")
323             .setPrimaryContact("primaryContact-532068418")
324             .setDocumentation("documentation1587405498")
325             .setListingCount(-1101038700)
326             .setIcon(ByteString.EMPTY)
327             .build();
328     mockAnalyticsHubService.addResponse(expectedResponse);
329 
330     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
331     DataExchange dataExchange = DataExchange.newBuilder().build();
332 
333     DataExchange actualResponse = client.createDataExchange(parent, dataExchange);
334     Assert.assertEquals(expectedResponse, actualResponse);
335 
336     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
337     Assert.assertEquals(1, actualRequests.size());
338     CreateDataExchangeRequest actualRequest = ((CreateDataExchangeRequest) actualRequests.get(0));
339 
340     Assert.assertEquals(parent.toString(), actualRequest.getParent());
341     Assert.assertEquals(dataExchange, actualRequest.getDataExchange());
342     Assert.assertTrue(
343         channelProvider.isHeaderSent(
344             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
345             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
346   }
347 
348   @Test
createDataExchangeExceptionTest()349   public void createDataExchangeExceptionTest() throws Exception {
350     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
351     mockAnalyticsHubService.addException(exception);
352 
353     try {
354       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
355       DataExchange dataExchange = DataExchange.newBuilder().build();
356       client.createDataExchange(parent, dataExchange);
357       Assert.fail("No exception raised");
358     } catch (InvalidArgumentException e) {
359       // Expected exception.
360     }
361   }
362 
363   @Test
createDataExchangeTest2()364   public void createDataExchangeTest2() throws Exception {
365     DataExchange expectedResponse =
366         DataExchange.newBuilder()
367             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
368             .setDisplayName("displayName1714148973")
369             .setDescription("description-1724546052")
370             .setPrimaryContact("primaryContact-532068418")
371             .setDocumentation("documentation1587405498")
372             .setListingCount(-1101038700)
373             .setIcon(ByteString.EMPTY)
374             .build();
375     mockAnalyticsHubService.addResponse(expectedResponse);
376 
377     String parent = "parent-995424086";
378     DataExchange dataExchange = DataExchange.newBuilder().build();
379 
380     DataExchange actualResponse = client.createDataExchange(parent, dataExchange);
381     Assert.assertEquals(expectedResponse, actualResponse);
382 
383     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
384     Assert.assertEquals(1, actualRequests.size());
385     CreateDataExchangeRequest actualRequest = ((CreateDataExchangeRequest) actualRequests.get(0));
386 
387     Assert.assertEquals(parent, actualRequest.getParent());
388     Assert.assertEquals(dataExchange, actualRequest.getDataExchange());
389     Assert.assertTrue(
390         channelProvider.isHeaderSent(
391             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
392             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
393   }
394 
395   @Test
createDataExchangeExceptionTest2()396   public void createDataExchangeExceptionTest2() throws Exception {
397     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
398     mockAnalyticsHubService.addException(exception);
399 
400     try {
401       String parent = "parent-995424086";
402       DataExchange dataExchange = DataExchange.newBuilder().build();
403       client.createDataExchange(parent, dataExchange);
404       Assert.fail("No exception raised");
405     } catch (InvalidArgumentException e) {
406       // Expected exception.
407     }
408   }
409 
410   @Test
updateDataExchangeTest()411   public void updateDataExchangeTest() throws Exception {
412     DataExchange expectedResponse =
413         DataExchange.newBuilder()
414             .setName(DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
415             .setDisplayName("displayName1714148973")
416             .setDescription("description-1724546052")
417             .setPrimaryContact("primaryContact-532068418")
418             .setDocumentation("documentation1587405498")
419             .setListingCount(-1101038700)
420             .setIcon(ByteString.EMPTY)
421             .build();
422     mockAnalyticsHubService.addResponse(expectedResponse);
423 
424     DataExchange dataExchange = DataExchange.newBuilder().build();
425     FieldMask updateMask = FieldMask.newBuilder().build();
426 
427     DataExchange actualResponse = client.updateDataExchange(dataExchange, updateMask);
428     Assert.assertEquals(expectedResponse, actualResponse);
429 
430     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
431     Assert.assertEquals(1, actualRequests.size());
432     UpdateDataExchangeRequest actualRequest = ((UpdateDataExchangeRequest) actualRequests.get(0));
433 
434     Assert.assertEquals(dataExchange, actualRequest.getDataExchange());
435     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
436     Assert.assertTrue(
437         channelProvider.isHeaderSent(
438             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
439             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
440   }
441 
442   @Test
updateDataExchangeExceptionTest()443   public void updateDataExchangeExceptionTest() throws Exception {
444     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
445     mockAnalyticsHubService.addException(exception);
446 
447     try {
448       DataExchange dataExchange = DataExchange.newBuilder().build();
449       FieldMask updateMask = FieldMask.newBuilder().build();
450       client.updateDataExchange(dataExchange, updateMask);
451       Assert.fail("No exception raised");
452     } catch (InvalidArgumentException e) {
453       // Expected exception.
454     }
455   }
456 
457   @Test
deleteDataExchangeTest()458   public void deleteDataExchangeTest() throws Exception {
459     Empty expectedResponse = Empty.newBuilder().build();
460     mockAnalyticsHubService.addResponse(expectedResponse);
461 
462     DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
463 
464     client.deleteDataExchange(name);
465 
466     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
467     Assert.assertEquals(1, actualRequests.size());
468     DeleteDataExchangeRequest actualRequest = ((DeleteDataExchangeRequest) actualRequests.get(0));
469 
470     Assert.assertEquals(name.toString(), actualRequest.getName());
471     Assert.assertTrue(
472         channelProvider.isHeaderSent(
473             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
474             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
475   }
476 
477   @Test
deleteDataExchangeExceptionTest()478   public void deleteDataExchangeExceptionTest() throws Exception {
479     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
480     mockAnalyticsHubService.addException(exception);
481 
482     try {
483       DataExchangeName name = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
484       client.deleteDataExchange(name);
485       Assert.fail("No exception raised");
486     } catch (InvalidArgumentException e) {
487       // Expected exception.
488     }
489   }
490 
491   @Test
deleteDataExchangeTest2()492   public void deleteDataExchangeTest2() throws Exception {
493     Empty expectedResponse = Empty.newBuilder().build();
494     mockAnalyticsHubService.addResponse(expectedResponse);
495 
496     String name = "name3373707";
497 
498     client.deleteDataExchange(name);
499 
500     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
501     Assert.assertEquals(1, actualRequests.size());
502     DeleteDataExchangeRequest actualRequest = ((DeleteDataExchangeRequest) actualRequests.get(0));
503 
504     Assert.assertEquals(name, actualRequest.getName());
505     Assert.assertTrue(
506         channelProvider.isHeaderSent(
507             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
508             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
509   }
510 
511   @Test
deleteDataExchangeExceptionTest2()512   public void deleteDataExchangeExceptionTest2() throws Exception {
513     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
514     mockAnalyticsHubService.addException(exception);
515 
516     try {
517       String name = "name3373707";
518       client.deleteDataExchange(name);
519       Assert.fail("No exception raised");
520     } catch (InvalidArgumentException e) {
521       // Expected exception.
522     }
523   }
524 
525   @Test
listListingsTest()526   public void listListingsTest() throws Exception {
527     Listing responsesElement = Listing.newBuilder().build();
528     ListListingsResponse expectedResponse =
529         ListListingsResponse.newBuilder()
530             .setNextPageToken("")
531             .addAllListings(Arrays.asList(responsesElement))
532             .build();
533     mockAnalyticsHubService.addResponse(expectedResponse);
534 
535     DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
536 
537     ListListingsPagedResponse pagedListResponse = client.listListings(parent);
538 
539     List<Listing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
540 
541     Assert.assertEquals(1, resources.size());
542     Assert.assertEquals(expectedResponse.getListingsList().get(0), resources.get(0));
543 
544     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
545     Assert.assertEquals(1, actualRequests.size());
546     ListListingsRequest actualRequest = ((ListListingsRequest) actualRequests.get(0));
547 
548     Assert.assertEquals(parent.toString(), actualRequest.getParent());
549     Assert.assertTrue(
550         channelProvider.isHeaderSent(
551             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
552             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
553   }
554 
555   @Test
listListingsExceptionTest()556   public void listListingsExceptionTest() throws Exception {
557     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
558     mockAnalyticsHubService.addException(exception);
559 
560     try {
561       DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
562       client.listListings(parent);
563       Assert.fail("No exception raised");
564     } catch (InvalidArgumentException e) {
565       // Expected exception.
566     }
567   }
568 
569   @Test
listListingsTest2()570   public void listListingsTest2() throws Exception {
571     Listing responsesElement = Listing.newBuilder().build();
572     ListListingsResponse expectedResponse =
573         ListListingsResponse.newBuilder()
574             .setNextPageToken("")
575             .addAllListings(Arrays.asList(responsesElement))
576             .build();
577     mockAnalyticsHubService.addResponse(expectedResponse);
578 
579     String parent = "parent-995424086";
580 
581     ListListingsPagedResponse pagedListResponse = client.listListings(parent);
582 
583     List<Listing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
584 
585     Assert.assertEquals(1, resources.size());
586     Assert.assertEquals(expectedResponse.getListingsList().get(0), resources.get(0));
587 
588     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
589     Assert.assertEquals(1, actualRequests.size());
590     ListListingsRequest actualRequest = ((ListListingsRequest) actualRequests.get(0));
591 
592     Assert.assertEquals(parent, actualRequest.getParent());
593     Assert.assertTrue(
594         channelProvider.isHeaderSent(
595             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
596             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
597   }
598 
599   @Test
listListingsExceptionTest2()600   public void listListingsExceptionTest2() throws Exception {
601     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
602     mockAnalyticsHubService.addException(exception);
603 
604     try {
605       String parent = "parent-995424086";
606       client.listListings(parent);
607       Assert.fail("No exception raised");
608     } catch (InvalidArgumentException e) {
609       // Expected exception.
610     }
611   }
612 
613   @Test
getListingTest()614   public void getListingTest() throws Exception {
615     Listing expectedResponse =
616         Listing.newBuilder()
617             .setName(
618                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
619                     .toString())
620             .setDisplayName("displayName1714148973")
621             .setDescription("description-1724546052")
622             .setPrimaryContact("primaryContact-532068418")
623             .setDocumentation("documentation1587405498")
624             .setIcon(ByteString.EMPTY)
625             .setDataProvider(DataProvider.newBuilder().build())
626             .addAllCategories(new ArrayList<Listing.Category>())
627             .setPublisher(Publisher.newBuilder().build())
628             .setRequestAccess("requestAccess871967955")
629             .build();
630     mockAnalyticsHubService.addResponse(expectedResponse);
631 
632     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
633 
634     Listing actualResponse = client.getListing(name);
635     Assert.assertEquals(expectedResponse, actualResponse);
636 
637     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
638     Assert.assertEquals(1, actualRequests.size());
639     GetListingRequest actualRequest = ((GetListingRequest) actualRequests.get(0));
640 
641     Assert.assertEquals(name.toString(), actualRequest.getName());
642     Assert.assertTrue(
643         channelProvider.isHeaderSent(
644             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
645             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
646   }
647 
648   @Test
getListingExceptionTest()649   public void getListingExceptionTest() throws Exception {
650     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
651     mockAnalyticsHubService.addException(exception);
652 
653     try {
654       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
655       client.getListing(name);
656       Assert.fail("No exception raised");
657     } catch (InvalidArgumentException e) {
658       // Expected exception.
659     }
660   }
661 
662   @Test
getListingTest2()663   public void getListingTest2() throws Exception {
664     Listing expectedResponse =
665         Listing.newBuilder()
666             .setName(
667                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
668                     .toString())
669             .setDisplayName("displayName1714148973")
670             .setDescription("description-1724546052")
671             .setPrimaryContact("primaryContact-532068418")
672             .setDocumentation("documentation1587405498")
673             .setIcon(ByteString.EMPTY)
674             .setDataProvider(DataProvider.newBuilder().build())
675             .addAllCategories(new ArrayList<Listing.Category>())
676             .setPublisher(Publisher.newBuilder().build())
677             .setRequestAccess("requestAccess871967955")
678             .build();
679     mockAnalyticsHubService.addResponse(expectedResponse);
680 
681     String name = "name3373707";
682 
683     Listing actualResponse = client.getListing(name);
684     Assert.assertEquals(expectedResponse, actualResponse);
685 
686     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
687     Assert.assertEquals(1, actualRequests.size());
688     GetListingRequest actualRequest = ((GetListingRequest) actualRequests.get(0));
689 
690     Assert.assertEquals(name, actualRequest.getName());
691     Assert.assertTrue(
692         channelProvider.isHeaderSent(
693             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
694             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
695   }
696 
697   @Test
getListingExceptionTest2()698   public void getListingExceptionTest2() throws Exception {
699     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
700     mockAnalyticsHubService.addException(exception);
701 
702     try {
703       String name = "name3373707";
704       client.getListing(name);
705       Assert.fail("No exception raised");
706     } catch (InvalidArgumentException e) {
707       // Expected exception.
708     }
709   }
710 
711   @Test
createListingTest()712   public void createListingTest() throws Exception {
713     Listing expectedResponse =
714         Listing.newBuilder()
715             .setName(
716                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
717                     .toString())
718             .setDisplayName("displayName1714148973")
719             .setDescription("description-1724546052")
720             .setPrimaryContact("primaryContact-532068418")
721             .setDocumentation("documentation1587405498")
722             .setIcon(ByteString.EMPTY)
723             .setDataProvider(DataProvider.newBuilder().build())
724             .addAllCategories(new ArrayList<Listing.Category>())
725             .setPublisher(Publisher.newBuilder().build())
726             .setRequestAccess("requestAccess871967955")
727             .build();
728     mockAnalyticsHubService.addResponse(expectedResponse);
729 
730     DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
731     Listing listing = Listing.newBuilder().build();
732 
733     Listing actualResponse = client.createListing(parent, listing);
734     Assert.assertEquals(expectedResponse, actualResponse);
735 
736     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
737     Assert.assertEquals(1, actualRequests.size());
738     CreateListingRequest actualRequest = ((CreateListingRequest) actualRequests.get(0));
739 
740     Assert.assertEquals(parent.toString(), actualRequest.getParent());
741     Assert.assertEquals(listing, actualRequest.getListing());
742     Assert.assertTrue(
743         channelProvider.isHeaderSent(
744             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
745             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
746   }
747 
748   @Test
createListingExceptionTest()749   public void createListingExceptionTest() throws Exception {
750     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
751     mockAnalyticsHubService.addException(exception);
752 
753     try {
754       DataExchangeName parent = DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]");
755       Listing listing = Listing.newBuilder().build();
756       client.createListing(parent, listing);
757       Assert.fail("No exception raised");
758     } catch (InvalidArgumentException e) {
759       // Expected exception.
760     }
761   }
762 
763   @Test
createListingTest2()764   public void createListingTest2() throws Exception {
765     Listing expectedResponse =
766         Listing.newBuilder()
767             .setName(
768                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
769                     .toString())
770             .setDisplayName("displayName1714148973")
771             .setDescription("description-1724546052")
772             .setPrimaryContact("primaryContact-532068418")
773             .setDocumentation("documentation1587405498")
774             .setIcon(ByteString.EMPTY)
775             .setDataProvider(DataProvider.newBuilder().build())
776             .addAllCategories(new ArrayList<Listing.Category>())
777             .setPublisher(Publisher.newBuilder().build())
778             .setRequestAccess("requestAccess871967955")
779             .build();
780     mockAnalyticsHubService.addResponse(expectedResponse);
781 
782     String parent = "parent-995424086";
783     Listing listing = Listing.newBuilder().build();
784 
785     Listing actualResponse = client.createListing(parent, listing);
786     Assert.assertEquals(expectedResponse, actualResponse);
787 
788     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
789     Assert.assertEquals(1, actualRequests.size());
790     CreateListingRequest actualRequest = ((CreateListingRequest) actualRequests.get(0));
791 
792     Assert.assertEquals(parent, actualRequest.getParent());
793     Assert.assertEquals(listing, actualRequest.getListing());
794     Assert.assertTrue(
795         channelProvider.isHeaderSent(
796             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
797             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
798   }
799 
800   @Test
createListingExceptionTest2()801   public void createListingExceptionTest2() throws Exception {
802     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
803     mockAnalyticsHubService.addException(exception);
804 
805     try {
806       String parent = "parent-995424086";
807       Listing listing = Listing.newBuilder().build();
808       client.createListing(parent, listing);
809       Assert.fail("No exception raised");
810     } catch (InvalidArgumentException e) {
811       // Expected exception.
812     }
813   }
814 
815   @Test
updateListingTest()816   public void updateListingTest() throws Exception {
817     Listing expectedResponse =
818         Listing.newBuilder()
819             .setName(
820                 ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]")
821                     .toString())
822             .setDisplayName("displayName1714148973")
823             .setDescription("description-1724546052")
824             .setPrimaryContact("primaryContact-532068418")
825             .setDocumentation("documentation1587405498")
826             .setIcon(ByteString.EMPTY)
827             .setDataProvider(DataProvider.newBuilder().build())
828             .addAllCategories(new ArrayList<Listing.Category>())
829             .setPublisher(Publisher.newBuilder().build())
830             .setRequestAccess("requestAccess871967955")
831             .build();
832     mockAnalyticsHubService.addResponse(expectedResponse);
833 
834     Listing listing = Listing.newBuilder().build();
835     FieldMask updateMask = FieldMask.newBuilder().build();
836 
837     Listing actualResponse = client.updateListing(listing, updateMask);
838     Assert.assertEquals(expectedResponse, actualResponse);
839 
840     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
841     Assert.assertEquals(1, actualRequests.size());
842     UpdateListingRequest actualRequest = ((UpdateListingRequest) actualRequests.get(0));
843 
844     Assert.assertEquals(listing, actualRequest.getListing());
845     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
846     Assert.assertTrue(
847         channelProvider.isHeaderSent(
848             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
849             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
850   }
851 
852   @Test
updateListingExceptionTest()853   public void updateListingExceptionTest() throws Exception {
854     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
855     mockAnalyticsHubService.addException(exception);
856 
857     try {
858       Listing listing = Listing.newBuilder().build();
859       FieldMask updateMask = FieldMask.newBuilder().build();
860       client.updateListing(listing, updateMask);
861       Assert.fail("No exception raised");
862     } catch (InvalidArgumentException e) {
863       // Expected exception.
864     }
865   }
866 
867   @Test
deleteListingTest()868   public void deleteListingTest() throws Exception {
869     Empty expectedResponse = Empty.newBuilder().build();
870     mockAnalyticsHubService.addResponse(expectedResponse);
871 
872     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
873 
874     client.deleteListing(name);
875 
876     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
877     Assert.assertEquals(1, actualRequests.size());
878     DeleteListingRequest actualRequest = ((DeleteListingRequest) actualRequests.get(0));
879 
880     Assert.assertEquals(name.toString(), actualRequest.getName());
881     Assert.assertTrue(
882         channelProvider.isHeaderSent(
883             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
884             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
885   }
886 
887   @Test
deleteListingExceptionTest()888   public void deleteListingExceptionTest() throws Exception {
889     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
890     mockAnalyticsHubService.addException(exception);
891 
892     try {
893       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
894       client.deleteListing(name);
895       Assert.fail("No exception raised");
896     } catch (InvalidArgumentException e) {
897       // Expected exception.
898     }
899   }
900 
901   @Test
deleteListingTest2()902   public void deleteListingTest2() throws Exception {
903     Empty expectedResponse = Empty.newBuilder().build();
904     mockAnalyticsHubService.addResponse(expectedResponse);
905 
906     String name = "name3373707";
907 
908     client.deleteListing(name);
909 
910     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
911     Assert.assertEquals(1, actualRequests.size());
912     DeleteListingRequest actualRequest = ((DeleteListingRequest) actualRequests.get(0));
913 
914     Assert.assertEquals(name, actualRequest.getName());
915     Assert.assertTrue(
916         channelProvider.isHeaderSent(
917             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
918             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
919   }
920 
921   @Test
deleteListingExceptionTest2()922   public void deleteListingExceptionTest2() throws Exception {
923     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
924     mockAnalyticsHubService.addException(exception);
925 
926     try {
927       String name = "name3373707";
928       client.deleteListing(name);
929       Assert.fail("No exception raised");
930     } catch (InvalidArgumentException e) {
931       // Expected exception.
932     }
933   }
934 
935   @Test
subscribeListingTest()936   public void subscribeListingTest() throws Exception {
937     SubscribeListingResponse expectedResponse = SubscribeListingResponse.newBuilder().build();
938     mockAnalyticsHubService.addResponse(expectedResponse);
939 
940     ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
941 
942     SubscribeListingResponse actualResponse = client.subscribeListing(name);
943     Assert.assertEquals(expectedResponse, actualResponse);
944 
945     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
946     Assert.assertEquals(1, actualRequests.size());
947     SubscribeListingRequest actualRequest = ((SubscribeListingRequest) actualRequests.get(0));
948 
949     Assert.assertEquals(name.toString(), actualRequest.getName());
950     Assert.assertTrue(
951         channelProvider.isHeaderSent(
952             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
953             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
954   }
955 
956   @Test
subscribeListingExceptionTest()957   public void subscribeListingExceptionTest() throws Exception {
958     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
959     mockAnalyticsHubService.addException(exception);
960 
961     try {
962       ListingName name = ListingName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]", "[LISTING]");
963       client.subscribeListing(name);
964       Assert.fail("No exception raised");
965     } catch (InvalidArgumentException e) {
966       // Expected exception.
967     }
968   }
969 
970   @Test
subscribeListingTest2()971   public void subscribeListingTest2() throws Exception {
972     SubscribeListingResponse expectedResponse = SubscribeListingResponse.newBuilder().build();
973     mockAnalyticsHubService.addResponse(expectedResponse);
974 
975     String name = "name3373707";
976 
977     SubscribeListingResponse actualResponse = client.subscribeListing(name);
978     Assert.assertEquals(expectedResponse, actualResponse);
979 
980     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
981     Assert.assertEquals(1, actualRequests.size());
982     SubscribeListingRequest actualRequest = ((SubscribeListingRequest) actualRequests.get(0));
983 
984     Assert.assertEquals(name, actualRequest.getName());
985     Assert.assertTrue(
986         channelProvider.isHeaderSent(
987             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
988             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
989   }
990 
991   @Test
subscribeListingExceptionTest2()992   public void subscribeListingExceptionTest2() throws Exception {
993     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
994     mockAnalyticsHubService.addException(exception);
995 
996     try {
997       String name = "name3373707";
998       client.subscribeListing(name);
999       Assert.fail("No exception raised");
1000     } catch (InvalidArgumentException e) {
1001       // Expected exception.
1002     }
1003   }
1004 
1005   @Test
getIamPolicyTest()1006   public void getIamPolicyTest() throws Exception {
1007     Policy expectedResponse =
1008         Policy.newBuilder()
1009             .setVersion(351608024)
1010             .addAllBindings(new ArrayList<Binding>())
1011             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1012             .setEtag(ByteString.EMPTY)
1013             .build();
1014     mockAnalyticsHubService.addResponse(expectedResponse);
1015 
1016     GetIamPolicyRequest request =
1017         GetIamPolicyRequest.newBuilder()
1018             .setResource(
1019                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1020             .setOptions(GetPolicyOptions.newBuilder().build())
1021             .build();
1022 
1023     Policy actualResponse = client.getIamPolicy(request);
1024     Assert.assertEquals(expectedResponse, actualResponse);
1025 
1026     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
1027     Assert.assertEquals(1, actualRequests.size());
1028     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1029 
1030     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1031     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
1032     Assert.assertTrue(
1033         channelProvider.isHeaderSent(
1034             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1035             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1036   }
1037 
1038   @Test
getIamPolicyExceptionTest()1039   public void getIamPolicyExceptionTest() throws Exception {
1040     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1041     mockAnalyticsHubService.addException(exception);
1042 
1043     try {
1044       GetIamPolicyRequest request =
1045           GetIamPolicyRequest.newBuilder()
1046               .setResource(
1047                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1048               .setOptions(GetPolicyOptions.newBuilder().build())
1049               .build();
1050       client.getIamPolicy(request);
1051       Assert.fail("No exception raised");
1052     } catch (InvalidArgumentException e) {
1053       // Expected exception.
1054     }
1055   }
1056 
1057   @Test
setIamPolicyTest()1058   public void setIamPolicyTest() throws Exception {
1059     Policy expectedResponse =
1060         Policy.newBuilder()
1061             .setVersion(351608024)
1062             .addAllBindings(new ArrayList<Binding>())
1063             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1064             .setEtag(ByteString.EMPTY)
1065             .build();
1066     mockAnalyticsHubService.addResponse(expectedResponse);
1067 
1068     SetIamPolicyRequest request =
1069         SetIamPolicyRequest.newBuilder()
1070             .setResource(
1071                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1072             .setPolicy(Policy.newBuilder().build())
1073             .setUpdateMask(FieldMask.newBuilder().build())
1074             .build();
1075 
1076     Policy actualResponse = client.setIamPolicy(request);
1077     Assert.assertEquals(expectedResponse, actualResponse);
1078 
1079     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
1080     Assert.assertEquals(1, actualRequests.size());
1081     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1082 
1083     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1084     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1085     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1086     Assert.assertTrue(
1087         channelProvider.isHeaderSent(
1088             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1089             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1090   }
1091 
1092   @Test
setIamPolicyExceptionTest()1093   public void setIamPolicyExceptionTest() throws Exception {
1094     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1095     mockAnalyticsHubService.addException(exception);
1096 
1097     try {
1098       SetIamPolicyRequest request =
1099           SetIamPolicyRequest.newBuilder()
1100               .setResource(
1101                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1102               .setPolicy(Policy.newBuilder().build())
1103               .setUpdateMask(FieldMask.newBuilder().build())
1104               .build();
1105       client.setIamPolicy(request);
1106       Assert.fail("No exception raised");
1107     } catch (InvalidArgumentException e) {
1108       // Expected exception.
1109     }
1110   }
1111 
1112   @Test
testIamPermissionsTest()1113   public void testIamPermissionsTest() throws Exception {
1114     TestIamPermissionsResponse expectedResponse =
1115         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1116     mockAnalyticsHubService.addResponse(expectedResponse);
1117 
1118     TestIamPermissionsRequest request =
1119         TestIamPermissionsRequest.newBuilder()
1120             .setResource(
1121                 DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1122             .addAllPermissions(new ArrayList<String>())
1123             .build();
1124 
1125     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1126     Assert.assertEquals(expectedResponse, actualResponse);
1127 
1128     List<AbstractMessage> actualRequests = mockAnalyticsHubService.getRequests();
1129     Assert.assertEquals(1, actualRequests.size());
1130     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1131 
1132     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1133     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
1134     Assert.assertTrue(
1135         channelProvider.isHeaderSent(
1136             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1137             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1138   }
1139 
1140   @Test
testIamPermissionsExceptionTest()1141   public void testIamPermissionsExceptionTest() throws Exception {
1142     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1143     mockAnalyticsHubService.addException(exception);
1144 
1145     try {
1146       TestIamPermissionsRequest request =
1147           TestIamPermissionsRequest.newBuilder()
1148               .setResource(
1149                   DataExchangeName.of("[PROJECT]", "[LOCATION]", "[DATA_EXCHANGE]").toString())
1150               .addAllPermissions(new ArrayList<String>())
1151               .build();
1152       client.testIamPermissions(request);
1153       Assert.fail("No exception raised");
1154     } catch (InvalidArgumentException e) {
1155       // Expected exception.
1156     }
1157   }
1158 }
1159