• 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.identity.accesscontextmanager.v1;
18 
19 import static com.google.identity.accesscontextmanager.v1.AccessContextManagerClient.ListAccessLevelsPagedResponse;
20 import static com.google.identity.accesscontextmanager.v1.AccessContextManagerClient.ListAccessPoliciesPagedResponse;
21 import static com.google.identity.accesscontextmanager.v1.AccessContextManagerClient.ListGcpUserAccessBindingsPagedResponse;
22 import static com.google.identity.accesscontextmanager.v1.AccessContextManagerClient.ListServicePerimetersPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.grpc.GaxGrpcProperties;
26 import com.google.api.gax.grpc.testing.LocalChannelProvider;
27 import com.google.api.gax.grpc.testing.MockGrpcService;
28 import com.google.api.gax.grpc.testing.MockServiceHelper;
29 import com.google.api.gax.rpc.ApiClientHeaderProvider;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.common.collect.Lists;
33 import com.google.iam.v1.AuditConfig;
34 import com.google.iam.v1.Binding;
35 import com.google.iam.v1.GetIamPolicyRequest;
36 import com.google.iam.v1.GetPolicyOptions;
37 import com.google.iam.v1.Policy;
38 import com.google.iam.v1.SetIamPolicyRequest;
39 import com.google.iam.v1.TestIamPermissionsRequest;
40 import com.google.iam.v1.TestIamPermissionsResponse;
41 import com.google.longrunning.Operation;
42 import com.google.protobuf.AbstractMessage;
43 import com.google.protobuf.Any;
44 import com.google.protobuf.ByteString;
45 import com.google.protobuf.Empty;
46 import com.google.protobuf.FieldMask;
47 import com.google.protobuf.Timestamp;
48 import io.grpc.StatusRuntimeException;
49 import java.io.IOException;
50 import java.util.ArrayList;
51 import java.util.Arrays;
52 import java.util.List;
53 import java.util.UUID;
54 import java.util.concurrent.ExecutionException;
55 import javax.annotation.Generated;
56 import org.junit.After;
57 import org.junit.AfterClass;
58 import org.junit.Assert;
59 import org.junit.Before;
60 import org.junit.BeforeClass;
61 import org.junit.Test;
62 
63 @Generated("by gapic-generator-java")
64 public class AccessContextManagerClientTest {
65   private static MockAccessContextManager mockAccessContextManager;
66   private static MockServiceHelper mockServiceHelper;
67   private LocalChannelProvider channelProvider;
68   private AccessContextManagerClient client;
69 
70   @BeforeClass
startStaticServer()71   public static void startStaticServer() {
72     mockAccessContextManager = new MockAccessContextManager();
73     mockServiceHelper =
74         new MockServiceHelper(
75             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockAccessContextManager));
76     mockServiceHelper.start();
77   }
78 
79   @AfterClass
stopServer()80   public static void stopServer() {
81     mockServiceHelper.stop();
82   }
83 
84   @Before
setUp()85   public void setUp() throws IOException {
86     mockServiceHelper.reset();
87     channelProvider = mockServiceHelper.createChannelProvider();
88     AccessContextManagerSettings settings =
89         AccessContextManagerSettings.newBuilder()
90             .setTransportChannelProvider(channelProvider)
91             .setCredentialsProvider(NoCredentialsProvider.create())
92             .build();
93     client = AccessContextManagerClient.create(settings);
94   }
95 
96   @After
tearDown()97   public void tearDown() throws Exception {
98     client.close();
99   }
100 
101   @Test
listAccessPoliciesTest()102   public void listAccessPoliciesTest() throws Exception {
103     AccessPolicy responsesElement = AccessPolicy.newBuilder().build();
104     ListAccessPoliciesResponse expectedResponse =
105         ListAccessPoliciesResponse.newBuilder()
106             .setNextPageToken("")
107             .addAllAccessPolicies(Arrays.asList(responsesElement))
108             .build();
109     mockAccessContextManager.addResponse(expectedResponse);
110 
111     ListAccessPoliciesRequest request =
112         ListAccessPoliciesRequest.newBuilder()
113             .setParent(OrganizationName.of("[ORGANIZATION]").toString())
114             .setPageSize(883849137)
115             .setPageToken("pageToken873572522")
116             .build();
117 
118     ListAccessPoliciesPagedResponse pagedListResponse = client.listAccessPolicies(request);
119 
120     List<AccessPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
121 
122     Assert.assertEquals(1, resources.size());
123     Assert.assertEquals(expectedResponse.getAccessPoliciesList().get(0), resources.get(0));
124 
125     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
126     Assert.assertEquals(1, actualRequests.size());
127     ListAccessPoliciesRequest actualRequest = ((ListAccessPoliciesRequest) actualRequests.get(0));
128 
129     Assert.assertEquals(request.getParent(), actualRequest.getParent());
130     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
131     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
132     Assert.assertTrue(
133         channelProvider.isHeaderSent(
134             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
135             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
136   }
137 
138   @Test
listAccessPoliciesExceptionTest()139   public void listAccessPoliciesExceptionTest() throws Exception {
140     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
141     mockAccessContextManager.addException(exception);
142 
143     try {
144       ListAccessPoliciesRequest request =
145           ListAccessPoliciesRequest.newBuilder()
146               .setParent(OrganizationName.of("[ORGANIZATION]").toString())
147               .setPageSize(883849137)
148               .setPageToken("pageToken873572522")
149               .build();
150       client.listAccessPolicies(request);
151       Assert.fail("No exception raised");
152     } catch (InvalidArgumentException e) {
153       // Expected exception.
154     }
155   }
156 
157   @Test
getAccessPolicyTest()158   public void getAccessPolicyTest() throws Exception {
159     AccessPolicy expectedResponse =
160         AccessPolicy.newBuilder()
161             .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
162             .setParent("parent-995424086")
163             .setTitle("title110371416")
164             .addAllScopes(new ArrayList<String>())
165             .setCreateTime(Timestamp.newBuilder().build())
166             .setUpdateTime(Timestamp.newBuilder().build())
167             .setEtag("etag3123477")
168             .build();
169     mockAccessContextManager.addResponse(expectedResponse);
170 
171     AccessPolicyName name = AccessPolicyName.of("[ACCESS_POLICY]");
172 
173     AccessPolicy actualResponse = client.getAccessPolicy(name);
174     Assert.assertEquals(expectedResponse, actualResponse);
175 
176     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
177     Assert.assertEquals(1, actualRequests.size());
178     GetAccessPolicyRequest actualRequest = ((GetAccessPolicyRequest) actualRequests.get(0));
179 
180     Assert.assertEquals(name.toString(), actualRequest.getName());
181     Assert.assertTrue(
182         channelProvider.isHeaderSent(
183             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
184             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
185   }
186 
187   @Test
getAccessPolicyExceptionTest()188   public void getAccessPolicyExceptionTest() throws Exception {
189     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
190     mockAccessContextManager.addException(exception);
191 
192     try {
193       AccessPolicyName name = AccessPolicyName.of("[ACCESS_POLICY]");
194       client.getAccessPolicy(name);
195       Assert.fail("No exception raised");
196     } catch (InvalidArgumentException e) {
197       // Expected exception.
198     }
199   }
200 
201   @Test
getAccessPolicyTest2()202   public void getAccessPolicyTest2() throws Exception {
203     AccessPolicy expectedResponse =
204         AccessPolicy.newBuilder()
205             .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
206             .setParent("parent-995424086")
207             .setTitle("title110371416")
208             .addAllScopes(new ArrayList<String>())
209             .setCreateTime(Timestamp.newBuilder().build())
210             .setUpdateTime(Timestamp.newBuilder().build())
211             .setEtag("etag3123477")
212             .build();
213     mockAccessContextManager.addResponse(expectedResponse);
214 
215     String name = "name3373707";
216 
217     AccessPolicy actualResponse = client.getAccessPolicy(name);
218     Assert.assertEquals(expectedResponse, actualResponse);
219 
220     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
221     Assert.assertEquals(1, actualRequests.size());
222     GetAccessPolicyRequest actualRequest = ((GetAccessPolicyRequest) actualRequests.get(0));
223 
224     Assert.assertEquals(name, actualRequest.getName());
225     Assert.assertTrue(
226         channelProvider.isHeaderSent(
227             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
228             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
229   }
230 
231   @Test
getAccessPolicyExceptionTest2()232   public void getAccessPolicyExceptionTest2() throws Exception {
233     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
234     mockAccessContextManager.addException(exception);
235 
236     try {
237       String name = "name3373707";
238       client.getAccessPolicy(name);
239       Assert.fail("No exception raised");
240     } catch (InvalidArgumentException e) {
241       // Expected exception.
242     }
243   }
244 
245   @Test
createAccessPolicyTest()246   public void createAccessPolicyTest() throws Exception {
247     AccessPolicy expectedResponse =
248         AccessPolicy.newBuilder()
249             .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
250             .setParent("parent-995424086")
251             .setTitle("title110371416")
252             .addAllScopes(new ArrayList<String>())
253             .setCreateTime(Timestamp.newBuilder().build())
254             .setUpdateTime(Timestamp.newBuilder().build())
255             .setEtag("etag3123477")
256             .build();
257     Operation resultOperation =
258         Operation.newBuilder()
259             .setName("createAccessPolicyTest")
260             .setDone(true)
261             .setResponse(Any.pack(expectedResponse))
262             .build();
263     mockAccessContextManager.addResponse(resultOperation);
264 
265     AccessPolicy request =
266         AccessPolicy.newBuilder()
267             .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
268             .setParent("parent-995424086")
269             .setTitle("title110371416")
270             .addAllScopes(new ArrayList<String>())
271             .setCreateTime(Timestamp.newBuilder().build())
272             .setUpdateTime(Timestamp.newBuilder().build())
273             .setEtag("etag3123477")
274             .build();
275 
276     AccessPolicy actualResponse = client.createAccessPolicyAsync(request).get();
277     Assert.assertEquals(expectedResponse, actualResponse);
278 
279     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
280     Assert.assertEquals(1, actualRequests.size());
281     AccessPolicy actualRequest = ((AccessPolicy) actualRequests.get(0));
282 
283     Assert.assertEquals(request.getName(), actualRequest.getName());
284     Assert.assertEquals(request.getParent(), actualRequest.getParent());
285     Assert.assertEquals(request.getTitle(), actualRequest.getTitle());
286     Assert.assertEquals(request.getScopesList(), actualRequest.getScopesList());
287     Assert.assertEquals(request.getCreateTime(), actualRequest.getCreateTime());
288     Assert.assertEquals(request.getUpdateTime(), actualRequest.getUpdateTime());
289     Assert.assertEquals(request.getEtag(), actualRequest.getEtag());
290     Assert.assertTrue(
291         channelProvider.isHeaderSent(
292             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
293             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
294   }
295 
296   @Test
createAccessPolicyExceptionTest()297   public void createAccessPolicyExceptionTest() throws Exception {
298     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
299     mockAccessContextManager.addException(exception);
300 
301     try {
302       AccessPolicy request =
303           AccessPolicy.newBuilder()
304               .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
305               .setParent("parent-995424086")
306               .setTitle("title110371416")
307               .addAllScopes(new ArrayList<String>())
308               .setCreateTime(Timestamp.newBuilder().build())
309               .setUpdateTime(Timestamp.newBuilder().build())
310               .setEtag("etag3123477")
311               .build();
312       client.createAccessPolicyAsync(request).get();
313       Assert.fail("No exception raised");
314     } catch (ExecutionException e) {
315       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
316       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
317       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
318     }
319   }
320 
321   @Test
updateAccessPolicyTest()322   public void updateAccessPolicyTest() throws Exception {
323     AccessPolicy expectedResponse =
324         AccessPolicy.newBuilder()
325             .setName(AccessPolicyName.of("[ACCESS_POLICY]").toString())
326             .setParent("parent-995424086")
327             .setTitle("title110371416")
328             .addAllScopes(new ArrayList<String>())
329             .setCreateTime(Timestamp.newBuilder().build())
330             .setUpdateTime(Timestamp.newBuilder().build())
331             .setEtag("etag3123477")
332             .build();
333     Operation resultOperation =
334         Operation.newBuilder()
335             .setName("updateAccessPolicyTest")
336             .setDone(true)
337             .setResponse(Any.pack(expectedResponse))
338             .build();
339     mockAccessContextManager.addResponse(resultOperation);
340 
341     AccessPolicy policy = AccessPolicy.newBuilder().build();
342     FieldMask updateMask = FieldMask.newBuilder().build();
343 
344     AccessPolicy actualResponse = client.updateAccessPolicyAsync(policy, updateMask).get();
345     Assert.assertEquals(expectedResponse, actualResponse);
346 
347     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
348     Assert.assertEquals(1, actualRequests.size());
349     UpdateAccessPolicyRequest actualRequest = ((UpdateAccessPolicyRequest) actualRequests.get(0));
350 
351     Assert.assertEquals(policy, actualRequest.getPolicy());
352     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
353     Assert.assertTrue(
354         channelProvider.isHeaderSent(
355             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
356             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
357   }
358 
359   @Test
updateAccessPolicyExceptionTest()360   public void updateAccessPolicyExceptionTest() throws Exception {
361     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
362     mockAccessContextManager.addException(exception);
363 
364     try {
365       AccessPolicy policy = AccessPolicy.newBuilder().build();
366       FieldMask updateMask = FieldMask.newBuilder().build();
367       client.updateAccessPolicyAsync(policy, updateMask).get();
368       Assert.fail("No exception raised");
369     } catch (ExecutionException e) {
370       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
371       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
372       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
373     }
374   }
375 
376   @Test
deleteAccessPolicyTest()377   public void deleteAccessPolicyTest() throws Exception {
378     Empty expectedResponse = Empty.newBuilder().build();
379     Operation resultOperation =
380         Operation.newBuilder()
381             .setName("deleteAccessPolicyTest")
382             .setDone(true)
383             .setResponse(Any.pack(expectedResponse))
384             .build();
385     mockAccessContextManager.addResponse(resultOperation);
386 
387     AccessPolicyName name = AccessPolicyName.of("[ACCESS_POLICY]");
388 
389     client.deleteAccessPolicyAsync(name).get();
390 
391     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
392     Assert.assertEquals(1, actualRequests.size());
393     DeleteAccessPolicyRequest actualRequest = ((DeleteAccessPolicyRequest) actualRequests.get(0));
394 
395     Assert.assertEquals(name.toString(), actualRequest.getName());
396     Assert.assertTrue(
397         channelProvider.isHeaderSent(
398             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
399             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
400   }
401 
402   @Test
deleteAccessPolicyExceptionTest()403   public void deleteAccessPolicyExceptionTest() throws Exception {
404     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
405     mockAccessContextManager.addException(exception);
406 
407     try {
408       AccessPolicyName name = AccessPolicyName.of("[ACCESS_POLICY]");
409       client.deleteAccessPolicyAsync(name).get();
410       Assert.fail("No exception raised");
411     } catch (ExecutionException e) {
412       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
413       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
414       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
415     }
416   }
417 
418   @Test
deleteAccessPolicyTest2()419   public void deleteAccessPolicyTest2() throws Exception {
420     Empty expectedResponse = Empty.newBuilder().build();
421     Operation resultOperation =
422         Operation.newBuilder()
423             .setName("deleteAccessPolicyTest")
424             .setDone(true)
425             .setResponse(Any.pack(expectedResponse))
426             .build();
427     mockAccessContextManager.addResponse(resultOperation);
428 
429     String name = "name3373707";
430 
431     client.deleteAccessPolicyAsync(name).get();
432 
433     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
434     Assert.assertEquals(1, actualRequests.size());
435     DeleteAccessPolicyRequest actualRequest = ((DeleteAccessPolicyRequest) actualRequests.get(0));
436 
437     Assert.assertEquals(name, actualRequest.getName());
438     Assert.assertTrue(
439         channelProvider.isHeaderSent(
440             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
441             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
442   }
443 
444   @Test
deleteAccessPolicyExceptionTest2()445   public void deleteAccessPolicyExceptionTest2() throws Exception {
446     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
447     mockAccessContextManager.addException(exception);
448 
449     try {
450       String name = "name3373707";
451       client.deleteAccessPolicyAsync(name).get();
452       Assert.fail("No exception raised");
453     } catch (ExecutionException e) {
454       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
455       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
456       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
457     }
458   }
459 
460   @Test
listAccessLevelsTest()461   public void listAccessLevelsTest() throws Exception {
462     AccessLevel responsesElement = AccessLevel.newBuilder().build();
463     ListAccessLevelsResponse expectedResponse =
464         ListAccessLevelsResponse.newBuilder()
465             .setNextPageToken("")
466             .addAllAccessLevels(Arrays.asList(responsesElement))
467             .build();
468     mockAccessContextManager.addResponse(expectedResponse);
469 
470     AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
471 
472     ListAccessLevelsPagedResponse pagedListResponse = client.listAccessLevels(parent);
473 
474     List<AccessLevel> resources = Lists.newArrayList(pagedListResponse.iterateAll());
475 
476     Assert.assertEquals(1, resources.size());
477     Assert.assertEquals(expectedResponse.getAccessLevelsList().get(0), resources.get(0));
478 
479     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
480     Assert.assertEquals(1, actualRequests.size());
481     ListAccessLevelsRequest actualRequest = ((ListAccessLevelsRequest) actualRequests.get(0));
482 
483     Assert.assertEquals(parent.toString(), actualRequest.getParent());
484     Assert.assertTrue(
485         channelProvider.isHeaderSent(
486             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
487             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
488   }
489 
490   @Test
listAccessLevelsExceptionTest()491   public void listAccessLevelsExceptionTest() throws Exception {
492     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
493     mockAccessContextManager.addException(exception);
494 
495     try {
496       AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
497       client.listAccessLevels(parent);
498       Assert.fail("No exception raised");
499     } catch (InvalidArgumentException e) {
500       // Expected exception.
501     }
502   }
503 
504   @Test
listAccessLevelsTest2()505   public void listAccessLevelsTest2() throws Exception {
506     AccessLevel responsesElement = AccessLevel.newBuilder().build();
507     ListAccessLevelsResponse expectedResponse =
508         ListAccessLevelsResponse.newBuilder()
509             .setNextPageToken("")
510             .addAllAccessLevels(Arrays.asList(responsesElement))
511             .build();
512     mockAccessContextManager.addResponse(expectedResponse);
513 
514     String parent = "parent-995424086";
515 
516     ListAccessLevelsPagedResponse pagedListResponse = client.listAccessLevels(parent);
517 
518     List<AccessLevel> resources = Lists.newArrayList(pagedListResponse.iterateAll());
519 
520     Assert.assertEquals(1, resources.size());
521     Assert.assertEquals(expectedResponse.getAccessLevelsList().get(0), resources.get(0));
522 
523     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
524     Assert.assertEquals(1, actualRequests.size());
525     ListAccessLevelsRequest actualRequest = ((ListAccessLevelsRequest) actualRequests.get(0));
526 
527     Assert.assertEquals(parent, actualRequest.getParent());
528     Assert.assertTrue(
529         channelProvider.isHeaderSent(
530             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
531             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
532   }
533 
534   @Test
listAccessLevelsExceptionTest2()535   public void listAccessLevelsExceptionTest2() throws Exception {
536     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
537     mockAccessContextManager.addException(exception);
538 
539     try {
540       String parent = "parent-995424086";
541       client.listAccessLevels(parent);
542       Assert.fail("No exception raised");
543     } catch (InvalidArgumentException e) {
544       // Expected exception.
545     }
546   }
547 
548   @Test
getAccessLevelTest()549   public void getAccessLevelTest() throws Exception {
550     AccessLevel expectedResponse =
551         AccessLevel.newBuilder()
552             .setName(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
553             .setTitle("title110371416")
554             .setDescription("description-1724546052")
555             .setCreateTime(Timestamp.newBuilder().build())
556             .setUpdateTime(Timestamp.newBuilder().build())
557             .build();
558     mockAccessContextManager.addResponse(expectedResponse);
559 
560     AccessLevelName name = AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
561 
562     AccessLevel actualResponse = client.getAccessLevel(name);
563     Assert.assertEquals(expectedResponse, actualResponse);
564 
565     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
566     Assert.assertEquals(1, actualRequests.size());
567     GetAccessLevelRequest actualRequest = ((GetAccessLevelRequest) actualRequests.get(0));
568 
569     Assert.assertEquals(name.toString(), actualRequest.getName());
570     Assert.assertTrue(
571         channelProvider.isHeaderSent(
572             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
573             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
574   }
575 
576   @Test
getAccessLevelExceptionTest()577   public void getAccessLevelExceptionTest() throws Exception {
578     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
579     mockAccessContextManager.addException(exception);
580 
581     try {
582       AccessLevelName name = AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
583       client.getAccessLevel(name);
584       Assert.fail("No exception raised");
585     } catch (InvalidArgumentException e) {
586       // Expected exception.
587     }
588   }
589 
590   @Test
getAccessLevelTest2()591   public void getAccessLevelTest2() throws Exception {
592     AccessLevel expectedResponse =
593         AccessLevel.newBuilder()
594             .setName(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
595             .setTitle("title110371416")
596             .setDescription("description-1724546052")
597             .setCreateTime(Timestamp.newBuilder().build())
598             .setUpdateTime(Timestamp.newBuilder().build())
599             .build();
600     mockAccessContextManager.addResponse(expectedResponse);
601 
602     String name = "name3373707";
603 
604     AccessLevel actualResponse = client.getAccessLevel(name);
605     Assert.assertEquals(expectedResponse, actualResponse);
606 
607     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
608     Assert.assertEquals(1, actualRequests.size());
609     GetAccessLevelRequest actualRequest = ((GetAccessLevelRequest) actualRequests.get(0));
610 
611     Assert.assertEquals(name, actualRequest.getName());
612     Assert.assertTrue(
613         channelProvider.isHeaderSent(
614             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
615             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
616   }
617 
618   @Test
getAccessLevelExceptionTest2()619   public void getAccessLevelExceptionTest2() throws Exception {
620     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
621     mockAccessContextManager.addException(exception);
622 
623     try {
624       String name = "name3373707";
625       client.getAccessLevel(name);
626       Assert.fail("No exception raised");
627     } catch (InvalidArgumentException e) {
628       // Expected exception.
629     }
630   }
631 
632   @Test
createAccessLevelTest()633   public void createAccessLevelTest() throws Exception {
634     AccessLevel expectedResponse =
635         AccessLevel.newBuilder()
636             .setName(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
637             .setTitle("title110371416")
638             .setDescription("description-1724546052")
639             .setCreateTime(Timestamp.newBuilder().build())
640             .setUpdateTime(Timestamp.newBuilder().build())
641             .build();
642     Operation resultOperation =
643         Operation.newBuilder()
644             .setName("createAccessLevelTest")
645             .setDone(true)
646             .setResponse(Any.pack(expectedResponse))
647             .build();
648     mockAccessContextManager.addResponse(resultOperation);
649 
650     AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
651     AccessLevel accessLevel = AccessLevel.newBuilder().build();
652 
653     AccessLevel actualResponse = client.createAccessLevelAsync(parent, accessLevel).get();
654     Assert.assertEquals(expectedResponse, actualResponse);
655 
656     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
657     Assert.assertEquals(1, actualRequests.size());
658     CreateAccessLevelRequest actualRequest = ((CreateAccessLevelRequest) actualRequests.get(0));
659 
660     Assert.assertEquals(parent.toString(), actualRequest.getParent());
661     Assert.assertEquals(accessLevel, actualRequest.getAccessLevel());
662     Assert.assertTrue(
663         channelProvider.isHeaderSent(
664             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
665             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
666   }
667 
668   @Test
createAccessLevelExceptionTest()669   public void createAccessLevelExceptionTest() throws Exception {
670     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
671     mockAccessContextManager.addException(exception);
672 
673     try {
674       AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
675       AccessLevel accessLevel = AccessLevel.newBuilder().build();
676       client.createAccessLevelAsync(parent, accessLevel).get();
677       Assert.fail("No exception raised");
678     } catch (ExecutionException e) {
679       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
680       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
681       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
682     }
683   }
684 
685   @Test
createAccessLevelTest2()686   public void createAccessLevelTest2() throws Exception {
687     AccessLevel expectedResponse =
688         AccessLevel.newBuilder()
689             .setName(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
690             .setTitle("title110371416")
691             .setDescription("description-1724546052")
692             .setCreateTime(Timestamp.newBuilder().build())
693             .setUpdateTime(Timestamp.newBuilder().build())
694             .build();
695     Operation resultOperation =
696         Operation.newBuilder()
697             .setName("createAccessLevelTest")
698             .setDone(true)
699             .setResponse(Any.pack(expectedResponse))
700             .build();
701     mockAccessContextManager.addResponse(resultOperation);
702 
703     String parent = "parent-995424086";
704     AccessLevel accessLevel = AccessLevel.newBuilder().build();
705 
706     AccessLevel actualResponse = client.createAccessLevelAsync(parent, accessLevel).get();
707     Assert.assertEquals(expectedResponse, actualResponse);
708 
709     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
710     Assert.assertEquals(1, actualRequests.size());
711     CreateAccessLevelRequest actualRequest = ((CreateAccessLevelRequest) actualRequests.get(0));
712 
713     Assert.assertEquals(parent, actualRequest.getParent());
714     Assert.assertEquals(accessLevel, actualRequest.getAccessLevel());
715     Assert.assertTrue(
716         channelProvider.isHeaderSent(
717             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
718             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
719   }
720 
721   @Test
createAccessLevelExceptionTest2()722   public void createAccessLevelExceptionTest2() throws Exception {
723     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
724     mockAccessContextManager.addException(exception);
725 
726     try {
727       String parent = "parent-995424086";
728       AccessLevel accessLevel = AccessLevel.newBuilder().build();
729       client.createAccessLevelAsync(parent, accessLevel).get();
730       Assert.fail("No exception raised");
731     } catch (ExecutionException e) {
732       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
733       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
734       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
735     }
736   }
737 
738   @Test
updateAccessLevelTest()739   public void updateAccessLevelTest() throws Exception {
740     AccessLevel expectedResponse =
741         AccessLevel.newBuilder()
742             .setName(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
743             .setTitle("title110371416")
744             .setDescription("description-1724546052")
745             .setCreateTime(Timestamp.newBuilder().build())
746             .setUpdateTime(Timestamp.newBuilder().build())
747             .build();
748     Operation resultOperation =
749         Operation.newBuilder()
750             .setName("updateAccessLevelTest")
751             .setDone(true)
752             .setResponse(Any.pack(expectedResponse))
753             .build();
754     mockAccessContextManager.addResponse(resultOperation);
755 
756     AccessLevel accessLevel = AccessLevel.newBuilder().build();
757     FieldMask updateMask = FieldMask.newBuilder().build();
758 
759     AccessLevel actualResponse = client.updateAccessLevelAsync(accessLevel, updateMask).get();
760     Assert.assertEquals(expectedResponse, actualResponse);
761 
762     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
763     Assert.assertEquals(1, actualRequests.size());
764     UpdateAccessLevelRequest actualRequest = ((UpdateAccessLevelRequest) actualRequests.get(0));
765 
766     Assert.assertEquals(accessLevel, actualRequest.getAccessLevel());
767     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
768     Assert.assertTrue(
769         channelProvider.isHeaderSent(
770             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
771             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
772   }
773 
774   @Test
updateAccessLevelExceptionTest()775   public void updateAccessLevelExceptionTest() throws Exception {
776     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
777     mockAccessContextManager.addException(exception);
778 
779     try {
780       AccessLevel accessLevel = AccessLevel.newBuilder().build();
781       FieldMask updateMask = FieldMask.newBuilder().build();
782       client.updateAccessLevelAsync(accessLevel, updateMask).get();
783       Assert.fail("No exception raised");
784     } catch (ExecutionException e) {
785       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
786       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
787       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
788     }
789   }
790 
791   @Test
deleteAccessLevelTest()792   public void deleteAccessLevelTest() throws Exception {
793     Empty expectedResponse = Empty.newBuilder().build();
794     Operation resultOperation =
795         Operation.newBuilder()
796             .setName("deleteAccessLevelTest")
797             .setDone(true)
798             .setResponse(Any.pack(expectedResponse))
799             .build();
800     mockAccessContextManager.addResponse(resultOperation);
801 
802     AccessLevelName name = AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
803 
804     client.deleteAccessLevelAsync(name).get();
805 
806     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
807     Assert.assertEquals(1, actualRequests.size());
808     DeleteAccessLevelRequest actualRequest = ((DeleteAccessLevelRequest) actualRequests.get(0));
809 
810     Assert.assertEquals(name.toString(), actualRequest.getName());
811     Assert.assertTrue(
812         channelProvider.isHeaderSent(
813             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
814             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
815   }
816 
817   @Test
deleteAccessLevelExceptionTest()818   public void deleteAccessLevelExceptionTest() throws Exception {
819     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
820     mockAccessContextManager.addException(exception);
821 
822     try {
823       AccessLevelName name = AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
824       client.deleteAccessLevelAsync(name).get();
825       Assert.fail("No exception raised");
826     } catch (ExecutionException e) {
827       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
828       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
829       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
830     }
831   }
832 
833   @Test
deleteAccessLevelTest2()834   public void deleteAccessLevelTest2() throws Exception {
835     Empty expectedResponse = Empty.newBuilder().build();
836     Operation resultOperation =
837         Operation.newBuilder()
838             .setName("deleteAccessLevelTest")
839             .setDone(true)
840             .setResponse(Any.pack(expectedResponse))
841             .build();
842     mockAccessContextManager.addResponse(resultOperation);
843 
844     String name = "name3373707";
845 
846     client.deleteAccessLevelAsync(name).get();
847 
848     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
849     Assert.assertEquals(1, actualRequests.size());
850     DeleteAccessLevelRequest actualRequest = ((DeleteAccessLevelRequest) actualRequests.get(0));
851 
852     Assert.assertEquals(name, actualRequest.getName());
853     Assert.assertTrue(
854         channelProvider.isHeaderSent(
855             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
856             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
857   }
858 
859   @Test
deleteAccessLevelExceptionTest2()860   public void deleteAccessLevelExceptionTest2() throws Exception {
861     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
862     mockAccessContextManager.addException(exception);
863 
864     try {
865       String name = "name3373707";
866       client.deleteAccessLevelAsync(name).get();
867       Assert.fail("No exception raised");
868     } catch (ExecutionException e) {
869       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
870       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
871       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
872     }
873   }
874 
875   @Test
replaceAccessLevelsTest()876   public void replaceAccessLevelsTest() throws Exception {
877     ReplaceAccessLevelsResponse expectedResponse =
878         ReplaceAccessLevelsResponse.newBuilder()
879             .addAllAccessLevels(new ArrayList<AccessLevel>())
880             .build();
881     Operation resultOperation =
882         Operation.newBuilder()
883             .setName("replaceAccessLevelsTest")
884             .setDone(true)
885             .setResponse(Any.pack(expectedResponse))
886             .build();
887     mockAccessContextManager.addResponse(resultOperation);
888 
889     ReplaceAccessLevelsRequest request =
890         ReplaceAccessLevelsRequest.newBuilder()
891             .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
892             .addAllAccessLevels(new ArrayList<AccessLevel>())
893             .setEtag("etag3123477")
894             .build();
895 
896     ReplaceAccessLevelsResponse actualResponse = client.replaceAccessLevelsAsync(request).get();
897     Assert.assertEquals(expectedResponse, actualResponse);
898 
899     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
900     Assert.assertEquals(1, actualRequests.size());
901     ReplaceAccessLevelsRequest actualRequest = ((ReplaceAccessLevelsRequest) actualRequests.get(0));
902 
903     Assert.assertEquals(request.getParent(), actualRequest.getParent());
904     Assert.assertEquals(request.getAccessLevelsList(), actualRequest.getAccessLevelsList());
905     Assert.assertEquals(request.getEtag(), actualRequest.getEtag());
906     Assert.assertTrue(
907         channelProvider.isHeaderSent(
908             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
909             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
910   }
911 
912   @Test
replaceAccessLevelsExceptionTest()913   public void replaceAccessLevelsExceptionTest() throws Exception {
914     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
915     mockAccessContextManager.addException(exception);
916 
917     try {
918       ReplaceAccessLevelsRequest request =
919           ReplaceAccessLevelsRequest.newBuilder()
920               .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
921               .addAllAccessLevels(new ArrayList<AccessLevel>())
922               .setEtag("etag3123477")
923               .build();
924       client.replaceAccessLevelsAsync(request).get();
925       Assert.fail("No exception raised");
926     } catch (ExecutionException e) {
927       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
928       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
929       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
930     }
931   }
932 
933   @Test
listServicePerimetersTest()934   public void listServicePerimetersTest() throws Exception {
935     ServicePerimeter responsesElement = ServicePerimeter.newBuilder().build();
936     ListServicePerimetersResponse expectedResponse =
937         ListServicePerimetersResponse.newBuilder()
938             .setNextPageToken("")
939             .addAllServicePerimeters(Arrays.asList(responsesElement))
940             .build();
941     mockAccessContextManager.addResponse(expectedResponse);
942 
943     AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
944 
945     ListServicePerimetersPagedResponse pagedListResponse = client.listServicePerimeters(parent);
946 
947     List<ServicePerimeter> resources = Lists.newArrayList(pagedListResponse.iterateAll());
948 
949     Assert.assertEquals(1, resources.size());
950     Assert.assertEquals(expectedResponse.getServicePerimetersList().get(0), resources.get(0));
951 
952     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
953     Assert.assertEquals(1, actualRequests.size());
954     ListServicePerimetersRequest actualRequest =
955         ((ListServicePerimetersRequest) actualRequests.get(0));
956 
957     Assert.assertEquals(parent.toString(), actualRequest.getParent());
958     Assert.assertTrue(
959         channelProvider.isHeaderSent(
960             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
961             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
962   }
963 
964   @Test
listServicePerimetersExceptionTest()965   public void listServicePerimetersExceptionTest() throws Exception {
966     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
967     mockAccessContextManager.addException(exception);
968 
969     try {
970       AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
971       client.listServicePerimeters(parent);
972       Assert.fail("No exception raised");
973     } catch (InvalidArgumentException e) {
974       // Expected exception.
975     }
976   }
977 
978   @Test
listServicePerimetersTest2()979   public void listServicePerimetersTest2() throws Exception {
980     ServicePerimeter responsesElement = ServicePerimeter.newBuilder().build();
981     ListServicePerimetersResponse expectedResponse =
982         ListServicePerimetersResponse.newBuilder()
983             .setNextPageToken("")
984             .addAllServicePerimeters(Arrays.asList(responsesElement))
985             .build();
986     mockAccessContextManager.addResponse(expectedResponse);
987 
988     String parent = "parent-995424086";
989 
990     ListServicePerimetersPagedResponse pagedListResponse = client.listServicePerimeters(parent);
991 
992     List<ServicePerimeter> resources = Lists.newArrayList(pagedListResponse.iterateAll());
993 
994     Assert.assertEquals(1, resources.size());
995     Assert.assertEquals(expectedResponse.getServicePerimetersList().get(0), resources.get(0));
996 
997     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
998     Assert.assertEquals(1, actualRequests.size());
999     ListServicePerimetersRequest actualRequest =
1000         ((ListServicePerimetersRequest) actualRequests.get(0));
1001 
1002     Assert.assertEquals(parent, actualRequest.getParent());
1003     Assert.assertTrue(
1004         channelProvider.isHeaderSent(
1005             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1006             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1007   }
1008 
1009   @Test
listServicePerimetersExceptionTest2()1010   public void listServicePerimetersExceptionTest2() throws Exception {
1011     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1012     mockAccessContextManager.addException(exception);
1013 
1014     try {
1015       String parent = "parent-995424086";
1016       client.listServicePerimeters(parent);
1017       Assert.fail("No exception raised");
1018     } catch (InvalidArgumentException e) {
1019       // Expected exception.
1020     }
1021   }
1022 
1023   @Test
getServicePerimeterTest()1024   public void getServicePerimeterTest() throws Exception {
1025     ServicePerimeter expectedResponse =
1026         ServicePerimeter.newBuilder()
1027             .setName(ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]").toString())
1028             .setTitle("title110371416")
1029             .setDescription("description-1724546052")
1030             .setCreateTime(Timestamp.newBuilder().build())
1031             .setUpdateTime(Timestamp.newBuilder().build())
1032             .setStatus(ServicePerimeterConfig.newBuilder().build())
1033             .setSpec(ServicePerimeterConfig.newBuilder().build())
1034             .setUseExplicitDryRunSpec(true)
1035             .build();
1036     mockAccessContextManager.addResponse(expectedResponse);
1037 
1038     ServicePerimeterName name = ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
1039 
1040     ServicePerimeter actualResponse = client.getServicePerimeter(name);
1041     Assert.assertEquals(expectedResponse, actualResponse);
1042 
1043     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1044     Assert.assertEquals(1, actualRequests.size());
1045     GetServicePerimeterRequest actualRequest = ((GetServicePerimeterRequest) actualRequests.get(0));
1046 
1047     Assert.assertEquals(name.toString(), actualRequest.getName());
1048     Assert.assertTrue(
1049         channelProvider.isHeaderSent(
1050             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1051             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1052   }
1053 
1054   @Test
getServicePerimeterExceptionTest()1055   public void getServicePerimeterExceptionTest() throws Exception {
1056     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1057     mockAccessContextManager.addException(exception);
1058 
1059     try {
1060       ServicePerimeterName name = ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
1061       client.getServicePerimeter(name);
1062       Assert.fail("No exception raised");
1063     } catch (InvalidArgumentException e) {
1064       // Expected exception.
1065     }
1066   }
1067 
1068   @Test
getServicePerimeterTest2()1069   public void getServicePerimeterTest2() throws Exception {
1070     ServicePerimeter expectedResponse =
1071         ServicePerimeter.newBuilder()
1072             .setName(ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]").toString())
1073             .setTitle("title110371416")
1074             .setDescription("description-1724546052")
1075             .setCreateTime(Timestamp.newBuilder().build())
1076             .setUpdateTime(Timestamp.newBuilder().build())
1077             .setStatus(ServicePerimeterConfig.newBuilder().build())
1078             .setSpec(ServicePerimeterConfig.newBuilder().build())
1079             .setUseExplicitDryRunSpec(true)
1080             .build();
1081     mockAccessContextManager.addResponse(expectedResponse);
1082 
1083     String name = "name3373707";
1084 
1085     ServicePerimeter actualResponse = client.getServicePerimeter(name);
1086     Assert.assertEquals(expectedResponse, actualResponse);
1087 
1088     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1089     Assert.assertEquals(1, actualRequests.size());
1090     GetServicePerimeterRequest actualRequest = ((GetServicePerimeterRequest) actualRequests.get(0));
1091 
1092     Assert.assertEquals(name, actualRequest.getName());
1093     Assert.assertTrue(
1094         channelProvider.isHeaderSent(
1095             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1096             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1097   }
1098 
1099   @Test
getServicePerimeterExceptionTest2()1100   public void getServicePerimeterExceptionTest2() throws Exception {
1101     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1102     mockAccessContextManager.addException(exception);
1103 
1104     try {
1105       String name = "name3373707";
1106       client.getServicePerimeter(name);
1107       Assert.fail("No exception raised");
1108     } catch (InvalidArgumentException e) {
1109       // Expected exception.
1110     }
1111   }
1112 
1113   @Test
createServicePerimeterTest()1114   public void createServicePerimeterTest() throws Exception {
1115     ServicePerimeter expectedResponse =
1116         ServicePerimeter.newBuilder()
1117             .setName(ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]").toString())
1118             .setTitle("title110371416")
1119             .setDescription("description-1724546052")
1120             .setCreateTime(Timestamp.newBuilder().build())
1121             .setUpdateTime(Timestamp.newBuilder().build())
1122             .setStatus(ServicePerimeterConfig.newBuilder().build())
1123             .setSpec(ServicePerimeterConfig.newBuilder().build())
1124             .setUseExplicitDryRunSpec(true)
1125             .build();
1126     Operation resultOperation =
1127         Operation.newBuilder()
1128             .setName("createServicePerimeterTest")
1129             .setDone(true)
1130             .setResponse(Any.pack(expectedResponse))
1131             .build();
1132     mockAccessContextManager.addResponse(resultOperation);
1133 
1134     AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
1135     ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1136 
1137     ServicePerimeter actualResponse =
1138         client.createServicePerimeterAsync(parent, servicePerimeter).get();
1139     Assert.assertEquals(expectedResponse, actualResponse);
1140 
1141     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1142     Assert.assertEquals(1, actualRequests.size());
1143     CreateServicePerimeterRequest actualRequest =
1144         ((CreateServicePerimeterRequest) actualRequests.get(0));
1145 
1146     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1147     Assert.assertEquals(servicePerimeter, actualRequest.getServicePerimeter());
1148     Assert.assertTrue(
1149         channelProvider.isHeaderSent(
1150             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1151             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1152   }
1153 
1154   @Test
createServicePerimeterExceptionTest()1155   public void createServicePerimeterExceptionTest() throws Exception {
1156     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1157     mockAccessContextManager.addException(exception);
1158 
1159     try {
1160       AccessPolicyName parent = AccessPolicyName.of("[ACCESS_POLICY]");
1161       ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1162       client.createServicePerimeterAsync(parent, servicePerimeter).get();
1163       Assert.fail("No exception raised");
1164     } catch (ExecutionException e) {
1165       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1166       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1167       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1168     }
1169   }
1170 
1171   @Test
createServicePerimeterTest2()1172   public void createServicePerimeterTest2() throws Exception {
1173     ServicePerimeter expectedResponse =
1174         ServicePerimeter.newBuilder()
1175             .setName(ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]").toString())
1176             .setTitle("title110371416")
1177             .setDescription("description-1724546052")
1178             .setCreateTime(Timestamp.newBuilder().build())
1179             .setUpdateTime(Timestamp.newBuilder().build())
1180             .setStatus(ServicePerimeterConfig.newBuilder().build())
1181             .setSpec(ServicePerimeterConfig.newBuilder().build())
1182             .setUseExplicitDryRunSpec(true)
1183             .build();
1184     Operation resultOperation =
1185         Operation.newBuilder()
1186             .setName("createServicePerimeterTest")
1187             .setDone(true)
1188             .setResponse(Any.pack(expectedResponse))
1189             .build();
1190     mockAccessContextManager.addResponse(resultOperation);
1191 
1192     String parent = "parent-995424086";
1193     ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1194 
1195     ServicePerimeter actualResponse =
1196         client.createServicePerimeterAsync(parent, servicePerimeter).get();
1197     Assert.assertEquals(expectedResponse, actualResponse);
1198 
1199     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1200     Assert.assertEquals(1, actualRequests.size());
1201     CreateServicePerimeterRequest actualRequest =
1202         ((CreateServicePerimeterRequest) actualRequests.get(0));
1203 
1204     Assert.assertEquals(parent, actualRequest.getParent());
1205     Assert.assertEquals(servicePerimeter, actualRequest.getServicePerimeter());
1206     Assert.assertTrue(
1207         channelProvider.isHeaderSent(
1208             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1209             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1210   }
1211 
1212   @Test
createServicePerimeterExceptionTest2()1213   public void createServicePerimeterExceptionTest2() throws Exception {
1214     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1215     mockAccessContextManager.addException(exception);
1216 
1217     try {
1218       String parent = "parent-995424086";
1219       ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1220       client.createServicePerimeterAsync(parent, servicePerimeter).get();
1221       Assert.fail("No exception raised");
1222     } catch (ExecutionException e) {
1223       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1224       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1225       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1226     }
1227   }
1228 
1229   @Test
updateServicePerimeterTest()1230   public void updateServicePerimeterTest() throws Exception {
1231     ServicePerimeter expectedResponse =
1232         ServicePerimeter.newBuilder()
1233             .setName(ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]").toString())
1234             .setTitle("title110371416")
1235             .setDescription("description-1724546052")
1236             .setCreateTime(Timestamp.newBuilder().build())
1237             .setUpdateTime(Timestamp.newBuilder().build())
1238             .setStatus(ServicePerimeterConfig.newBuilder().build())
1239             .setSpec(ServicePerimeterConfig.newBuilder().build())
1240             .setUseExplicitDryRunSpec(true)
1241             .build();
1242     Operation resultOperation =
1243         Operation.newBuilder()
1244             .setName("updateServicePerimeterTest")
1245             .setDone(true)
1246             .setResponse(Any.pack(expectedResponse))
1247             .build();
1248     mockAccessContextManager.addResponse(resultOperation);
1249 
1250     ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1251     FieldMask updateMask = FieldMask.newBuilder().build();
1252 
1253     ServicePerimeter actualResponse =
1254         client.updateServicePerimeterAsync(servicePerimeter, updateMask).get();
1255     Assert.assertEquals(expectedResponse, actualResponse);
1256 
1257     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1258     Assert.assertEquals(1, actualRequests.size());
1259     UpdateServicePerimeterRequest actualRequest =
1260         ((UpdateServicePerimeterRequest) actualRequests.get(0));
1261 
1262     Assert.assertEquals(servicePerimeter, actualRequest.getServicePerimeter());
1263     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1264     Assert.assertTrue(
1265         channelProvider.isHeaderSent(
1266             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1267             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1268   }
1269 
1270   @Test
updateServicePerimeterExceptionTest()1271   public void updateServicePerimeterExceptionTest() throws Exception {
1272     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1273     mockAccessContextManager.addException(exception);
1274 
1275     try {
1276       ServicePerimeter servicePerimeter = ServicePerimeter.newBuilder().build();
1277       FieldMask updateMask = FieldMask.newBuilder().build();
1278       client.updateServicePerimeterAsync(servicePerimeter, updateMask).get();
1279       Assert.fail("No exception raised");
1280     } catch (ExecutionException e) {
1281       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1282       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1283       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1284     }
1285   }
1286 
1287   @Test
deleteServicePerimeterTest()1288   public void deleteServicePerimeterTest() throws Exception {
1289     Empty expectedResponse = Empty.newBuilder().build();
1290     Operation resultOperation =
1291         Operation.newBuilder()
1292             .setName("deleteServicePerimeterTest")
1293             .setDone(true)
1294             .setResponse(Any.pack(expectedResponse))
1295             .build();
1296     mockAccessContextManager.addResponse(resultOperation);
1297 
1298     ServicePerimeterName name = ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
1299 
1300     client.deleteServicePerimeterAsync(name).get();
1301 
1302     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1303     Assert.assertEquals(1, actualRequests.size());
1304     DeleteServicePerimeterRequest actualRequest =
1305         ((DeleteServicePerimeterRequest) actualRequests.get(0));
1306 
1307     Assert.assertEquals(name.toString(), actualRequest.getName());
1308     Assert.assertTrue(
1309         channelProvider.isHeaderSent(
1310             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1311             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1312   }
1313 
1314   @Test
deleteServicePerimeterExceptionTest()1315   public void deleteServicePerimeterExceptionTest() throws Exception {
1316     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1317     mockAccessContextManager.addException(exception);
1318 
1319     try {
1320       ServicePerimeterName name = ServicePerimeterName.of("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
1321       client.deleteServicePerimeterAsync(name).get();
1322       Assert.fail("No exception raised");
1323     } catch (ExecutionException e) {
1324       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1325       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1326       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1327     }
1328   }
1329 
1330   @Test
deleteServicePerimeterTest2()1331   public void deleteServicePerimeterTest2() throws Exception {
1332     Empty expectedResponse = Empty.newBuilder().build();
1333     Operation resultOperation =
1334         Operation.newBuilder()
1335             .setName("deleteServicePerimeterTest")
1336             .setDone(true)
1337             .setResponse(Any.pack(expectedResponse))
1338             .build();
1339     mockAccessContextManager.addResponse(resultOperation);
1340 
1341     String name = "name3373707";
1342 
1343     client.deleteServicePerimeterAsync(name).get();
1344 
1345     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1346     Assert.assertEquals(1, actualRequests.size());
1347     DeleteServicePerimeterRequest actualRequest =
1348         ((DeleteServicePerimeterRequest) actualRequests.get(0));
1349 
1350     Assert.assertEquals(name, actualRequest.getName());
1351     Assert.assertTrue(
1352         channelProvider.isHeaderSent(
1353             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1354             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1355   }
1356 
1357   @Test
deleteServicePerimeterExceptionTest2()1358   public void deleteServicePerimeterExceptionTest2() throws Exception {
1359     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1360     mockAccessContextManager.addException(exception);
1361 
1362     try {
1363       String name = "name3373707";
1364       client.deleteServicePerimeterAsync(name).get();
1365       Assert.fail("No exception raised");
1366     } catch (ExecutionException e) {
1367       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1368       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1369       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1370     }
1371   }
1372 
1373   @Test
replaceServicePerimetersTest()1374   public void replaceServicePerimetersTest() throws Exception {
1375     ReplaceServicePerimetersResponse expectedResponse =
1376         ReplaceServicePerimetersResponse.newBuilder()
1377             .addAllServicePerimeters(new ArrayList<ServicePerimeter>())
1378             .build();
1379     Operation resultOperation =
1380         Operation.newBuilder()
1381             .setName("replaceServicePerimetersTest")
1382             .setDone(true)
1383             .setResponse(Any.pack(expectedResponse))
1384             .build();
1385     mockAccessContextManager.addResponse(resultOperation);
1386 
1387     ReplaceServicePerimetersRequest request =
1388         ReplaceServicePerimetersRequest.newBuilder()
1389             .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1390             .addAllServicePerimeters(new ArrayList<ServicePerimeter>())
1391             .setEtag("etag3123477")
1392             .build();
1393 
1394     ReplaceServicePerimetersResponse actualResponse =
1395         client.replaceServicePerimetersAsync(request).get();
1396     Assert.assertEquals(expectedResponse, actualResponse);
1397 
1398     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1399     Assert.assertEquals(1, actualRequests.size());
1400     ReplaceServicePerimetersRequest actualRequest =
1401         ((ReplaceServicePerimetersRequest) actualRequests.get(0));
1402 
1403     Assert.assertEquals(request.getParent(), actualRequest.getParent());
1404     Assert.assertEquals(
1405         request.getServicePerimetersList(), actualRequest.getServicePerimetersList());
1406     Assert.assertEquals(request.getEtag(), actualRequest.getEtag());
1407     Assert.assertTrue(
1408         channelProvider.isHeaderSent(
1409             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1410             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1411   }
1412 
1413   @Test
replaceServicePerimetersExceptionTest()1414   public void replaceServicePerimetersExceptionTest() throws Exception {
1415     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1416     mockAccessContextManager.addException(exception);
1417 
1418     try {
1419       ReplaceServicePerimetersRequest request =
1420           ReplaceServicePerimetersRequest.newBuilder()
1421               .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1422               .addAllServicePerimeters(new ArrayList<ServicePerimeter>())
1423               .setEtag("etag3123477")
1424               .build();
1425       client.replaceServicePerimetersAsync(request).get();
1426       Assert.fail("No exception raised");
1427     } catch (ExecutionException e) {
1428       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1429       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1430       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1431     }
1432   }
1433 
1434   @Test
commitServicePerimetersTest()1435   public void commitServicePerimetersTest() throws Exception {
1436     CommitServicePerimetersResponse expectedResponse =
1437         CommitServicePerimetersResponse.newBuilder()
1438             .addAllServicePerimeters(new ArrayList<ServicePerimeter>())
1439             .build();
1440     Operation resultOperation =
1441         Operation.newBuilder()
1442             .setName("commitServicePerimetersTest")
1443             .setDone(true)
1444             .setResponse(Any.pack(expectedResponse))
1445             .build();
1446     mockAccessContextManager.addResponse(resultOperation);
1447 
1448     CommitServicePerimetersRequest request =
1449         CommitServicePerimetersRequest.newBuilder()
1450             .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1451             .setEtag("etag3123477")
1452             .build();
1453 
1454     CommitServicePerimetersResponse actualResponse =
1455         client.commitServicePerimetersAsync(request).get();
1456     Assert.assertEquals(expectedResponse, actualResponse);
1457 
1458     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1459     Assert.assertEquals(1, actualRequests.size());
1460     CommitServicePerimetersRequest actualRequest =
1461         ((CommitServicePerimetersRequest) actualRequests.get(0));
1462 
1463     Assert.assertEquals(request.getParent(), actualRequest.getParent());
1464     Assert.assertEquals(request.getEtag(), actualRequest.getEtag());
1465     Assert.assertTrue(
1466         channelProvider.isHeaderSent(
1467             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1468             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1469   }
1470 
1471   @Test
commitServicePerimetersExceptionTest()1472   public void commitServicePerimetersExceptionTest() throws Exception {
1473     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1474     mockAccessContextManager.addException(exception);
1475 
1476     try {
1477       CommitServicePerimetersRequest request =
1478           CommitServicePerimetersRequest.newBuilder()
1479               .setParent(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1480               .setEtag("etag3123477")
1481               .build();
1482       client.commitServicePerimetersAsync(request).get();
1483       Assert.fail("No exception raised");
1484     } catch (ExecutionException e) {
1485       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1486       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1487       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1488     }
1489   }
1490 
1491   @Test
listGcpUserAccessBindingsTest()1492   public void listGcpUserAccessBindingsTest() throws Exception {
1493     GcpUserAccessBinding responsesElement = GcpUserAccessBinding.newBuilder().build();
1494     ListGcpUserAccessBindingsResponse expectedResponse =
1495         ListGcpUserAccessBindingsResponse.newBuilder()
1496             .setNextPageToken("")
1497             .addAllGcpUserAccessBindings(Arrays.asList(responsesElement))
1498             .build();
1499     mockAccessContextManager.addResponse(expectedResponse);
1500 
1501     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1502 
1503     ListGcpUserAccessBindingsPagedResponse pagedListResponse =
1504         client.listGcpUserAccessBindings(parent);
1505 
1506     List<GcpUserAccessBinding> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1507 
1508     Assert.assertEquals(1, resources.size());
1509     Assert.assertEquals(expectedResponse.getGcpUserAccessBindingsList().get(0), resources.get(0));
1510 
1511     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1512     Assert.assertEquals(1, actualRequests.size());
1513     ListGcpUserAccessBindingsRequest actualRequest =
1514         ((ListGcpUserAccessBindingsRequest) actualRequests.get(0));
1515 
1516     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1517     Assert.assertTrue(
1518         channelProvider.isHeaderSent(
1519             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1520             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1521   }
1522 
1523   @Test
listGcpUserAccessBindingsExceptionTest()1524   public void listGcpUserAccessBindingsExceptionTest() throws Exception {
1525     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1526     mockAccessContextManager.addException(exception);
1527 
1528     try {
1529       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1530       client.listGcpUserAccessBindings(parent);
1531       Assert.fail("No exception raised");
1532     } catch (InvalidArgumentException e) {
1533       // Expected exception.
1534     }
1535   }
1536 
1537   @Test
listGcpUserAccessBindingsTest2()1538   public void listGcpUserAccessBindingsTest2() throws Exception {
1539     GcpUserAccessBinding responsesElement = GcpUserAccessBinding.newBuilder().build();
1540     ListGcpUserAccessBindingsResponse expectedResponse =
1541         ListGcpUserAccessBindingsResponse.newBuilder()
1542             .setNextPageToken("")
1543             .addAllGcpUserAccessBindings(Arrays.asList(responsesElement))
1544             .build();
1545     mockAccessContextManager.addResponse(expectedResponse);
1546 
1547     String parent = "parent-995424086";
1548 
1549     ListGcpUserAccessBindingsPagedResponse pagedListResponse =
1550         client.listGcpUserAccessBindings(parent);
1551 
1552     List<GcpUserAccessBinding> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1553 
1554     Assert.assertEquals(1, resources.size());
1555     Assert.assertEquals(expectedResponse.getGcpUserAccessBindingsList().get(0), resources.get(0));
1556 
1557     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1558     Assert.assertEquals(1, actualRequests.size());
1559     ListGcpUserAccessBindingsRequest actualRequest =
1560         ((ListGcpUserAccessBindingsRequest) actualRequests.get(0));
1561 
1562     Assert.assertEquals(parent, actualRequest.getParent());
1563     Assert.assertTrue(
1564         channelProvider.isHeaderSent(
1565             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1566             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1567   }
1568 
1569   @Test
listGcpUserAccessBindingsExceptionTest2()1570   public void listGcpUserAccessBindingsExceptionTest2() throws Exception {
1571     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1572     mockAccessContextManager.addException(exception);
1573 
1574     try {
1575       String parent = "parent-995424086";
1576       client.listGcpUserAccessBindings(parent);
1577       Assert.fail("No exception raised");
1578     } catch (InvalidArgumentException e) {
1579       // Expected exception.
1580     }
1581   }
1582 
1583   @Test
getGcpUserAccessBindingTest()1584   public void getGcpUserAccessBindingTest() throws Exception {
1585     GcpUserAccessBinding expectedResponse =
1586         GcpUserAccessBinding.newBuilder()
1587             .setName(
1588                 GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]")
1589                     .toString())
1590             .setGroupKey("groupKey506342240")
1591             .addAllAccessLevels(new ArrayList<String>())
1592             .build();
1593     mockAccessContextManager.addResponse(expectedResponse);
1594 
1595     GcpUserAccessBindingName name =
1596         GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
1597 
1598     GcpUserAccessBinding actualResponse = client.getGcpUserAccessBinding(name);
1599     Assert.assertEquals(expectedResponse, actualResponse);
1600 
1601     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1602     Assert.assertEquals(1, actualRequests.size());
1603     GetGcpUserAccessBindingRequest actualRequest =
1604         ((GetGcpUserAccessBindingRequest) actualRequests.get(0));
1605 
1606     Assert.assertEquals(name.toString(), actualRequest.getName());
1607     Assert.assertTrue(
1608         channelProvider.isHeaderSent(
1609             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1610             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1611   }
1612 
1613   @Test
getGcpUserAccessBindingExceptionTest()1614   public void getGcpUserAccessBindingExceptionTest() throws Exception {
1615     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1616     mockAccessContextManager.addException(exception);
1617 
1618     try {
1619       GcpUserAccessBindingName name =
1620           GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
1621       client.getGcpUserAccessBinding(name);
1622       Assert.fail("No exception raised");
1623     } catch (InvalidArgumentException e) {
1624       // Expected exception.
1625     }
1626   }
1627 
1628   @Test
getGcpUserAccessBindingTest2()1629   public void getGcpUserAccessBindingTest2() throws Exception {
1630     GcpUserAccessBinding expectedResponse =
1631         GcpUserAccessBinding.newBuilder()
1632             .setName(
1633                 GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]")
1634                     .toString())
1635             .setGroupKey("groupKey506342240")
1636             .addAllAccessLevels(new ArrayList<String>())
1637             .build();
1638     mockAccessContextManager.addResponse(expectedResponse);
1639 
1640     String name = "name3373707";
1641 
1642     GcpUserAccessBinding actualResponse = client.getGcpUserAccessBinding(name);
1643     Assert.assertEquals(expectedResponse, actualResponse);
1644 
1645     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1646     Assert.assertEquals(1, actualRequests.size());
1647     GetGcpUserAccessBindingRequest actualRequest =
1648         ((GetGcpUserAccessBindingRequest) actualRequests.get(0));
1649 
1650     Assert.assertEquals(name, actualRequest.getName());
1651     Assert.assertTrue(
1652         channelProvider.isHeaderSent(
1653             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1654             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1655   }
1656 
1657   @Test
getGcpUserAccessBindingExceptionTest2()1658   public void getGcpUserAccessBindingExceptionTest2() throws Exception {
1659     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1660     mockAccessContextManager.addException(exception);
1661 
1662     try {
1663       String name = "name3373707";
1664       client.getGcpUserAccessBinding(name);
1665       Assert.fail("No exception raised");
1666     } catch (InvalidArgumentException e) {
1667       // Expected exception.
1668     }
1669   }
1670 
1671   @Test
createGcpUserAccessBindingTest()1672   public void createGcpUserAccessBindingTest() throws Exception {
1673     GcpUserAccessBinding expectedResponse =
1674         GcpUserAccessBinding.newBuilder()
1675             .setName(
1676                 GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]")
1677                     .toString())
1678             .setGroupKey("groupKey506342240")
1679             .addAllAccessLevels(new ArrayList<String>())
1680             .build();
1681     Operation resultOperation =
1682         Operation.newBuilder()
1683             .setName("createGcpUserAccessBindingTest")
1684             .setDone(true)
1685             .setResponse(Any.pack(expectedResponse))
1686             .build();
1687     mockAccessContextManager.addResponse(resultOperation);
1688 
1689     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1690     GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1691 
1692     GcpUserAccessBinding actualResponse =
1693         client.createGcpUserAccessBindingAsync(parent, gcpUserAccessBinding).get();
1694     Assert.assertEquals(expectedResponse, actualResponse);
1695 
1696     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1697     Assert.assertEquals(1, actualRequests.size());
1698     CreateGcpUserAccessBindingRequest actualRequest =
1699         ((CreateGcpUserAccessBindingRequest) actualRequests.get(0));
1700 
1701     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1702     Assert.assertEquals(gcpUserAccessBinding, actualRequest.getGcpUserAccessBinding());
1703     Assert.assertTrue(
1704         channelProvider.isHeaderSent(
1705             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1706             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1707   }
1708 
1709   @Test
createGcpUserAccessBindingExceptionTest()1710   public void createGcpUserAccessBindingExceptionTest() throws Exception {
1711     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1712     mockAccessContextManager.addException(exception);
1713 
1714     try {
1715       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1716       GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1717       client.createGcpUserAccessBindingAsync(parent, gcpUserAccessBinding).get();
1718       Assert.fail("No exception raised");
1719     } catch (ExecutionException e) {
1720       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1721       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1722       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1723     }
1724   }
1725 
1726   @Test
createGcpUserAccessBindingTest2()1727   public void createGcpUserAccessBindingTest2() throws Exception {
1728     GcpUserAccessBinding expectedResponse =
1729         GcpUserAccessBinding.newBuilder()
1730             .setName(
1731                 GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]")
1732                     .toString())
1733             .setGroupKey("groupKey506342240")
1734             .addAllAccessLevels(new ArrayList<String>())
1735             .build();
1736     Operation resultOperation =
1737         Operation.newBuilder()
1738             .setName("createGcpUserAccessBindingTest")
1739             .setDone(true)
1740             .setResponse(Any.pack(expectedResponse))
1741             .build();
1742     mockAccessContextManager.addResponse(resultOperation);
1743 
1744     String parent = "parent-995424086";
1745     GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1746 
1747     GcpUserAccessBinding actualResponse =
1748         client.createGcpUserAccessBindingAsync(parent, gcpUserAccessBinding).get();
1749     Assert.assertEquals(expectedResponse, actualResponse);
1750 
1751     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1752     Assert.assertEquals(1, actualRequests.size());
1753     CreateGcpUserAccessBindingRequest actualRequest =
1754         ((CreateGcpUserAccessBindingRequest) actualRequests.get(0));
1755 
1756     Assert.assertEquals(parent, actualRequest.getParent());
1757     Assert.assertEquals(gcpUserAccessBinding, actualRequest.getGcpUserAccessBinding());
1758     Assert.assertTrue(
1759         channelProvider.isHeaderSent(
1760             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1761             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1762   }
1763 
1764   @Test
createGcpUserAccessBindingExceptionTest2()1765   public void createGcpUserAccessBindingExceptionTest2() throws Exception {
1766     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1767     mockAccessContextManager.addException(exception);
1768 
1769     try {
1770       String parent = "parent-995424086";
1771       GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1772       client.createGcpUserAccessBindingAsync(parent, gcpUserAccessBinding).get();
1773       Assert.fail("No exception raised");
1774     } catch (ExecutionException e) {
1775       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1776       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1777       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1778     }
1779   }
1780 
1781   @Test
updateGcpUserAccessBindingTest()1782   public void updateGcpUserAccessBindingTest() throws Exception {
1783     GcpUserAccessBinding expectedResponse =
1784         GcpUserAccessBinding.newBuilder()
1785             .setName(
1786                 GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]")
1787                     .toString())
1788             .setGroupKey("groupKey506342240")
1789             .addAllAccessLevels(new ArrayList<String>())
1790             .build();
1791     Operation resultOperation =
1792         Operation.newBuilder()
1793             .setName("updateGcpUserAccessBindingTest")
1794             .setDone(true)
1795             .setResponse(Any.pack(expectedResponse))
1796             .build();
1797     mockAccessContextManager.addResponse(resultOperation);
1798 
1799     GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1800     FieldMask updateMask = FieldMask.newBuilder().build();
1801 
1802     GcpUserAccessBinding actualResponse =
1803         client.updateGcpUserAccessBindingAsync(gcpUserAccessBinding, updateMask).get();
1804     Assert.assertEquals(expectedResponse, actualResponse);
1805 
1806     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1807     Assert.assertEquals(1, actualRequests.size());
1808     UpdateGcpUserAccessBindingRequest actualRequest =
1809         ((UpdateGcpUserAccessBindingRequest) actualRequests.get(0));
1810 
1811     Assert.assertEquals(gcpUserAccessBinding, actualRequest.getGcpUserAccessBinding());
1812     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1813     Assert.assertTrue(
1814         channelProvider.isHeaderSent(
1815             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1816             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1817   }
1818 
1819   @Test
updateGcpUserAccessBindingExceptionTest()1820   public void updateGcpUserAccessBindingExceptionTest() throws Exception {
1821     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1822     mockAccessContextManager.addException(exception);
1823 
1824     try {
1825       GcpUserAccessBinding gcpUserAccessBinding = GcpUserAccessBinding.newBuilder().build();
1826       FieldMask updateMask = FieldMask.newBuilder().build();
1827       client.updateGcpUserAccessBindingAsync(gcpUserAccessBinding, updateMask).get();
1828       Assert.fail("No exception raised");
1829     } catch (ExecutionException e) {
1830       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1831       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1832       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1833     }
1834   }
1835 
1836   @Test
deleteGcpUserAccessBindingTest()1837   public void deleteGcpUserAccessBindingTest() throws Exception {
1838     Empty expectedResponse = Empty.newBuilder().build();
1839     Operation resultOperation =
1840         Operation.newBuilder()
1841             .setName("deleteGcpUserAccessBindingTest")
1842             .setDone(true)
1843             .setResponse(Any.pack(expectedResponse))
1844             .build();
1845     mockAccessContextManager.addResponse(resultOperation);
1846 
1847     GcpUserAccessBindingName name =
1848         GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
1849 
1850     client.deleteGcpUserAccessBindingAsync(name).get();
1851 
1852     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1853     Assert.assertEquals(1, actualRequests.size());
1854     DeleteGcpUserAccessBindingRequest actualRequest =
1855         ((DeleteGcpUserAccessBindingRequest) actualRequests.get(0));
1856 
1857     Assert.assertEquals(name.toString(), actualRequest.getName());
1858     Assert.assertTrue(
1859         channelProvider.isHeaderSent(
1860             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1861             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1862   }
1863 
1864   @Test
deleteGcpUserAccessBindingExceptionTest()1865   public void deleteGcpUserAccessBindingExceptionTest() throws Exception {
1866     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1867     mockAccessContextManager.addException(exception);
1868 
1869     try {
1870       GcpUserAccessBindingName name =
1871           GcpUserAccessBindingName.of("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
1872       client.deleteGcpUserAccessBindingAsync(name).get();
1873       Assert.fail("No exception raised");
1874     } catch (ExecutionException e) {
1875       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1876       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1877       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1878     }
1879   }
1880 
1881   @Test
deleteGcpUserAccessBindingTest2()1882   public void deleteGcpUserAccessBindingTest2() throws Exception {
1883     Empty expectedResponse = Empty.newBuilder().build();
1884     Operation resultOperation =
1885         Operation.newBuilder()
1886             .setName("deleteGcpUserAccessBindingTest")
1887             .setDone(true)
1888             .setResponse(Any.pack(expectedResponse))
1889             .build();
1890     mockAccessContextManager.addResponse(resultOperation);
1891 
1892     String name = "name3373707";
1893 
1894     client.deleteGcpUserAccessBindingAsync(name).get();
1895 
1896     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1897     Assert.assertEquals(1, actualRequests.size());
1898     DeleteGcpUserAccessBindingRequest actualRequest =
1899         ((DeleteGcpUserAccessBindingRequest) actualRequests.get(0));
1900 
1901     Assert.assertEquals(name, actualRequest.getName());
1902     Assert.assertTrue(
1903         channelProvider.isHeaderSent(
1904             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1905             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1906   }
1907 
1908   @Test
deleteGcpUserAccessBindingExceptionTest2()1909   public void deleteGcpUserAccessBindingExceptionTest2() throws Exception {
1910     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1911     mockAccessContextManager.addException(exception);
1912 
1913     try {
1914       String name = "name3373707";
1915       client.deleteGcpUserAccessBindingAsync(name).get();
1916       Assert.fail("No exception raised");
1917     } catch (ExecutionException e) {
1918       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1919       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1920       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1921     }
1922   }
1923 
1924   @Test
setIamPolicyTest()1925   public void setIamPolicyTest() throws Exception {
1926     Policy expectedResponse =
1927         Policy.newBuilder()
1928             .setVersion(351608024)
1929             .addAllBindings(new ArrayList<Binding>())
1930             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1931             .setEtag(ByteString.EMPTY)
1932             .build();
1933     mockAccessContextManager.addResponse(expectedResponse);
1934 
1935     SetIamPolicyRequest request =
1936         SetIamPolicyRequest.newBuilder()
1937             .setResource(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1938             .setPolicy(Policy.newBuilder().build())
1939             .setUpdateMask(FieldMask.newBuilder().build())
1940             .build();
1941 
1942     Policy actualResponse = client.setIamPolicy(request);
1943     Assert.assertEquals(expectedResponse, actualResponse);
1944 
1945     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1946     Assert.assertEquals(1, actualRequests.size());
1947     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1948 
1949     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1950     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1951     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1952     Assert.assertTrue(
1953         channelProvider.isHeaderSent(
1954             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1955             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1956   }
1957 
1958   @Test
setIamPolicyExceptionTest()1959   public void setIamPolicyExceptionTest() throws Exception {
1960     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1961     mockAccessContextManager.addException(exception);
1962 
1963     try {
1964       SetIamPolicyRequest request =
1965           SetIamPolicyRequest.newBuilder()
1966               .setResource(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1967               .setPolicy(Policy.newBuilder().build())
1968               .setUpdateMask(FieldMask.newBuilder().build())
1969               .build();
1970       client.setIamPolicy(request);
1971       Assert.fail("No exception raised");
1972     } catch (InvalidArgumentException e) {
1973       // Expected exception.
1974     }
1975   }
1976 
1977   @Test
getIamPolicyTest()1978   public void getIamPolicyTest() throws Exception {
1979     Policy expectedResponse =
1980         Policy.newBuilder()
1981             .setVersion(351608024)
1982             .addAllBindings(new ArrayList<Binding>())
1983             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1984             .setEtag(ByteString.EMPTY)
1985             .build();
1986     mockAccessContextManager.addResponse(expectedResponse);
1987 
1988     GetIamPolicyRequest request =
1989         GetIamPolicyRequest.newBuilder()
1990             .setResource(AccessPolicyName.of("[ACCESS_POLICY]").toString())
1991             .setOptions(GetPolicyOptions.newBuilder().build())
1992             .build();
1993 
1994     Policy actualResponse = client.getIamPolicy(request);
1995     Assert.assertEquals(expectedResponse, actualResponse);
1996 
1997     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
1998     Assert.assertEquals(1, actualRequests.size());
1999     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
2000 
2001     Assert.assertEquals(request.getResource(), actualRequest.getResource());
2002     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
2003     Assert.assertTrue(
2004         channelProvider.isHeaderSent(
2005             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2006             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2007   }
2008 
2009   @Test
getIamPolicyExceptionTest()2010   public void getIamPolicyExceptionTest() throws Exception {
2011     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2012     mockAccessContextManager.addException(exception);
2013 
2014     try {
2015       GetIamPolicyRequest request =
2016           GetIamPolicyRequest.newBuilder()
2017               .setResource(AccessPolicyName.of("[ACCESS_POLICY]").toString())
2018               .setOptions(GetPolicyOptions.newBuilder().build())
2019               .build();
2020       client.getIamPolicy(request);
2021       Assert.fail("No exception raised");
2022     } catch (InvalidArgumentException e) {
2023       // Expected exception.
2024     }
2025   }
2026 
2027   @Test
testIamPermissionsTest()2028   public void testIamPermissionsTest() throws Exception {
2029     TestIamPermissionsResponse expectedResponse =
2030         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
2031     mockAccessContextManager.addResponse(expectedResponse);
2032 
2033     TestIamPermissionsRequest request =
2034         TestIamPermissionsRequest.newBuilder()
2035             .setResource(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
2036             .addAllPermissions(new ArrayList<String>())
2037             .build();
2038 
2039     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
2040     Assert.assertEquals(expectedResponse, actualResponse);
2041 
2042     List<AbstractMessage> actualRequests = mockAccessContextManager.getRequests();
2043     Assert.assertEquals(1, actualRequests.size());
2044     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
2045 
2046     Assert.assertEquals(request.getResource(), actualRequest.getResource());
2047     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
2048     Assert.assertTrue(
2049         channelProvider.isHeaderSent(
2050             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2051             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2052   }
2053 
2054   @Test
testIamPermissionsExceptionTest()2055   public void testIamPermissionsExceptionTest() throws Exception {
2056     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2057     mockAccessContextManager.addException(exception);
2058 
2059     try {
2060       TestIamPermissionsRequest request =
2061           TestIamPermissionsRequest.newBuilder()
2062               .setResource(AccessLevelName.of("[ACCESS_POLICY]", "[ACCESS_LEVEL]").toString())
2063               .addAllPermissions(new ArrayList<String>())
2064               .build();
2065       client.testIamPermissions(request);
2066       Assert.fail("No exception raised");
2067     } catch (InvalidArgumentException e) {
2068       // Expected exception.
2069     }
2070   }
2071 }
2072