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