• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.networksecurity.v1beta1;
18 
19 import static com.google.cloud.networksecurity.v1beta1.NetworkSecurityClient.ListAuthorizationPoliciesPagedResponse;
20 import static com.google.cloud.networksecurity.v1beta1.NetworkSecurityClient.ListClientTlsPoliciesPagedResponse;
21 import static com.google.cloud.networksecurity.v1beta1.NetworkSecurityClient.ListLocationsPagedResponse;
22 import static com.google.cloud.networksecurity.v1beta1.NetworkSecurityClient.ListServerTlsPoliciesPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
26 import com.google.api.gax.httpjson.testing.MockHttpService;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.ApiException;
29 import com.google.api.gax.rpc.ApiExceptionFactory;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.api.gax.rpc.testing.FakeStatusCode;
33 import com.google.cloud.location.GetLocationRequest;
34 import com.google.cloud.location.ListLocationsRequest;
35 import com.google.cloud.location.ListLocationsResponse;
36 import com.google.cloud.location.Location;
37 import com.google.cloud.networksecurity.v1beta1.stub.HttpJsonNetworkSecurityStub;
38 import com.google.common.collect.Lists;
39 import com.google.iam.v1.AuditConfig;
40 import com.google.iam.v1.Binding;
41 import com.google.iam.v1.GetIamPolicyRequest;
42 import com.google.iam.v1.GetPolicyOptions;
43 import com.google.iam.v1.Policy;
44 import com.google.iam.v1.SetIamPolicyRequest;
45 import com.google.iam.v1.TestIamPermissionsRequest;
46 import com.google.iam.v1.TestIamPermissionsResponse;
47 import com.google.longrunning.Operation;
48 import com.google.protobuf.Any;
49 import com.google.protobuf.ByteString;
50 import com.google.protobuf.Empty;
51 import com.google.protobuf.FieldMask;
52 import com.google.protobuf.Timestamp;
53 import java.io.IOException;
54 import java.util.ArrayList;
55 import java.util.Arrays;
56 import java.util.HashMap;
57 import java.util.List;
58 import java.util.concurrent.ExecutionException;
59 import javax.annotation.Generated;
60 import org.junit.After;
61 import org.junit.AfterClass;
62 import org.junit.Assert;
63 import org.junit.Before;
64 import org.junit.BeforeClass;
65 import org.junit.Test;
66 
67 @Generated("by gapic-generator-java")
68 public class NetworkSecurityClientHttpJsonTest {
69   private static MockHttpService mockService;
70   private static NetworkSecurityClient client;
71 
72   @BeforeClass
startStaticServer()73   public static void startStaticServer() throws IOException {
74     mockService =
75         new MockHttpService(
76             HttpJsonNetworkSecurityStub.getMethodDescriptors(),
77             NetworkSecuritySettings.getDefaultEndpoint());
78     NetworkSecuritySettings settings =
79         NetworkSecuritySettings.newHttpJsonBuilder()
80             .setTransportChannelProvider(
81                 NetworkSecuritySettings.defaultHttpJsonTransportProviderBuilder()
82                     .setHttpTransport(mockService)
83                     .build())
84             .setCredentialsProvider(NoCredentialsProvider.create())
85             .build();
86     client = NetworkSecurityClient.create(settings);
87   }
88 
89   @AfterClass
stopServer()90   public static void stopServer() {
91     client.close();
92   }
93 
94   @Before
setUp()95   public void setUp() {}
96 
97   @After
tearDown()98   public void tearDown() throws Exception {
99     mockService.reset();
100   }
101 
102   @Test
listAuthorizationPoliciesTest()103   public void listAuthorizationPoliciesTest() throws Exception {
104     AuthorizationPolicy responsesElement = AuthorizationPolicy.newBuilder().build();
105     ListAuthorizationPoliciesResponse expectedResponse =
106         ListAuthorizationPoliciesResponse.newBuilder()
107             .setNextPageToken("")
108             .addAllAuthorizationPolicies(Arrays.asList(responsesElement))
109             .build();
110     mockService.addResponse(expectedResponse);
111 
112     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
113 
114     ListAuthorizationPoliciesPagedResponse pagedListResponse =
115         client.listAuthorizationPolicies(parent);
116 
117     List<AuthorizationPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
118 
119     Assert.assertEquals(1, resources.size());
120     Assert.assertEquals(expectedResponse.getAuthorizationPoliciesList().get(0), resources.get(0));
121 
122     List<String> actualRequests = mockService.getRequestPaths();
123     Assert.assertEquals(1, actualRequests.size());
124 
125     String apiClientHeaderKey =
126         mockService
127             .getRequestHeaders()
128             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
129             .iterator()
130             .next();
131     Assert.assertTrue(
132         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
133             .matcher(apiClientHeaderKey)
134             .matches());
135   }
136 
137   @Test
listAuthorizationPoliciesExceptionTest()138   public void listAuthorizationPoliciesExceptionTest() throws Exception {
139     ApiException exception =
140         ApiExceptionFactory.createException(
141             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
142     mockService.addException(exception);
143 
144     try {
145       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
146       client.listAuthorizationPolicies(parent);
147       Assert.fail("No exception raised");
148     } catch (InvalidArgumentException e) {
149       // Expected exception.
150     }
151   }
152 
153   @Test
listAuthorizationPoliciesTest2()154   public void listAuthorizationPoliciesTest2() throws Exception {
155     AuthorizationPolicy responsesElement = AuthorizationPolicy.newBuilder().build();
156     ListAuthorizationPoliciesResponse expectedResponse =
157         ListAuthorizationPoliciesResponse.newBuilder()
158             .setNextPageToken("")
159             .addAllAuthorizationPolicies(Arrays.asList(responsesElement))
160             .build();
161     mockService.addResponse(expectedResponse);
162 
163     String parent = "projects/project-5833/locations/location-5833";
164 
165     ListAuthorizationPoliciesPagedResponse pagedListResponse =
166         client.listAuthorizationPolicies(parent);
167 
168     List<AuthorizationPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
169 
170     Assert.assertEquals(1, resources.size());
171     Assert.assertEquals(expectedResponse.getAuthorizationPoliciesList().get(0), resources.get(0));
172 
173     List<String> actualRequests = mockService.getRequestPaths();
174     Assert.assertEquals(1, actualRequests.size());
175 
176     String apiClientHeaderKey =
177         mockService
178             .getRequestHeaders()
179             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
180             .iterator()
181             .next();
182     Assert.assertTrue(
183         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
184             .matcher(apiClientHeaderKey)
185             .matches());
186   }
187 
188   @Test
listAuthorizationPoliciesExceptionTest2()189   public void listAuthorizationPoliciesExceptionTest2() throws Exception {
190     ApiException exception =
191         ApiExceptionFactory.createException(
192             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
193     mockService.addException(exception);
194 
195     try {
196       String parent = "projects/project-5833/locations/location-5833";
197       client.listAuthorizationPolicies(parent);
198       Assert.fail("No exception raised");
199     } catch (InvalidArgumentException e) {
200       // Expected exception.
201     }
202   }
203 
204   @Test
getAuthorizationPolicyTest()205   public void getAuthorizationPolicyTest() throws Exception {
206     AuthorizationPolicy expectedResponse =
207         AuthorizationPolicy.newBuilder()
208             .setName(
209                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
210                     .toString())
211             .setDescription("description-1724546052")
212             .setCreateTime(Timestamp.newBuilder().build())
213             .setUpdateTime(Timestamp.newBuilder().build())
214             .putAllLabels(new HashMap<String, String>())
215             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
216             .build();
217     mockService.addResponse(expectedResponse);
218 
219     AuthorizationPolicyName name =
220         AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]");
221 
222     AuthorizationPolicy actualResponse = client.getAuthorizationPolicy(name);
223     Assert.assertEquals(expectedResponse, actualResponse);
224 
225     List<String> actualRequests = mockService.getRequestPaths();
226     Assert.assertEquals(1, actualRequests.size());
227 
228     String apiClientHeaderKey =
229         mockService
230             .getRequestHeaders()
231             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
232             .iterator()
233             .next();
234     Assert.assertTrue(
235         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
236             .matcher(apiClientHeaderKey)
237             .matches());
238   }
239 
240   @Test
getAuthorizationPolicyExceptionTest()241   public void getAuthorizationPolicyExceptionTest() throws Exception {
242     ApiException exception =
243         ApiExceptionFactory.createException(
244             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
245     mockService.addException(exception);
246 
247     try {
248       AuthorizationPolicyName name =
249           AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]");
250       client.getAuthorizationPolicy(name);
251       Assert.fail("No exception raised");
252     } catch (InvalidArgumentException e) {
253       // Expected exception.
254     }
255   }
256 
257   @Test
getAuthorizationPolicyTest2()258   public void getAuthorizationPolicyTest2() throws Exception {
259     AuthorizationPolicy expectedResponse =
260         AuthorizationPolicy.newBuilder()
261             .setName(
262                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
263                     .toString())
264             .setDescription("description-1724546052")
265             .setCreateTime(Timestamp.newBuilder().build())
266             .setUpdateTime(Timestamp.newBuilder().build())
267             .putAllLabels(new HashMap<String, String>())
268             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
269             .build();
270     mockService.addResponse(expectedResponse);
271 
272     String name =
273         "projects/project-7969/locations/location-7969/authorizationPolicies/authorizationPolicie-7969";
274 
275     AuthorizationPolicy actualResponse = client.getAuthorizationPolicy(name);
276     Assert.assertEquals(expectedResponse, actualResponse);
277 
278     List<String> actualRequests = mockService.getRequestPaths();
279     Assert.assertEquals(1, actualRequests.size());
280 
281     String apiClientHeaderKey =
282         mockService
283             .getRequestHeaders()
284             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
285             .iterator()
286             .next();
287     Assert.assertTrue(
288         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
289             .matcher(apiClientHeaderKey)
290             .matches());
291   }
292 
293   @Test
getAuthorizationPolicyExceptionTest2()294   public void getAuthorizationPolicyExceptionTest2() throws Exception {
295     ApiException exception =
296         ApiExceptionFactory.createException(
297             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
298     mockService.addException(exception);
299 
300     try {
301       String name =
302           "projects/project-7969/locations/location-7969/authorizationPolicies/authorizationPolicie-7969";
303       client.getAuthorizationPolicy(name);
304       Assert.fail("No exception raised");
305     } catch (InvalidArgumentException e) {
306       // Expected exception.
307     }
308   }
309 
310   @Test
createAuthorizationPolicyTest()311   public void createAuthorizationPolicyTest() throws Exception {
312     AuthorizationPolicy expectedResponse =
313         AuthorizationPolicy.newBuilder()
314             .setName(
315                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
316                     .toString())
317             .setDescription("description-1724546052")
318             .setCreateTime(Timestamp.newBuilder().build())
319             .setUpdateTime(Timestamp.newBuilder().build())
320             .putAllLabels(new HashMap<String, String>())
321             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
322             .build();
323     Operation resultOperation =
324         Operation.newBuilder()
325             .setName("createAuthorizationPolicyTest")
326             .setDone(true)
327             .setResponse(Any.pack(expectedResponse))
328             .build();
329     mockService.addResponse(resultOperation);
330 
331     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
332     AuthorizationPolicy authorizationPolicy = AuthorizationPolicy.newBuilder().build();
333     String authorizationPolicyId = "authorizationPolicyId1314252166";
334 
335     AuthorizationPolicy actualResponse =
336         client
337             .createAuthorizationPolicyAsync(parent, authorizationPolicy, authorizationPolicyId)
338             .get();
339     Assert.assertEquals(expectedResponse, actualResponse);
340 
341     List<String> actualRequests = mockService.getRequestPaths();
342     Assert.assertEquals(1, actualRequests.size());
343 
344     String apiClientHeaderKey =
345         mockService
346             .getRequestHeaders()
347             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
348             .iterator()
349             .next();
350     Assert.assertTrue(
351         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
352             .matcher(apiClientHeaderKey)
353             .matches());
354   }
355 
356   @Test
createAuthorizationPolicyExceptionTest()357   public void createAuthorizationPolicyExceptionTest() throws Exception {
358     ApiException exception =
359         ApiExceptionFactory.createException(
360             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
361     mockService.addException(exception);
362 
363     try {
364       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
365       AuthorizationPolicy authorizationPolicy = AuthorizationPolicy.newBuilder().build();
366       String authorizationPolicyId = "authorizationPolicyId1314252166";
367       client
368           .createAuthorizationPolicyAsync(parent, authorizationPolicy, authorizationPolicyId)
369           .get();
370       Assert.fail("No exception raised");
371     } catch (ExecutionException e) {
372     }
373   }
374 
375   @Test
createAuthorizationPolicyTest2()376   public void createAuthorizationPolicyTest2() throws Exception {
377     AuthorizationPolicy expectedResponse =
378         AuthorizationPolicy.newBuilder()
379             .setName(
380                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
381                     .toString())
382             .setDescription("description-1724546052")
383             .setCreateTime(Timestamp.newBuilder().build())
384             .setUpdateTime(Timestamp.newBuilder().build())
385             .putAllLabels(new HashMap<String, String>())
386             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
387             .build();
388     Operation resultOperation =
389         Operation.newBuilder()
390             .setName("createAuthorizationPolicyTest")
391             .setDone(true)
392             .setResponse(Any.pack(expectedResponse))
393             .build();
394     mockService.addResponse(resultOperation);
395 
396     String parent = "projects/project-5833/locations/location-5833";
397     AuthorizationPolicy authorizationPolicy = AuthorizationPolicy.newBuilder().build();
398     String authorizationPolicyId = "authorizationPolicyId1314252166";
399 
400     AuthorizationPolicy actualResponse =
401         client
402             .createAuthorizationPolicyAsync(parent, authorizationPolicy, authorizationPolicyId)
403             .get();
404     Assert.assertEquals(expectedResponse, actualResponse);
405 
406     List<String> actualRequests = mockService.getRequestPaths();
407     Assert.assertEquals(1, actualRequests.size());
408 
409     String apiClientHeaderKey =
410         mockService
411             .getRequestHeaders()
412             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
413             .iterator()
414             .next();
415     Assert.assertTrue(
416         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
417             .matcher(apiClientHeaderKey)
418             .matches());
419   }
420 
421   @Test
createAuthorizationPolicyExceptionTest2()422   public void createAuthorizationPolicyExceptionTest2() throws Exception {
423     ApiException exception =
424         ApiExceptionFactory.createException(
425             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
426     mockService.addException(exception);
427 
428     try {
429       String parent = "projects/project-5833/locations/location-5833";
430       AuthorizationPolicy authorizationPolicy = AuthorizationPolicy.newBuilder().build();
431       String authorizationPolicyId = "authorizationPolicyId1314252166";
432       client
433           .createAuthorizationPolicyAsync(parent, authorizationPolicy, authorizationPolicyId)
434           .get();
435       Assert.fail("No exception raised");
436     } catch (ExecutionException e) {
437     }
438   }
439 
440   @Test
updateAuthorizationPolicyTest()441   public void updateAuthorizationPolicyTest() throws Exception {
442     AuthorizationPolicy expectedResponse =
443         AuthorizationPolicy.newBuilder()
444             .setName(
445                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
446                     .toString())
447             .setDescription("description-1724546052")
448             .setCreateTime(Timestamp.newBuilder().build())
449             .setUpdateTime(Timestamp.newBuilder().build())
450             .putAllLabels(new HashMap<String, String>())
451             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
452             .build();
453     Operation resultOperation =
454         Operation.newBuilder()
455             .setName("updateAuthorizationPolicyTest")
456             .setDone(true)
457             .setResponse(Any.pack(expectedResponse))
458             .build();
459     mockService.addResponse(resultOperation);
460 
461     AuthorizationPolicy authorizationPolicy =
462         AuthorizationPolicy.newBuilder()
463             .setName(
464                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
465                     .toString())
466             .setDescription("description-1724546052")
467             .setCreateTime(Timestamp.newBuilder().build())
468             .setUpdateTime(Timestamp.newBuilder().build())
469             .putAllLabels(new HashMap<String, String>())
470             .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
471             .build();
472     FieldMask updateMask = FieldMask.newBuilder().build();
473 
474     AuthorizationPolicy actualResponse =
475         client.updateAuthorizationPolicyAsync(authorizationPolicy, updateMask).get();
476     Assert.assertEquals(expectedResponse, actualResponse);
477 
478     List<String> actualRequests = mockService.getRequestPaths();
479     Assert.assertEquals(1, actualRequests.size());
480 
481     String apiClientHeaderKey =
482         mockService
483             .getRequestHeaders()
484             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
485             .iterator()
486             .next();
487     Assert.assertTrue(
488         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
489             .matcher(apiClientHeaderKey)
490             .matches());
491   }
492 
493   @Test
updateAuthorizationPolicyExceptionTest()494   public void updateAuthorizationPolicyExceptionTest() throws Exception {
495     ApiException exception =
496         ApiExceptionFactory.createException(
497             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
498     mockService.addException(exception);
499 
500     try {
501       AuthorizationPolicy authorizationPolicy =
502           AuthorizationPolicy.newBuilder()
503               .setName(
504                   AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
505                       .toString())
506               .setDescription("description-1724546052")
507               .setCreateTime(Timestamp.newBuilder().build())
508               .setUpdateTime(Timestamp.newBuilder().build())
509               .putAllLabels(new HashMap<String, String>())
510               .addAllRules(new ArrayList<AuthorizationPolicy.Rule>())
511               .build();
512       FieldMask updateMask = FieldMask.newBuilder().build();
513       client.updateAuthorizationPolicyAsync(authorizationPolicy, updateMask).get();
514       Assert.fail("No exception raised");
515     } catch (ExecutionException e) {
516     }
517   }
518 
519   @Test
deleteAuthorizationPolicyTest()520   public void deleteAuthorizationPolicyTest() throws Exception {
521     Empty expectedResponse = Empty.newBuilder().build();
522     Operation resultOperation =
523         Operation.newBuilder()
524             .setName("deleteAuthorizationPolicyTest")
525             .setDone(true)
526             .setResponse(Any.pack(expectedResponse))
527             .build();
528     mockService.addResponse(resultOperation);
529 
530     AuthorizationPolicyName name =
531         AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]");
532 
533     client.deleteAuthorizationPolicyAsync(name).get();
534 
535     List<String> actualRequests = mockService.getRequestPaths();
536     Assert.assertEquals(1, actualRequests.size());
537 
538     String apiClientHeaderKey =
539         mockService
540             .getRequestHeaders()
541             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
542             .iterator()
543             .next();
544     Assert.assertTrue(
545         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
546             .matcher(apiClientHeaderKey)
547             .matches());
548   }
549 
550   @Test
deleteAuthorizationPolicyExceptionTest()551   public void deleteAuthorizationPolicyExceptionTest() throws Exception {
552     ApiException exception =
553         ApiExceptionFactory.createException(
554             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
555     mockService.addException(exception);
556 
557     try {
558       AuthorizationPolicyName name =
559           AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]");
560       client.deleteAuthorizationPolicyAsync(name).get();
561       Assert.fail("No exception raised");
562     } catch (ExecutionException e) {
563     }
564   }
565 
566   @Test
deleteAuthorizationPolicyTest2()567   public void deleteAuthorizationPolicyTest2() throws Exception {
568     Empty expectedResponse = Empty.newBuilder().build();
569     Operation resultOperation =
570         Operation.newBuilder()
571             .setName("deleteAuthorizationPolicyTest")
572             .setDone(true)
573             .setResponse(Any.pack(expectedResponse))
574             .build();
575     mockService.addResponse(resultOperation);
576 
577     String name =
578         "projects/project-7969/locations/location-7969/authorizationPolicies/authorizationPolicie-7969";
579 
580     client.deleteAuthorizationPolicyAsync(name).get();
581 
582     List<String> actualRequests = mockService.getRequestPaths();
583     Assert.assertEquals(1, actualRequests.size());
584 
585     String apiClientHeaderKey =
586         mockService
587             .getRequestHeaders()
588             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
589             .iterator()
590             .next();
591     Assert.assertTrue(
592         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
593             .matcher(apiClientHeaderKey)
594             .matches());
595   }
596 
597   @Test
deleteAuthorizationPolicyExceptionTest2()598   public void deleteAuthorizationPolicyExceptionTest2() throws Exception {
599     ApiException exception =
600         ApiExceptionFactory.createException(
601             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
602     mockService.addException(exception);
603 
604     try {
605       String name =
606           "projects/project-7969/locations/location-7969/authorizationPolicies/authorizationPolicie-7969";
607       client.deleteAuthorizationPolicyAsync(name).get();
608       Assert.fail("No exception raised");
609     } catch (ExecutionException e) {
610     }
611   }
612 
613   @Test
listServerTlsPoliciesTest()614   public void listServerTlsPoliciesTest() throws Exception {
615     ServerTlsPolicy responsesElement = ServerTlsPolicy.newBuilder().build();
616     ListServerTlsPoliciesResponse expectedResponse =
617         ListServerTlsPoliciesResponse.newBuilder()
618             .setNextPageToken("")
619             .addAllServerTlsPolicies(Arrays.asList(responsesElement))
620             .build();
621     mockService.addResponse(expectedResponse);
622 
623     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
624 
625     ListServerTlsPoliciesPagedResponse pagedListResponse = client.listServerTlsPolicies(parent);
626 
627     List<ServerTlsPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
628 
629     Assert.assertEquals(1, resources.size());
630     Assert.assertEquals(expectedResponse.getServerTlsPoliciesList().get(0), resources.get(0));
631 
632     List<String> actualRequests = mockService.getRequestPaths();
633     Assert.assertEquals(1, actualRequests.size());
634 
635     String apiClientHeaderKey =
636         mockService
637             .getRequestHeaders()
638             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
639             .iterator()
640             .next();
641     Assert.assertTrue(
642         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
643             .matcher(apiClientHeaderKey)
644             .matches());
645   }
646 
647   @Test
listServerTlsPoliciesExceptionTest()648   public void listServerTlsPoliciesExceptionTest() throws Exception {
649     ApiException exception =
650         ApiExceptionFactory.createException(
651             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
652     mockService.addException(exception);
653 
654     try {
655       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
656       client.listServerTlsPolicies(parent);
657       Assert.fail("No exception raised");
658     } catch (InvalidArgumentException e) {
659       // Expected exception.
660     }
661   }
662 
663   @Test
listServerTlsPoliciesTest2()664   public void listServerTlsPoliciesTest2() throws Exception {
665     ServerTlsPolicy responsesElement = ServerTlsPolicy.newBuilder().build();
666     ListServerTlsPoliciesResponse expectedResponse =
667         ListServerTlsPoliciesResponse.newBuilder()
668             .setNextPageToken("")
669             .addAllServerTlsPolicies(Arrays.asList(responsesElement))
670             .build();
671     mockService.addResponse(expectedResponse);
672 
673     String parent = "projects/project-5833/locations/location-5833";
674 
675     ListServerTlsPoliciesPagedResponse pagedListResponse = client.listServerTlsPolicies(parent);
676 
677     List<ServerTlsPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
678 
679     Assert.assertEquals(1, resources.size());
680     Assert.assertEquals(expectedResponse.getServerTlsPoliciesList().get(0), resources.get(0));
681 
682     List<String> actualRequests = mockService.getRequestPaths();
683     Assert.assertEquals(1, actualRequests.size());
684 
685     String apiClientHeaderKey =
686         mockService
687             .getRequestHeaders()
688             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
689             .iterator()
690             .next();
691     Assert.assertTrue(
692         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
693             .matcher(apiClientHeaderKey)
694             .matches());
695   }
696 
697   @Test
listServerTlsPoliciesExceptionTest2()698   public void listServerTlsPoliciesExceptionTest2() throws Exception {
699     ApiException exception =
700         ApiExceptionFactory.createException(
701             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
702     mockService.addException(exception);
703 
704     try {
705       String parent = "projects/project-5833/locations/location-5833";
706       client.listServerTlsPolicies(parent);
707       Assert.fail("No exception raised");
708     } catch (InvalidArgumentException e) {
709       // Expected exception.
710     }
711   }
712 
713   @Test
getServerTlsPolicyTest()714   public void getServerTlsPolicyTest() throws Exception {
715     ServerTlsPolicy expectedResponse =
716         ServerTlsPolicy.newBuilder()
717             .setName(
718                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
719             .setDescription("description-1724546052")
720             .setCreateTime(Timestamp.newBuilder().build())
721             .setUpdateTime(Timestamp.newBuilder().build())
722             .putAllLabels(new HashMap<String, String>())
723             .setAllowOpen(true)
724             .setServerCertificate(CertificateProvider.newBuilder().build())
725             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
726             .build();
727     mockService.addResponse(expectedResponse);
728 
729     ServerTlsPolicyName name =
730         ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]");
731 
732     ServerTlsPolicy actualResponse = client.getServerTlsPolicy(name);
733     Assert.assertEquals(expectedResponse, actualResponse);
734 
735     List<String> actualRequests = mockService.getRequestPaths();
736     Assert.assertEquals(1, actualRequests.size());
737 
738     String apiClientHeaderKey =
739         mockService
740             .getRequestHeaders()
741             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
742             .iterator()
743             .next();
744     Assert.assertTrue(
745         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
746             .matcher(apiClientHeaderKey)
747             .matches());
748   }
749 
750   @Test
getServerTlsPolicyExceptionTest()751   public void getServerTlsPolicyExceptionTest() throws Exception {
752     ApiException exception =
753         ApiExceptionFactory.createException(
754             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
755     mockService.addException(exception);
756 
757     try {
758       ServerTlsPolicyName name =
759           ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]");
760       client.getServerTlsPolicy(name);
761       Assert.fail("No exception raised");
762     } catch (InvalidArgumentException e) {
763       // Expected exception.
764     }
765   }
766 
767   @Test
getServerTlsPolicyTest2()768   public void getServerTlsPolicyTest2() throws Exception {
769     ServerTlsPolicy expectedResponse =
770         ServerTlsPolicy.newBuilder()
771             .setName(
772                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
773             .setDescription("description-1724546052")
774             .setCreateTime(Timestamp.newBuilder().build())
775             .setUpdateTime(Timestamp.newBuilder().build())
776             .putAllLabels(new HashMap<String, String>())
777             .setAllowOpen(true)
778             .setServerCertificate(CertificateProvider.newBuilder().build())
779             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
780             .build();
781     mockService.addResponse(expectedResponse);
782 
783     String name =
784         "projects/project-7730/locations/location-7730/serverTlsPolicies/serverTlsPolicie-7730";
785 
786     ServerTlsPolicy actualResponse = client.getServerTlsPolicy(name);
787     Assert.assertEquals(expectedResponse, actualResponse);
788 
789     List<String> actualRequests = mockService.getRequestPaths();
790     Assert.assertEquals(1, actualRequests.size());
791 
792     String apiClientHeaderKey =
793         mockService
794             .getRequestHeaders()
795             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
796             .iterator()
797             .next();
798     Assert.assertTrue(
799         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
800             .matcher(apiClientHeaderKey)
801             .matches());
802   }
803 
804   @Test
getServerTlsPolicyExceptionTest2()805   public void getServerTlsPolicyExceptionTest2() throws Exception {
806     ApiException exception =
807         ApiExceptionFactory.createException(
808             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
809     mockService.addException(exception);
810 
811     try {
812       String name =
813           "projects/project-7730/locations/location-7730/serverTlsPolicies/serverTlsPolicie-7730";
814       client.getServerTlsPolicy(name);
815       Assert.fail("No exception raised");
816     } catch (InvalidArgumentException e) {
817       // Expected exception.
818     }
819   }
820 
821   @Test
createServerTlsPolicyTest()822   public void createServerTlsPolicyTest() throws Exception {
823     ServerTlsPolicy expectedResponse =
824         ServerTlsPolicy.newBuilder()
825             .setName(
826                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
827             .setDescription("description-1724546052")
828             .setCreateTime(Timestamp.newBuilder().build())
829             .setUpdateTime(Timestamp.newBuilder().build())
830             .putAllLabels(new HashMap<String, String>())
831             .setAllowOpen(true)
832             .setServerCertificate(CertificateProvider.newBuilder().build())
833             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
834             .build();
835     Operation resultOperation =
836         Operation.newBuilder()
837             .setName("createServerTlsPolicyTest")
838             .setDone(true)
839             .setResponse(Any.pack(expectedResponse))
840             .build();
841     mockService.addResponse(resultOperation);
842 
843     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
844     ServerTlsPolicy serverTlsPolicy = ServerTlsPolicy.newBuilder().build();
845     String serverTlsPolicyId = "serverTlsPolicyId-1966046011";
846 
847     ServerTlsPolicy actualResponse =
848         client.createServerTlsPolicyAsync(parent, serverTlsPolicy, serverTlsPolicyId).get();
849     Assert.assertEquals(expectedResponse, actualResponse);
850 
851     List<String> actualRequests = mockService.getRequestPaths();
852     Assert.assertEquals(1, actualRequests.size());
853 
854     String apiClientHeaderKey =
855         mockService
856             .getRequestHeaders()
857             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
858             .iterator()
859             .next();
860     Assert.assertTrue(
861         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
862             .matcher(apiClientHeaderKey)
863             .matches());
864   }
865 
866   @Test
createServerTlsPolicyExceptionTest()867   public void createServerTlsPolicyExceptionTest() throws Exception {
868     ApiException exception =
869         ApiExceptionFactory.createException(
870             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
871     mockService.addException(exception);
872 
873     try {
874       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
875       ServerTlsPolicy serverTlsPolicy = ServerTlsPolicy.newBuilder().build();
876       String serverTlsPolicyId = "serverTlsPolicyId-1966046011";
877       client.createServerTlsPolicyAsync(parent, serverTlsPolicy, serverTlsPolicyId).get();
878       Assert.fail("No exception raised");
879     } catch (ExecutionException e) {
880     }
881   }
882 
883   @Test
createServerTlsPolicyTest2()884   public void createServerTlsPolicyTest2() throws Exception {
885     ServerTlsPolicy expectedResponse =
886         ServerTlsPolicy.newBuilder()
887             .setName(
888                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
889             .setDescription("description-1724546052")
890             .setCreateTime(Timestamp.newBuilder().build())
891             .setUpdateTime(Timestamp.newBuilder().build())
892             .putAllLabels(new HashMap<String, String>())
893             .setAllowOpen(true)
894             .setServerCertificate(CertificateProvider.newBuilder().build())
895             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
896             .build();
897     Operation resultOperation =
898         Operation.newBuilder()
899             .setName("createServerTlsPolicyTest")
900             .setDone(true)
901             .setResponse(Any.pack(expectedResponse))
902             .build();
903     mockService.addResponse(resultOperation);
904 
905     String parent = "projects/project-5833/locations/location-5833";
906     ServerTlsPolicy serverTlsPolicy = ServerTlsPolicy.newBuilder().build();
907     String serverTlsPolicyId = "serverTlsPolicyId-1966046011";
908 
909     ServerTlsPolicy actualResponse =
910         client.createServerTlsPolicyAsync(parent, serverTlsPolicy, serverTlsPolicyId).get();
911     Assert.assertEquals(expectedResponse, actualResponse);
912 
913     List<String> actualRequests = mockService.getRequestPaths();
914     Assert.assertEquals(1, actualRequests.size());
915 
916     String apiClientHeaderKey =
917         mockService
918             .getRequestHeaders()
919             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
920             .iterator()
921             .next();
922     Assert.assertTrue(
923         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
924             .matcher(apiClientHeaderKey)
925             .matches());
926   }
927 
928   @Test
createServerTlsPolicyExceptionTest2()929   public void createServerTlsPolicyExceptionTest2() throws Exception {
930     ApiException exception =
931         ApiExceptionFactory.createException(
932             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
933     mockService.addException(exception);
934 
935     try {
936       String parent = "projects/project-5833/locations/location-5833";
937       ServerTlsPolicy serverTlsPolicy = ServerTlsPolicy.newBuilder().build();
938       String serverTlsPolicyId = "serverTlsPolicyId-1966046011";
939       client.createServerTlsPolicyAsync(parent, serverTlsPolicy, serverTlsPolicyId).get();
940       Assert.fail("No exception raised");
941     } catch (ExecutionException e) {
942     }
943   }
944 
945   @Test
updateServerTlsPolicyTest()946   public void updateServerTlsPolicyTest() throws Exception {
947     ServerTlsPolicy expectedResponse =
948         ServerTlsPolicy.newBuilder()
949             .setName(
950                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
951             .setDescription("description-1724546052")
952             .setCreateTime(Timestamp.newBuilder().build())
953             .setUpdateTime(Timestamp.newBuilder().build())
954             .putAllLabels(new HashMap<String, String>())
955             .setAllowOpen(true)
956             .setServerCertificate(CertificateProvider.newBuilder().build())
957             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
958             .build();
959     Operation resultOperation =
960         Operation.newBuilder()
961             .setName("updateServerTlsPolicyTest")
962             .setDone(true)
963             .setResponse(Any.pack(expectedResponse))
964             .build();
965     mockService.addResponse(resultOperation);
966 
967     ServerTlsPolicy serverTlsPolicy =
968         ServerTlsPolicy.newBuilder()
969             .setName(
970                 ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]").toString())
971             .setDescription("description-1724546052")
972             .setCreateTime(Timestamp.newBuilder().build())
973             .setUpdateTime(Timestamp.newBuilder().build())
974             .putAllLabels(new HashMap<String, String>())
975             .setAllowOpen(true)
976             .setServerCertificate(CertificateProvider.newBuilder().build())
977             .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
978             .build();
979     FieldMask updateMask = FieldMask.newBuilder().build();
980 
981     ServerTlsPolicy actualResponse =
982         client.updateServerTlsPolicyAsync(serverTlsPolicy, updateMask).get();
983     Assert.assertEquals(expectedResponse, actualResponse);
984 
985     List<String> actualRequests = mockService.getRequestPaths();
986     Assert.assertEquals(1, actualRequests.size());
987 
988     String apiClientHeaderKey =
989         mockService
990             .getRequestHeaders()
991             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
992             .iterator()
993             .next();
994     Assert.assertTrue(
995         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
996             .matcher(apiClientHeaderKey)
997             .matches());
998   }
999 
1000   @Test
updateServerTlsPolicyExceptionTest()1001   public void updateServerTlsPolicyExceptionTest() throws Exception {
1002     ApiException exception =
1003         ApiExceptionFactory.createException(
1004             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1005     mockService.addException(exception);
1006 
1007     try {
1008       ServerTlsPolicy serverTlsPolicy =
1009           ServerTlsPolicy.newBuilder()
1010               .setName(
1011                   ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]")
1012                       .toString())
1013               .setDescription("description-1724546052")
1014               .setCreateTime(Timestamp.newBuilder().build())
1015               .setUpdateTime(Timestamp.newBuilder().build())
1016               .putAllLabels(new HashMap<String, String>())
1017               .setAllowOpen(true)
1018               .setServerCertificate(CertificateProvider.newBuilder().build())
1019               .setMtlsPolicy(ServerTlsPolicy.MTLSPolicy.newBuilder().build())
1020               .build();
1021       FieldMask updateMask = FieldMask.newBuilder().build();
1022       client.updateServerTlsPolicyAsync(serverTlsPolicy, updateMask).get();
1023       Assert.fail("No exception raised");
1024     } catch (ExecutionException e) {
1025     }
1026   }
1027 
1028   @Test
deleteServerTlsPolicyTest()1029   public void deleteServerTlsPolicyTest() throws Exception {
1030     Empty expectedResponse = Empty.newBuilder().build();
1031     Operation resultOperation =
1032         Operation.newBuilder()
1033             .setName("deleteServerTlsPolicyTest")
1034             .setDone(true)
1035             .setResponse(Any.pack(expectedResponse))
1036             .build();
1037     mockService.addResponse(resultOperation);
1038 
1039     ServerTlsPolicyName name =
1040         ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]");
1041 
1042     client.deleteServerTlsPolicyAsync(name).get();
1043 
1044     List<String> actualRequests = mockService.getRequestPaths();
1045     Assert.assertEquals(1, actualRequests.size());
1046 
1047     String apiClientHeaderKey =
1048         mockService
1049             .getRequestHeaders()
1050             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1051             .iterator()
1052             .next();
1053     Assert.assertTrue(
1054         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1055             .matcher(apiClientHeaderKey)
1056             .matches());
1057   }
1058 
1059   @Test
deleteServerTlsPolicyExceptionTest()1060   public void deleteServerTlsPolicyExceptionTest() throws Exception {
1061     ApiException exception =
1062         ApiExceptionFactory.createException(
1063             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1064     mockService.addException(exception);
1065 
1066     try {
1067       ServerTlsPolicyName name =
1068           ServerTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[SERVER_TLS_POLICY]");
1069       client.deleteServerTlsPolicyAsync(name).get();
1070       Assert.fail("No exception raised");
1071     } catch (ExecutionException e) {
1072     }
1073   }
1074 
1075   @Test
deleteServerTlsPolicyTest2()1076   public void deleteServerTlsPolicyTest2() throws Exception {
1077     Empty expectedResponse = Empty.newBuilder().build();
1078     Operation resultOperation =
1079         Operation.newBuilder()
1080             .setName("deleteServerTlsPolicyTest")
1081             .setDone(true)
1082             .setResponse(Any.pack(expectedResponse))
1083             .build();
1084     mockService.addResponse(resultOperation);
1085 
1086     String name =
1087         "projects/project-7730/locations/location-7730/serverTlsPolicies/serverTlsPolicie-7730";
1088 
1089     client.deleteServerTlsPolicyAsync(name).get();
1090 
1091     List<String> actualRequests = mockService.getRequestPaths();
1092     Assert.assertEquals(1, actualRequests.size());
1093 
1094     String apiClientHeaderKey =
1095         mockService
1096             .getRequestHeaders()
1097             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1098             .iterator()
1099             .next();
1100     Assert.assertTrue(
1101         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1102             .matcher(apiClientHeaderKey)
1103             .matches());
1104   }
1105 
1106   @Test
deleteServerTlsPolicyExceptionTest2()1107   public void deleteServerTlsPolicyExceptionTest2() throws Exception {
1108     ApiException exception =
1109         ApiExceptionFactory.createException(
1110             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1111     mockService.addException(exception);
1112 
1113     try {
1114       String name =
1115           "projects/project-7730/locations/location-7730/serverTlsPolicies/serverTlsPolicie-7730";
1116       client.deleteServerTlsPolicyAsync(name).get();
1117       Assert.fail("No exception raised");
1118     } catch (ExecutionException e) {
1119     }
1120   }
1121 
1122   @Test
listClientTlsPoliciesTest()1123   public void listClientTlsPoliciesTest() throws Exception {
1124     ClientTlsPolicy responsesElement = ClientTlsPolicy.newBuilder().build();
1125     ListClientTlsPoliciesResponse expectedResponse =
1126         ListClientTlsPoliciesResponse.newBuilder()
1127             .setNextPageToken("")
1128             .addAllClientTlsPolicies(Arrays.asList(responsesElement))
1129             .build();
1130     mockService.addResponse(expectedResponse);
1131 
1132     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1133 
1134     ListClientTlsPoliciesPagedResponse pagedListResponse = client.listClientTlsPolicies(parent);
1135 
1136     List<ClientTlsPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1137 
1138     Assert.assertEquals(1, resources.size());
1139     Assert.assertEquals(expectedResponse.getClientTlsPoliciesList().get(0), resources.get(0));
1140 
1141     List<String> actualRequests = mockService.getRequestPaths();
1142     Assert.assertEquals(1, actualRequests.size());
1143 
1144     String apiClientHeaderKey =
1145         mockService
1146             .getRequestHeaders()
1147             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1148             .iterator()
1149             .next();
1150     Assert.assertTrue(
1151         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1152             .matcher(apiClientHeaderKey)
1153             .matches());
1154   }
1155 
1156   @Test
listClientTlsPoliciesExceptionTest()1157   public void listClientTlsPoliciesExceptionTest() throws Exception {
1158     ApiException exception =
1159         ApiExceptionFactory.createException(
1160             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1161     mockService.addException(exception);
1162 
1163     try {
1164       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1165       client.listClientTlsPolicies(parent);
1166       Assert.fail("No exception raised");
1167     } catch (InvalidArgumentException e) {
1168       // Expected exception.
1169     }
1170   }
1171 
1172   @Test
listClientTlsPoliciesTest2()1173   public void listClientTlsPoliciesTest2() throws Exception {
1174     ClientTlsPolicy responsesElement = ClientTlsPolicy.newBuilder().build();
1175     ListClientTlsPoliciesResponse expectedResponse =
1176         ListClientTlsPoliciesResponse.newBuilder()
1177             .setNextPageToken("")
1178             .addAllClientTlsPolicies(Arrays.asList(responsesElement))
1179             .build();
1180     mockService.addResponse(expectedResponse);
1181 
1182     String parent = "projects/project-5833/locations/location-5833";
1183 
1184     ListClientTlsPoliciesPagedResponse pagedListResponse = client.listClientTlsPolicies(parent);
1185 
1186     List<ClientTlsPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1187 
1188     Assert.assertEquals(1, resources.size());
1189     Assert.assertEquals(expectedResponse.getClientTlsPoliciesList().get(0), resources.get(0));
1190 
1191     List<String> actualRequests = mockService.getRequestPaths();
1192     Assert.assertEquals(1, actualRequests.size());
1193 
1194     String apiClientHeaderKey =
1195         mockService
1196             .getRequestHeaders()
1197             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1198             .iterator()
1199             .next();
1200     Assert.assertTrue(
1201         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1202             .matcher(apiClientHeaderKey)
1203             .matches());
1204   }
1205 
1206   @Test
listClientTlsPoliciesExceptionTest2()1207   public void listClientTlsPoliciesExceptionTest2() throws Exception {
1208     ApiException exception =
1209         ApiExceptionFactory.createException(
1210             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1211     mockService.addException(exception);
1212 
1213     try {
1214       String parent = "projects/project-5833/locations/location-5833";
1215       client.listClientTlsPolicies(parent);
1216       Assert.fail("No exception raised");
1217     } catch (InvalidArgumentException e) {
1218       // Expected exception.
1219     }
1220   }
1221 
1222   @Test
getClientTlsPolicyTest()1223   public void getClientTlsPolicyTest() throws Exception {
1224     ClientTlsPolicy expectedResponse =
1225         ClientTlsPolicy.newBuilder()
1226             .setName(
1227                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1228             .setDescription("description-1724546052")
1229             .setCreateTime(Timestamp.newBuilder().build())
1230             .setUpdateTime(Timestamp.newBuilder().build())
1231             .putAllLabels(new HashMap<String, String>())
1232             .setSni("sni114030")
1233             .setClientCertificate(CertificateProvider.newBuilder().build())
1234             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1235             .build();
1236     mockService.addResponse(expectedResponse);
1237 
1238     ClientTlsPolicyName name =
1239         ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]");
1240 
1241     ClientTlsPolicy actualResponse = client.getClientTlsPolicy(name);
1242     Assert.assertEquals(expectedResponse, actualResponse);
1243 
1244     List<String> actualRequests = mockService.getRequestPaths();
1245     Assert.assertEquals(1, actualRequests.size());
1246 
1247     String apiClientHeaderKey =
1248         mockService
1249             .getRequestHeaders()
1250             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1251             .iterator()
1252             .next();
1253     Assert.assertTrue(
1254         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1255             .matcher(apiClientHeaderKey)
1256             .matches());
1257   }
1258 
1259   @Test
getClientTlsPolicyExceptionTest()1260   public void getClientTlsPolicyExceptionTest() throws Exception {
1261     ApiException exception =
1262         ApiExceptionFactory.createException(
1263             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1264     mockService.addException(exception);
1265 
1266     try {
1267       ClientTlsPolicyName name =
1268           ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]");
1269       client.getClientTlsPolicy(name);
1270       Assert.fail("No exception raised");
1271     } catch (InvalidArgumentException e) {
1272       // Expected exception.
1273     }
1274   }
1275 
1276   @Test
getClientTlsPolicyTest2()1277   public void getClientTlsPolicyTest2() throws Exception {
1278     ClientTlsPolicy expectedResponse =
1279         ClientTlsPolicy.newBuilder()
1280             .setName(
1281                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1282             .setDescription("description-1724546052")
1283             .setCreateTime(Timestamp.newBuilder().build())
1284             .setUpdateTime(Timestamp.newBuilder().build())
1285             .putAllLabels(new HashMap<String, String>())
1286             .setSni("sni114030")
1287             .setClientCertificate(CertificateProvider.newBuilder().build())
1288             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1289             .build();
1290     mockService.addResponse(expectedResponse);
1291 
1292     String name =
1293         "projects/project-6614/locations/location-6614/clientTlsPolicies/clientTlsPolicie-6614";
1294 
1295     ClientTlsPolicy actualResponse = client.getClientTlsPolicy(name);
1296     Assert.assertEquals(expectedResponse, actualResponse);
1297 
1298     List<String> actualRequests = mockService.getRequestPaths();
1299     Assert.assertEquals(1, actualRequests.size());
1300 
1301     String apiClientHeaderKey =
1302         mockService
1303             .getRequestHeaders()
1304             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1305             .iterator()
1306             .next();
1307     Assert.assertTrue(
1308         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1309             .matcher(apiClientHeaderKey)
1310             .matches());
1311   }
1312 
1313   @Test
getClientTlsPolicyExceptionTest2()1314   public void getClientTlsPolicyExceptionTest2() throws Exception {
1315     ApiException exception =
1316         ApiExceptionFactory.createException(
1317             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1318     mockService.addException(exception);
1319 
1320     try {
1321       String name =
1322           "projects/project-6614/locations/location-6614/clientTlsPolicies/clientTlsPolicie-6614";
1323       client.getClientTlsPolicy(name);
1324       Assert.fail("No exception raised");
1325     } catch (InvalidArgumentException e) {
1326       // Expected exception.
1327     }
1328   }
1329 
1330   @Test
createClientTlsPolicyTest()1331   public void createClientTlsPolicyTest() throws Exception {
1332     ClientTlsPolicy expectedResponse =
1333         ClientTlsPolicy.newBuilder()
1334             .setName(
1335                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1336             .setDescription("description-1724546052")
1337             .setCreateTime(Timestamp.newBuilder().build())
1338             .setUpdateTime(Timestamp.newBuilder().build())
1339             .putAllLabels(new HashMap<String, String>())
1340             .setSni("sni114030")
1341             .setClientCertificate(CertificateProvider.newBuilder().build())
1342             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1343             .build();
1344     Operation resultOperation =
1345         Operation.newBuilder()
1346             .setName("createClientTlsPolicyTest")
1347             .setDone(true)
1348             .setResponse(Any.pack(expectedResponse))
1349             .build();
1350     mockService.addResponse(resultOperation);
1351 
1352     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1353     ClientTlsPolicy clientTlsPolicy = ClientTlsPolicy.newBuilder().build();
1354     String clientTlsPolicyId = "clientTlsPolicyId-188933315";
1355 
1356     ClientTlsPolicy actualResponse =
1357         client.createClientTlsPolicyAsync(parent, clientTlsPolicy, clientTlsPolicyId).get();
1358     Assert.assertEquals(expectedResponse, actualResponse);
1359 
1360     List<String> actualRequests = mockService.getRequestPaths();
1361     Assert.assertEquals(1, actualRequests.size());
1362 
1363     String apiClientHeaderKey =
1364         mockService
1365             .getRequestHeaders()
1366             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1367             .iterator()
1368             .next();
1369     Assert.assertTrue(
1370         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1371             .matcher(apiClientHeaderKey)
1372             .matches());
1373   }
1374 
1375   @Test
createClientTlsPolicyExceptionTest()1376   public void createClientTlsPolicyExceptionTest() throws Exception {
1377     ApiException exception =
1378         ApiExceptionFactory.createException(
1379             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1380     mockService.addException(exception);
1381 
1382     try {
1383       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1384       ClientTlsPolicy clientTlsPolicy = ClientTlsPolicy.newBuilder().build();
1385       String clientTlsPolicyId = "clientTlsPolicyId-188933315";
1386       client.createClientTlsPolicyAsync(parent, clientTlsPolicy, clientTlsPolicyId).get();
1387       Assert.fail("No exception raised");
1388     } catch (ExecutionException e) {
1389     }
1390   }
1391 
1392   @Test
createClientTlsPolicyTest2()1393   public void createClientTlsPolicyTest2() throws Exception {
1394     ClientTlsPolicy expectedResponse =
1395         ClientTlsPolicy.newBuilder()
1396             .setName(
1397                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1398             .setDescription("description-1724546052")
1399             .setCreateTime(Timestamp.newBuilder().build())
1400             .setUpdateTime(Timestamp.newBuilder().build())
1401             .putAllLabels(new HashMap<String, String>())
1402             .setSni("sni114030")
1403             .setClientCertificate(CertificateProvider.newBuilder().build())
1404             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1405             .build();
1406     Operation resultOperation =
1407         Operation.newBuilder()
1408             .setName("createClientTlsPolicyTest")
1409             .setDone(true)
1410             .setResponse(Any.pack(expectedResponse))
1411             .build();
1412     mockService.addResponse(resultOperation);
1413 
1414     String parent = "projects/project-5833/locations/location-5833";
1415     ClientTlsPolicy clientTlsPolicy = ClientTlsPolicy.newBuilder().build();
1416     String clientTlsPolicyId = "clientTlsPolicyId-188933315";
1417 
1418     ClientTlsPolicy actualResponse =
1419         client.createClientTlsPolicyAsync(parent, clientTlsPolicy, clientTlsPolicyId).get();
1420     Assert.assertEquals(expectedResponse, actualResponse);
1421 
1422     List<String> actualRequests = mockService.getRequestPaths();
1423     Assert.assertEquals(1, actualRequests.size());
1424 
1425     String apiClientHeaderKey =
1426         mockService
1427             .getRequestHeaders()
1428             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1429             .iterator()
1430             .next();
1431     Assert.assertTrue(
1432         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1433             .matcher(apiClientHeaderKey)
1434             .matches());
1435   }
1436 
1437   @Test
createClientTlsPolicyExceptionTest2()1438   public void createClientTlsPolicyExceptionTest2() throws Exception {
1439     ApiException exception =
1440         ApiExceptionFactory.createException(
1441             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1442     mockService.addException(exception);
1443 
1444     try {
1445       String parent = "projects/project-5833/locations/location-5833";
1446       ClientTlsPolicy clientTlsPolicy = ClientTlsPolicy.newBuilder().build();
1447       String clientTlsPolicyId = "clientTlsPolicyId-188933315";
1448       client.createClientTlsPolicyAsync(parent, clientTlsPolicy, clientTlsPolicyId).get();
1449       Assert.fail("No exception raised");
1450     } catch (ExecutionException e) {
1451     }
1452   }
1453 
1454   @Test
updateClientTlsPolicyTest()1455   public void updateClientTlsPolicyTest() throws Exception {
1456     ClientTlsPolicy expectedResponse =
1457         ClientTlsPolicy.newBuilder()
1458             .setName(
1459                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1460             .setDescription("description-1724546052")
1461             .setCreateTime(Timestamp.newBuilder().build())
1462             .setUpdateTime(Timestamp.newBuilder().build())
1463             .putAllLabels(new HashMap<String, String>())
1464             .setSni("sni114030")
1465             .setClientCertificate(CertificateProvider.newBuilder().build())
1466             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1467             .build();
1468     Operation resultOperation =
1469         Operation.newBuilder()
1470             .setName("updateClientTlsPolicyTest")
1471             .setDone(true)
1472             .setResponse(Any.pack(expectedResponse))
1473             .build();
1474     mockService.addResponse(resultOperation);
1475 
1476     ClientTlsPolicy clientTlsPolicy =
1477         ClientTlsPolicy.newBuilder()
1478             .setName(
1479                 ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]").toString())
1480             .setDescription("description-1724546052")
1481             .setCreateTime(Timestamp.newBuilder().build())
1482             .setUpdateTime(Timestamp.newBuilder().build())
1483             .putAllLabels(new HashMap<String, String>())
1484             .setSni("sni114030")
1485             .setClientCertificate(CertificateProvider.newBuilder().build())
1486             .addAllServerValidationCa(new ArrayList<ValidationCA>())
1487             .build();
1488     FieldMask updateMask = FieldMask.newBuilder().build();
1489 
1490     ClientTlsPolicy actualResponse =
1491         client.updateClientTlsPolicyAsync(clientTlsPolicy, updateMask).get();
1492     Assert.assertEquals(expectedResponse, actualResponse);
1493 
1494     List<String> actualRequests = mockService.getRequestPaths();
1495     Assert.assertEquals(1, actualRequests.size());
1496 
1497     String apiClientHeaderKey =
1498         mockService
1499             .getRequestHeaders()
1500             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1501             .iterator()
1502             .next();
1503     Assert.assertTrue(
1504         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1505             .matcher(apiClientHeaderKey)
1506             .matches());
1507   }
1508 
1509   @Test
updateClientTlsPolicyExceptionTest()1510   public void updateClientTlsPolicyExceptionTest() throws Exception {
1511     ApiException exception =
1512         ApiExceptionFactory.createException(
1513             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1514     mockService.addException(exception);
1515 
1516     try {
1517       ClientTlsPolicy clientTlsPolicy =
1518           ClientTlsPolicy.newBuilder()
1519               .setName(
1520                   ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]")
1521                       .toString())
1522               .setDescription("description-1724546052")
1523               .setCreateTime(Timestamp.newBuilder().build())
1524               .setUpdateTime(Timestamp.newBuilder().build())
1525               .putAllLabels(new HashMap<String, String>())
1526               .setSni("sni114030")
1527               .setClientCertificate(CertificateProvider.newBuilder().build())
1528               .addAllServerValidationCa(new ArrayList<ValidationCA>())
1529               .build();
1530       FieldMask updateMask = FieldMask.newBuilder().build();
1531       client.updateClientTlsPolicyAsync(clientTlsPolicy, updateMask).get();
1532       Assert.fail("No exception raised");
1533     } catch (ExecutionException e) {
1534     }
1535   }
1536 
1537   @Test
deleteClientTlsPolicyTest()1538   public void deleteClientTlsPolicyTest() throws Exception {
1539     Empty expectedResponse = Empty.newBuilder().build();
1540     Operation resultOperation =
1541         Operation.newBuilder()
1542             .setName("deleteClientTlsPolicyTest")
1543             .setDone(true)
1544             .setResponse(Any.pack(expectedResponse))
1545             .build();
1546     mockService.addResponse(resultOperation);
1547 
1548     ClientTlsPolicyName name =
1549         ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]");
1550 
1551     client.deleteClientTlsPolicyAsync(name).get();
1552 
1553     List<String> actualRequests = mockService.getRequestPaths();
1554     Assert.assertEquals(1, actualRequests.size());
1555 
1556     String apiClientHeaderKey =
1557         mockService
1558             .getRequestHeaders()
1559             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1560             .iterator()
1561             .next();
1562     Assert.assertTrue(
1563         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1564             .matcher(apiClientHeaderKey)
1565             .matches());
1566   }
1567 
1568   @Test
deleteClientTlsPolicyExceptionTest()1569   public void deleteClientTlsPolicyExceptionTest() throws Exception {
1570     ApiException exception =
1571         ApiExceptionFactory.createException(
1572             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1573     mockService.addException(exception);
1574 
1575     try {
1576       ClientTlsPolicyName name =
1577           ClientTlsPolicyName.of("[PROJECT]", "[LOCATION]", "[CLIENT_TLS_POLICY]");
1578       client.deleteClientTlsPolicyAsync(name).get();
1579       Assert.fail("No exception raised");
1580     } catch (ExecutionException e) {
1581     }
1582   }
1583 
1584   @Test
deleteClientTlsPolicyTest2()1585   public void deleteClientTlsPolicyTest2() throws Exception {
1586     Empty expectedResponse = Empty.newBuilder().build();
1587     Operation resultOperation =
1588         Operation.newBuilder()
1589             .setName("deleteClientTlsPolicyTest")
1590             .setDone(true)
1591             .setResponse(Any.pack(expectedResponse))
1592             .build();
1593     mockService.addResponse(resultOperation);
1594 
1595     String name =
1596         "projects/project-6614/locations/location-6614/clientTlsPolicies/clientTlsPolicie-6614";
1597 
1598     client.deleteClientTlsPolicyAsync(name).get();
1599 
1600     List<String> actualRequests = mockService.getRequestPaths();
1601     Assert.assertEquals(1, actualRequests.size());
1602 
1603     String apiClientHeaderKey =
1604         mockService
1605             .getRequestHeaders()
1606             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1607             .iterator()
1608             .next();
1609     Assert.assertTrue(
1610         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1611             .matcher(apiClientHeaderKey)
1612             .matches());
1613   }
1614 
1615   @Test
deleteClientTlsPolicyExceptionTest2()1616   public void deleteClientTlsPolicyExceptionTest2() throws Exception {
1617     ApiException exception =
1618         ApiExceptionFactory.createException(
1619             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1620     mockService.addException(exception);
1621 
1622     try {
1623       String name =
1624           "projects/project-6614/locations/location-6614/clientTlsPolicies/clientTlsPolicie-6614";
1625       client.deleteClientTlsPolicyAsync(name).get();
1626       Assert.fail("No exception raised");
1627     } catch (ExecutionException e) {
1628     }
1629   }
1630 
1631   @Test
listLocationsTest()1632   public void listLocationsTest() throws Exception {
1633     Location responsesElement = Location.newBuilder().build();
1634     ListLocationsResponse expectedResponse =
1635         ListLocationsResponse.newBuilder()
1636             .setNextPageToken("")
1637             .addAllLocations(Arrays.asList(responsesElement))
1638             .build();
1639     mockService.addResponse(expectedResponse);
1640 
1641     ListLocationsRequest request =
1642         ListLocationsRequest.newBuilder()
1643             .setName("projects/project-3664")
1644             .setFilter("filter-1274492040")
1645             .setPageSize(883849137)
1646             .setPageToken("pageToken873572522")
1647             .build();
1648 
1649     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1650 
1651     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1652 
1653     Assert.assertEquals(1, resources.size());
1654     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1655 
1656     List<String> actualRequests = mockService.getRequestPaths();
1657     Assert.assertEquals(1, actualRequests.size());
1658 
1659     String apiClientHeaderKey =
1660         mockService
1661             .getRequestHeaders()
1662             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1663             .iterator()
1664             .next();
1665     Assert.assertTrue(
1666         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1667             .matcher(apiClientHeaderKey)
1668             .matches());
1669   }
1670 
1671   @Test
listLocationsExceptionTest()1672   public void listLocationsExceptionTest() throws Exception {
1673     ApiException exception =
1674         ApiExceptionFactory.createException(
1675             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1676     mockService.addException(exception);
1677 
1678     try {
1679       ListLocationsRequest request =
1680           ListLocationsRequest.newBuilder()
1681               .setName("projects/project-3664")
1682               .setFilter("filter-1274492040")
1683               .setPageSize(883849137)
1684               .setPageToken("pageToken873572522")
1685               .build();
1686       client.listLocations(request);
1687       Assert.fail("No exception raised");
1688     } catch (InvalidArgumentException e) {
1689       // Expected exception.
1690     }
1691   }
1692 
1693   @Test
getLocationTest()1694   public void getLocationTest() throws Exception {
1695     Location expectedResponse =
1696         Location.newBuilder()
1697             .setName("name3373707")
1698             .setLocationId("locationId1541836720")
1699             .setDisplayName("displayName1714148973")
1700             .putAllLabels(new HashMap<String, String>())
1701             .setMetadata(Any.newBuilder().build())
1702             .build();
1703     mockService.addResponse(expectedResponse);
1704 
1705     GetLocationRequest request =
1706         GetLocationRequest.newBuilder()
1707             .setName("projects/project-9062/locations/location-9062")
1708             .build();
1709 
1710     Location actualResponse = client.getLocation(request);
1711     Assert.assertEquals(expectedResponse, actualResponse);
1712 
1713     List<String> actualRequests = mockService.getRequestPaths();
1714     Assert.assertEquals(1, actualRequests.size());
1715 
1716     String apiClientHeaderKey =
1717         mockService
1718             .getRequestHeaders()
1719             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1720             .iterator()
1721             .next();
1722     Assert.assertTrue(
1723         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1724             .matcher(apiClientHeaderKey)
1725             .matches());
1726   }
1727 
1728   @Test
getLocationExceptionTest()1729   public void getLocationExceptionTest() throws Exception {
1730     ApiException exception =
1731         ApiExceptionFactory.createException(
1732             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1733     mockService.addException(exception);
1734 
1735     try {
1736       GetLocationRequest request =
1737           GetLocationRequest.newBuilder()
1738               .setName("projects/project-9062/locations/location-9062")
1739               .build();
1740       client.getLocation(request);
1741       Assert.fail("No exception raised");
1742     } catch (InvalidArgumentException e) {
1743       // Expected exception.
1744     }
1745   }
1746 
1747   @Test
setIamPolicyTest()1748   public void setIamPolicyTest() throws Exception {
1749     Policy expectedResponse =
1750         Policy.newBuilder()
1751             .setVersion(351608024)
1752             .addAllBindings(new ArrayList<Binding>())
1753             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1754             .setEtag(ByteString.EMPTY)
1755             .build();
1756     mockService.addResponse(expectedResponse);
1757 
1758     SetIamPolicyRequest request =
1759         SetIamPolicyRequest.newBuilder()
1760             .setResource(
1761                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1762                     .toString())
1763             .setPolicy(Policy.newBuilder().build())
1764             .setUpdateMask(FieldMask.newBuilder().build())
1765             .build();
1766 
1767     Policy actualResponse = client.setIamPolicy(request);
1768     Assert.assertEquals(expectedResponse, actualResponse);
1769 
1770     List<String> actualRequests = mockService.getRequestPaths();
1771     Assert.assertEquals(1, actualRequests.size());
1772 
1773     String apiClientHeaderKey =
1774         mockService
1775             .getRequestHeaders()
1776             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1777             .iterator()
1778             .next();
1779     Assert.assertTrue(
1780         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1781             .matcher(apiClientHeaderKey)
1782             .matches());
1783   }
1784 
1785   @Test
setIamPolicyExceptionTest()1786   public void setIamPolicyExceptionTest() throws Exception {
1787     ApiException exception =
1788         ApiExceptionFactory.createException(
1789             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1790     mockService.addException(exception);
1791 
1792     try {
1793       SetIamPolicyRequest request =
1794           SetIamPolicyRequest.newBuilder()
1795               .setResource(
1796                   AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1797                       .toString())
1798               .setPolicy(Policy.newBuilder().build())
1799               .setUpdateMask(FieldMask.newBuilder().build())
1800               .build();
1801       client.setIamPolicy(request);
1802       Assert.fail("No exception raised");
1803     } catch (InvalidArgumentException e) {
1804       // Expected exception.
1805     }
1806   }
1807 
1808   @Test
getIamPolicyTest()1809   public void getIamPolicyTest() throws Exception {
1810     Policy expectedResponse =
1811         Policy.newBuilder()
1812             .setVersion(351608024)
1813             .addAllBindings(new ArrayList<Binding>())
1814             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1815             .setEtag(ByteString.EMPTY)
1816             .build();
1817     mockService.addResponse(expectedResponse);
1818 
1819     GetIamPolicyRequest request =
1820         GetIamPolicyRequest.newBuilder()
1821             .setResource(
1822                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1823                     .toString())
1824             .setOptions(GetPolicyOptions.newBuilder().build())
1825             .build();
1826 
1827     Policy actualResponse = client.getIamPolicy(request);
1828     Assert.assertEquals(expectedResponse, actualResponse);
1829 
1830     List<String> actualRequests = mockService.getRequestPaths();
1831     Assert.assertEquals(1, actualRequests.size());
1832 
1833     String apiClientHeaderKey =
1834         mockService
1835             .getRequestHeaders()
1836             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1837             .iterator()
1838             .next();
1839     Assert.assertTrue(
1840         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1841             .matcher(apiClientHeaderKey)
1842             .matches());
1843   }
1844 
1845   @Test
getIamPolicyExceptionTest()1846   public void getIamPolicyExceptionTest() throws Exception {
1847     ApiException exception =
1848         ApiExceptionFactory.createException(
1849             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1850     mockService.addException(exception);
1851 
1852     try {
1853       GetIamPolicyRequest request =
1854           GetIamPolicyRequest.newBuilder()
1855               .setResource(
1856                   AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1857                       .toString())
1858               .setOptions(GetPolicyOptions.newBuilder().build())
1859               .build();
1860       client.getIamPolicy(request);
1861       Assert.fail("No exception raised");
1862     } catch (InvalidArgumentException e) {
1863       // Expected exception.
1864     }
1865   }
1866 
1867   @Test
testIamPermissionsTest()1868   public void testIamPermissionsTest() throws Exception {
1869     TestIamPermissionsResponse expectedResponse =
1870         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1871     mockService.addResponse(expectedResponse);
1872 
1873     TestIamPermissionsRequest request =
1874         TestIamPermissionsRequest.newBuilder()
1875             .setResource(
1876                 AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1877                     .toString())
1878             .addAllPermissions(new ArrayList<String>())
1879             .build();
1880 
1881     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1882     Assert.assertEquals(expectedResponse, actualResponse);
1883 
1884     List<String> actualRequests = mockService.getRequestPaths();
1885     Assert.assertEquals(1, actualRequests.size());
1886 
1887     String apiClientHeaderKey =
1888         mockService
1889             .getRequestHeaders()
1890             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1891             .iterator()
1892             .next();
1893     Assert.assertTrue(
1894         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1895             .matcher(apiClientHeaderKey)
1896             .matches());
1897   }
1898 
1899   @Test
testIamPermissionsExceptionTest()1900   public void testIamPermissionsExceptionTest() throws Exception {
1901     ApiException exception =
1902         ApiExceptionFactory.createException(
1903             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1904     mockService.addException(exception);
1905 
1906     try {
1907       TestIamPermissionsRequest request =
1908           TestIamPermissionsRequest.newBuilder()
1909               .setResource(
1910                   AuthorizationPolicyName.of("[PROJECT]", "[LOCATION]", "[AUTHORIZATION_POLICY]")
1911                       .toString())
1912               .addAllPermissions(new ArrayList<String>())
1913               .build();
1914       client.testIamPermissions(request);
1915       Assert.fail("No exception raised");
1916     } catch (InvalidArgumentException e) {
1917       // Expected exception.
1918     }
1919   }
1920 }
1921