• 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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.SubnetworksClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.SubnetworksClient.ListPagedResponse;
21 import static com.google.cloud.compute.v1.SubnetworksClient.ListUsablePagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
25 import com.google.api.gax.httpjson.testing.MockHttpService;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.ApiException;
28 import com.google.api.gax.rpc.ApiExceptionFactory;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.api.gax.rpc.testing.FakeStatusCode;
32 import com.google.cloud.compute.v1.Operation.Status;
33 import com.google.cloud.compute.v1.stub.HttpJsonSubnetworksStub;
34 import com.google.common.collect.Lists;
35 import java.io.IOException;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.Collections;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.concurrent.ExecutionException;
42 import javax.annotation.Generated;
43 import org.junit.After;
44 import org.junit.AfterClass;
45 import org.junit.Assert;
46 import org.junit.Before;
47 import org.junit.BeforeClass;
48 import org.junit.Test;
49 
50 @Generated("by gapic-generator-java")
51 public class SubnetworksClientTest {
52   private static MockHttpService mockService;
53   private static SubnetworksClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonSubnetworksStub.getMethodDescriptors(),
60             SubnetworksSettings.getDefaultEndpoint());
61     SubnetworksSettings settings =
62         SubnetworksSettings.newBuilder()
63             .setTransportChannelProvider(
64                 SubnetworksSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = SubnetworksClient.create(settings);
70   }
71 
72   @AfterClass
stopServer()73   public static void stopServer() {
74     client.close();
75   }
76 
77   @Before
setUp()78   public void setUp() {}
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     mockService.reset();
83   }
84 
85   @Test
aggregatedListTest()86   public void aggregatedListTest() throws Exception {
87     SubnetworksScopedList responsesElement = SubnetworksScopedList.newBuilder().build();
88     SubnetworkAggregatedList expectedResponse =
89         SubnetworkAggregatedList.newBuilder()
90             .setNextPageToken("")
91             .putAllItems(Collections.singletonMap("items", responsesElement))
92             .build();
93     mockService.addResponse(expectedResponse);
94 
95     String project = "project-6911";
96 
97     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
98 
99     List<Map.Entry<String, SubnetworksScopedList>> resources =
100         Lists.newArrayList(pagedListResponse.iterateAll());
101 
102     Assert.assertEquals(1, resources.size());
103     Assert.assertEquals(
104         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
105 
106     List<String> actualRequests = mockService.getRequestPaths();
107     Assert.assertEquals(1, actualRequests.size());
108 
109     String apiClientHeaderKey =
110         mockService
111             .getRequestHeaders()
112             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
113             .iterator()
114             .next();
115     Assert.assertTrue(
116         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
117             .matcher(apiClientHeaderKey)
118             .matches());
119   }
120 
121   @Test
aggregatedListExceptionTest()122   public void aggregatedListExceptionTest() throws Exception {
123     ApiException exception =
124         ApiExceptionFactory.createException(
125             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
126     mockService.addException(exception);
127 
128     try {
129       String project = "project-6911";
130       client.aggregatedList(project);
131       Assert.fail("No exception raised");
132     } catch (InvalidArgumentException e) {
133       // Expected exception.
134     }
135   }
136 
137   @Test
deleteTest()138   public void deleteTest() throws Exception {
139     Operation expectedResponse =
140         Operation.newBuilder()
141             .setClientOperationId("clientOperationId-1230366697")
142             .setCreationTimestamp("creationTimestamp-370203401")
143             .setDescription("description-1724546052")
144             .setEndTime("endTime-1607243192")
145             .setError(Error.newBuilder().build())
146             .setHttpErrorMessage("httpErrorMessage1577303431")
147             .setHttpErrorStatusCode(0)
148             .setId(3355)
149             .setInsertTime("insertTime966165798")
150             .setKind("kind3292052")
151             .setName("name3373707")
152             .setOperationGroupId("operationGroupId1716161683")
153             .setOperationType("operationType91999553")
154             .setProgress(-1001078227)
155             .setRegion("region-934795532")
156             .setSelfLink("selfLink1191800166")
157             .setStartTime("startTime-2129294769")
158             .setStatus(Status.DONE)
159             .setStatusMessage("statusMessage-958704715")
160             .setTargetId(-815576439)
161             .setTargetLink("targetLink486368555")
162             .setUser("user3599307")
163             .addAllWarnings(new ArrayList<Warnings>())
164             .setZone("zone3744684")
165             .build();
166     mockService.addResponse(expectedResponse);
167 
168     String project = "project-6911";
169     String region = "region-9622";
170     String subnetwork = "subnetwork-596";
171 
172     Operation actualResponse = client.deleteAsync(project, region, subnetwork).get();
173     Assert.assertEquals(expectedResponse, actualResponse);
174 
175     List<String> actualRequests = mockService.getRequestPaths();
176     Assert.assertEquals(1, actualRequests.size());
177 
178     String apiClientHeaderKey =
179         mockService
180             .getRequestHeaders()
181             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
182             .iterator()
183             .next();
184     Assert.assertTrue(
185         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
186             .matcher(apiClientHeaderKey)
187             .matches());
188   }
189 
190   @Test
deleteExceptionTest()191   public void deleteExceptionTest() throws Exception {
192     ApiException exception =
193         ApiExceptionFactory.createException(
194             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
195     mockService.addException(exception);
196 
197     try {
198       String project = "project-6911";
199       String region = "region-9622";
200       String subnetwork = "subnetwork-596";
201       client.deleteAsync(project, region, subnetwork).get();
202       Assert.fail("No exception raised");
203     } catch (ExecutionException e) {
204     }
205   }
206 
207   @Test
expandIpCidrRangeTest()208   public void expandIpCidrRangeTest() throws Exception {
209     Operation expectedResponse =
210         Operation.newBuilder()
211             .setClientOperationId("clientOperationId-1230366697")
212             .setCreationTimestamp("creationTimestamp-370203401")
213             .setDescription("description-1724546052")
214             .setEndTime("endTime-1607243192")
215             .setError(Error.newBuilder().build())
216             .setHttpErrorMessage("httpErrorMessage1577303431")
217             .setHttpErrorStatusCode(0)
218             .setId(3355)
219             .setInsertTime("insertTime966165798")
220             .setKind("kind3292052")
221             .setName("name3373707")
222             .setOperationGroupId("operationGroupId1716161683")
223             .setOperationType("operationType91999553")
224             .setProgress(-1001078227)
225             .setRegion("region-934795532")
226             .setSelfLink("selfLink1191800166")
227             .setStartTime("startTime-2129294769")
228             .setStatus(Status.DONE)
229             .setStatusMessage("statusMessage-958704715")
230             .setTargetId(-815576439)
231             .setTargetLink("targetLink486368555")
232             .setUser("user3599307")
233             .addAllWarnings(new ArrayList<Warnings>())
234             .setZone("zone3744684")
235             .build();
236     mockService.addResponse(expectedResponse);
237 
238     String project = "project-6911";
239     String region = "region-9622";
240     String subnetwork = "subnetwork-596";
241     SubnetworksExpandIpCidrRangeRequest subnetworksExpandIpCidrRangeRequestResource =
242         SubnetworksExpandIpCidrRangeRequest.newBuilder().build();
243 
244     Operation actualResponse =
245         client
246             .expandIpCidrRangeAsync(
247                 project, region, subnetwork, subnetworksExpandIpCidrRangeRequestResource)
248             .get();
249     Assert.assertEquals(expectedResponse, actualResponse);
250 
251     List<String> actualRequests = mockService.getRequestPaths();
252     Assert.assertEquals(1, actualRequests.size());
253 
254     String apiClientHeaderKey =
255         mockService
256             .getRequestHeaders()
257             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
258             .iterator()
259             .next();
260     Assert.assertTrue(
261         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
262             .matcher(apiClientHeaderKey)
263             .matches());
264   }
265 
266   @Test
expandIpCidrRangeExceptionTest()267   public void expandIpCidrRangeExceptionTest() throws Exception {
268     ApiException exception =
269         ApiExceptionFactory.createException(
270             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
271     mockService.addException(exception);
272 
273     try {
274       String project = "project-6911";
275       String region = "region-9622";
276       String subnetwork = "subnetwork-596";
277       SubnetworksExpandIpCidrRangeRequest subnetworksExpandIpCidrRangeRequestResource =
278           SubnetworksExpandIpCidrRangeRequest.newBuilder().build();
279       client
280           .expandIpCidrRangeAsync(
281               project, region, subnetwork, subnetworksExpandIpCidrRangeRequestResource)
282           .get();
283       Assert.fail("No exception raised");
284     } catch (ExecutionException e) {
285     }
286   }
287 
288   @Test
getTest()289   public void getTest() throws Exception {
290     Subnetwork expectedResponse =
291         Subnetwork.newBuilder()
292             .setCreationTimestamp("creationTimestamp-370203401")
293             .setDescription("description-1724546052")
294             .setEnableFlowLogs(true)
295             .setExternalIpv6Prefix("externalIpv6Prefix-219545212")
296             .setFingerprint("fingerprint-1375934236")
297             .setGatewayAddress("gatewayAddress1860901136")
298             .setId(3355)
299             .setInternalIpv6Prefix("internalIpv6Prefix-561062410")
300             .setIpCidrRange("ipCidrRange-866375486")
301             .setIpv6AccessType("ipv6AccessType606780421")
302             .setIpv6CidrRange("ipv6CidrRange885760002")
303             .setKind("kind3292052")
304             .setLogConfig(SubnetworkLogConfig.newBuilder().build())
305             .setName("name3373707")
306             .setNetwork("network1843485230")
307             .setPrivateIpGoogleAccess(true)
308             .setPrivateIpv6GoogleAccess("privateIpv6GoogleAccess-1729571801")
309             .setPurpose("purpose-220463842")
310             .setRegion("region-934795532")
311             .setRole("role3506294")
312             .addAllSecondaryIpRanges(new ArrayList<SubnetworkSecondaryRange>())
313             .setSelfLink("selfLink1191800166")
314             .setStackType("stackType1727939042")
315             .setState("state109757585")
316             .build();
317     mockService.addResponse(expectedResponse);
318 
319     String project = "project-6911";
320     String region = "region-9622";
321     String subnetwork = "subnetwork-596";
322 
323     Subnetwork actualResponse = client.get(project, region, subnetwork);
324     Assert.assertEquals(expectedResponse, actualResponse);
325 
326     List<String> actualRequests = mockService.getRequestPaths();
327     Assert.assertEquals(1, actualRequests.size());
328 
329     String apiClientHeaderKey =
330         mockService
331             .getRequestHeaders()
332             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
333             .iterator()
334             .next();
335     Assert.assertTrue(
336         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
337             .matcher(apiClientHeaderKey)
338             .matches());
339   }
340 
341   @Test
getExceptionTest()342   public void getExceptionTest() throws Exception {
343     ApiException exception =
344         ApiExceptionFactory.createException(
345             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
346     mockService.addException(exception);
347 
348     try {
349       String project = "project-6911";
350       String region = "region-9622";
351       String subnetwork = "subnetwork-596";
352       client.get(project, region, subnetwork);
353       Assert.fail("No exception raised");
354     } catch (InvalidArgumentException e) {
355       // Expected exception.
356     }
357   }
358 
359   @Test
getIamPolicyTest()360   public void getIamPolicyTest() throws Exception {
361     Policy expectedResponse =
362         Policy.newBuilder()
363             .addAllAuditConfigs(new ArrayList<AuditConfig>())
364             .addAllBindings(new ArrayList<Binding>())
365             .setEtag("etag3123477")
366             .setIamOwned(true)
367             .addAllRules(new ArrayList<Rule>())
368             .setVersion(351608024)
369             .build();
370     mockService.addResponse(expectedResponse);
371 
372     String project = "project-6911";
373     String region = "region-9622";
374     String resource = "resource-756";
375 
376     Policy actualResponse = client.getIamPolicy(project, region, resource);
377     Assert.assertEquals(expectedResponse, actualResponse);
378 
379     List<String> actualRequests = mockService.getRequestPaths();
380     Assert.assertEquals(1, actualRequests.size());
381 
382     String apiClientHeaderKey =
383         mockService
384             .getRequestHeaders()
385             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
386             .iterator()
387             .next();
388     Assert.assertTrue(
389         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
390             .matcher(apiClientHeaderKey)
391             .matches());
392   }
393 
394   @Test
getIamPolicyExceptionTest()395   public void getIamPolicyExceptionTest() throws Exception {
396     ApiException exception =
397         ApiExceptionFactory.createException(
398             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
399     mockService.addException(exception);
400 
401     try {
402       String project = "project-6911";
403       String region = "region-9622";
404       String resource = "resource-756";
405       client.getIamPolicy(project, region, resource);
406       Assert.fail("No exception raised");
407     } catch (InvalidArgumentException e) {
408       // Expected exception.
409     }
410   }
411 
412   @Test
insertTest()413   public void insertTest() throws Exception {
414     Operation expectedResponse =
415         Operation.newBuilder()
416             .setClientOperationId("clientOperationId-1230366697")
417             .setCreationTimestamp("creationTimestamp-370203401")
418             .setDescription("description-1724546052")
419             .setEndTime("endTime-1607243192")
420             .setError(Error.newBuilder().build())
421             .setHttpErrorMessage("httpErrorMessage1577303431")
422             .setHttpErrorStatusCode(0)
423             .setId(3355)
424             .setInsertTime("insertTime966165798")
425             .setKind("kind3292052")
426             .setName("name3373707")
427             .setOperationGroupId("operationGroupId1716161683")
428             .setOperationType("operationType91999553")
429             .setProgress(-1001078227)
430             .setRegion("region-934795532")
431             .setSelfLink("selfLink1191800166")
432             .setStartTime("startTime-2129294769")
433             .setStatus(Status.DONE)
434             .setStatusMessage("statusMessage-958704715")
435             .setTargetId(-815576439)
436             .setTargetLink("targetLink486368555")
437             .setUser("user3599307")
438             .addAllWarnings(new ArrayList<Warnings>())
439             .setZone("zone3744684")
440             .build();
441     mockService.addResponse(expectedResponse);
442 
443     String project = "project-6911";
444     String region = "region-9622";
445     Subnetwork subnetworkResource = Subnetwork.newBuilder().build();
446 
447     Operation actualResponse = client.insertAsync(project, region, subnetworkResource).get();
448     Assert.assertEquals(expectedResponse, actualResponse);
449 
450     List<String> actualRequests = mockService.getRequestPaths();
451     Assert.assertEquals(1, actualRequests.size());
452 
453     String apiClientHeaderKey =
454         mockService
455             .getRequestHeaders()
456             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
457             .iterator()
458             .next();
459     Assert.assertTrue(
460         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
461             .matcher(apiClientHeaderKey)
462             .matches());
463   }
464 
465   @Test
insertExceptionTest()466   public void insertExceptionTest() throws Exception {
467     ApiException exception =
468         ApiExceptionFactory.createException(
469             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
470     mockService.addException(exception);
471 
472     try {
473       String project = "project-6911";
474       String region = "region-9622";
475       Subnetwork subnetworkResource = Subnetwork.newBuilder().build();
476       client.insertAsync(project, region, subnetworkResource).get();
477       Assert.fail("No exception raised");
478     } catch (ExecutionException e) {
479     }
480   }
481 
482   @Test
listTest()483   public void listTest() throws Exception {
484     Subnetwork responsesElement = Subnetwork.newBuilder().build();
485     SubnetworkList expectedResponse =
486         SubnetworkList.newBuilder()
487             .setNextPageToken("")
488             .addAllItems(Arrays.asList(responsesElement))
489             .build();
490     mockService.addResponse(expectedResponse);
491 
492     String project = "project-6911";
493     String region = "region-9622";
494 
495     ListPagedResponse pagedListResponse = client.list(project, region);
496 
497     List<Subnetwork> resources = Lists.newArrayList(pagedListResponse.iterateAll());
498 
499     Assert.assertEquals(1, resources.size());
500     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
501 
502     List<String> actualRequests = mockService.getRequestPaths();
503     Assert.assertEquals(1, actualRequests.size());
504 
505     String apiClientHeaderKey =
506         mockService
507             .getRequestHeaders()
508             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
509             .iterator()
510             .next();
511     Assert.assertTrue(
512         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
513             .matcher(apiClientHeaderKey)
514             .matches());
515   }
516 
517   @Test
listExceptionTest()518   public void listExceptionTest() throws Exception {
519     ApiException exception =
520         ApiExceptionFactory.createException(
521             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
522     mockService.addException(exception);
523 
524     try {
525       String project = "project-6911";
526       String region = "region-9622";
527       client.list(project, region);
528       Assert.fail("No exception raised");
529     } catch (InvalidArgumentException e) {
530       // Expected exception.
531     }
532   }
533 
534   @Test
listUsableTest()535   public void listUsableTest() throws Exception {
536     UsableSubnetwork responsesElement = UsableSubnetwork.newBuilder().build();
537     UsableSubnetworksAggregatedList expectedResponse =
538         UsableSubnetworksAggregatedList.newBuilder()
539             .setNextPageToken("")
540             .addAllItems(Arrays.asList(responsesElement))
541             .build();
542     mockService.addResponse(expectedResponse);
543 
544     String project = "project-6911";
545 
546     ListUsablePagedResponse pagedListResponse = client.listUsable(project);
547 
548     List<UsableSubnetwork> resources = Lists.newArrayList(pagedListResponse.iterateAll());
549 
550     Assert.assertEquals(1, resources.size());
551     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
552 
553     List<String> actualRequests = mockService.getRequestPaths();
554     Assert.assertEquals(1, actualRequests.size());
555 
556     String apiClientHeaderKey =
557         mockService
558             .getRequestHeaders()
559             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
560             .iterator()
561             .next();
562     Assert.assertTrue(
563         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
564             .matcher(apiClientHeaderKey)
565             .matches());
566   }
567 
568   @Test
listUsableExceptionTest()569   public void listUsableExceptionTest() throws Exception {
570     ApiException exception =
571         ApiExceptionFactory.createException(
572             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
573     mockService.addException(exception);
574 
575     try {
576       String project = "project-6911";
577       client.listUsable(project);
578       Assert.fail("No exception raised");
579     } catch (InvalidArgumentException e) {
580       // Expected exception.
581     }
582   }
583 
584   @Test
patchTest()585   public void patchTest() throws Exception {
586     Operation expectedResponse =
587         Operation.newBuilder()
588             .setClientOperationId("clientOperationId-1230366697")
589             .setCreationTimestamp("creationTimestamp-370203401")
590             .setDescription("description-1724546052")
591             .setEndTime("endTime-1607243192")
592             .setError(Error.newBuilder().build())
593             .setHttpErrorMessage("httpErrorMessage1577303431")
594             .setHttpErrorStatusCode(0)
595             .setId(3355)
596             .setInsertTime("insertTime966165798")
597             .setKind("kind3292052")
598             .setName("name3373707")
599             .setOperationGroupId("operationGroupId1716161683")
600             .setOperationType("operationType91999553")
601             .setProgress(-1001078227)
602             .setRegion("region-934795532")
603             .setSelfLink("selfLink1191800166")
604             .setStartTime("startTime-2129294769")
605             .setStatus(Status.DONE)
606             .setStatusMessage("statusMessage-958704715")
607             .setTargetId(-815576439)
608             .setTargetLink("targetLink486368555")
609             .setUser("user3599307")
610             .addAllWarnings(new ArrayList<Warnings>())
611             .setZone("zone3744684")
612             .build();
613     mockService.addResponse(expectedResponse);
614 
615     String project = "project-6911";
616     String region = "region-9622";
617     String subnetwork = "subnetwork-596";
618     Subnetwork subnetworkResource = Subnetwork.newBuilder().build();
619 
620     Operation actualResponse =
621         client.patchAsync(project, region, subnetwork, subnetworkResource).get();
622     Assert.assertEquals(expectedResponse, actualResponse);
623 
624     List<String> actualRequests = mockService.getRequestPaths();
625     Assert.assertEquals(1, actualRequests.size());
626 
627     String apiClientHeaderKey =
628         mockService
629             .getRequestHeaders()
630             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
631             .iterator()
632             .next();
633     Assert.assertTrue(
634         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
635             .matcher(apiClientHeaderKey)
636             .matches());
637   }
638 
639   @Test
patchExceptionTest()640   public void patchExceptionTest() throws Exception {
641     ApiException exception =
642         ApiExceptionFactory.createException(
643             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
644     mockService.addException(exception);
645 
646     try {
647       String project = "project-6911";
648       String region = "region-9622";
649       String subnetwork = "subnetwork-596";
650       Subnetwork subnetworkResource = Subnetwork.newBuilder().build();
651       client.patchAsync(project, region, subnetwork, subnetworkResource).get();
652       Assert.fail("No exception raised");
653     } catch (ExecutionException e) {
654     }
655   }
656 
657   @Test
setIamPolicyTest()658   public void setIamPolicyTest() throws Exception {
659     Policy expectedResponse =
660         Policy.newBuilder()
661             .addAllAuditConfigs(new ArrayList<AuditConfig>())
662             .addAllBindings(new ArrayList<Binding>())
663             .setEtag("etag3123477")
664             .setIamOwned(true)
665             .addAllRules(new ArrayList<Rule>())
666             .setVersion(351608024)
667             .build();
668     mockService.addResponse(expectedResponse);
669 
670     String project = "project-6911";
671     String region = "region-9622";
672     String resource = "resource-756";
673     RegionSetPolicyRequest regionSetPolicyRequestResource =
674         RegionSetPolicyRequest.newBuilder().build();
675 
676     Policy actualResponse =
677         client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
678     Assert.assertEquals(expectedResponse, actualResponse);
679 
680     List<String> actualRequests = mockService.getRequestPaths();
681     Assert.assertEquals(1, actualRequests.size());
682 
683     String apiClientHeaderKey =
684         mockService
685             .getRequestHeaders()
686             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
687             .iterator()
688             .next();
689     Assert.assertTrue(
690         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
691             .matcher(apiClientHeaderKey)
692             .matches());
693   }
694 
695   @Test
setIamPolicyExceptionTest()696   public void setIamPolicyExceptionTest() throws Exception {
697     ApiException exception =
698         ApiExceptionFactory.createException(
699             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
700     mockService.addException(exception);
701 
702     try {
703       String project = "project-6911";
704       String region = "region-9622";
705       String resource = "resource-756";
706       RegionSetPolicyRequest regionSetPolicyRequestResource =
707           RegionSetPolicyRequest.newBuilder().build();
708       client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
709       Assert.fail("No exception raised");
710     } catch (InvalidArgumentException e) {
711       // Expected exception.
712     }
713   }
714 
715   @Test
setPrivateIpGoogleAccessTest()716   public void setPrivateIpGoogleAccessTest() throws Exception {
717     Operation expectedResponse =
718         Operation.newBuilder()
719             .setClientOperationId("clientOperationId-1230366697")
720             .setCreationTimestamp("creationTimestamp-370203401")
721             .setDescription("description-1724546052")
722             .setEndTime("endTime-1607243192")
723             .setError(Error.newBuilder().build())
724             .setHttpErrorMessage("httpErrorMessage1577303431")
725             .setHttpErrorStatusCode(0)
726             .setId(3355)
727             .setInsertTime("insertTime966165798")
728             .setKind("kind3292052")
729             .setName("name3373707")
730             .setOperationGroupId("operationGroupId1716161683")
731             .setOperationType("operationType91999553")
732             .setProgress(-1001078227)
733             .setRegion("region-934795532")
734             .setSelfLink("selfLink1191800166")
735             .setStartTime("startTime-2129294769")
736             .setStatus(Status.DONE)
737             .setStatusMessage("statusMessage-958704715")
738             .setTargetId(-815576439)
739             .setTargetLink("targetLink486368555")
740             .setUser("user3599307")
741             .addAllWarnings(new ArrayList<Warnings>())
742             .setZone("zone3744684")
743             .build();
744     mockService.addResponse(expectedResponse);
745 
746     String project = "project-6911";
747     String region = "region-9622";
748     String subnetwork = "subnetwork-596";
749     SubnetworksSetPrivateIpGoogleAccessRequest subnetworksSetPrivateIpGoogleAccessRequestResource =
750         SubnetworksSetPrivateIpGoogleAccessRequest.newBuilder().build();
751 
752     Operation actualResponse =
753         client
754             .setPrivateIpGoogleAccessAsync(
755                 project, region, subnetwork, subnetworksSetPrivateIpGoogleAccessRequestResource)
756             .get();
757     Assert.assertEquals(expectedResponse, actualResponse);
758 
759     List<String> actualRequests = mockService.getRequestPaths();
760     Assert.assertEquals(1, actualRequests.size());
761 
762     String apiClientHeaderKey =
763         mockService
764             .getRequestHeaders()
765             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
766             .iterator()
767             .next();
768     Assert.assertTrue(
769         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
770             .matcher(apiClientHeaderKey)
771             .matches());
772   }
773 
774   @Test
setPrivateIpGoogleAccessExceptionTest()775   public void setPrivateIpGoogleAccessExceptionTest() throws Exception {
776     ApiException exception =
777         ApiExceptionFactory.createException(
778             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
779     mockService.addException(exception);
780 
781     try {
782       String project = "project-6911";
783       String region = "region-9622";
784       String subnetwork = "subnetwork-596";
785       SubnetworksSetPrivateIpGoogleAccessRequest
786           subnetworksSetPrivateIpGoogleAccessRequestResource =
787               SubnetworksSetPrivateIpGoogleAccessRequest.newBuilder().build();
788       client
789           .setPrivateIpGoogleAccessAsync(
790               project, region, subnetwork, subnetworksSetPrivateIpGoogleAccessRequestResource)
791           .get();
792       Assert.fail("No exception raised");
793     } catch (ExecutionException e) {
794     }
795   }
796 
797   @Test
testIamPermissionsTest()798   public void testIamPermissionsTest() throws Exception {
799     TestPermissionsResponse expectedResponse =
800         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
801     mockService.addResponse(expectedResponse);
802 
803     String project = "project-6911";
804     String region = "region-9622";
805     String resource = "resource-756";
806     TestPermissionsRequest testPermissionsRequestResource =
807         TestPermissionsRequest.newBuilder().build();
808 
809     TestPermissionsResponse actualResponse =
810         client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
811     Assert.assertEquals(expectedResponse, actualResponse);
812 
813     List<String> actualRequests = mockService.getRequestPaths();
814     Assert.assertEquals(1, actualRequests.size());
815 
816     String apiClientHeaderKey =
817         mockService
818             .getRequestHeaders()
819             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
820             .iterator()
821             .next();
822     Assert.assertTrue(
823         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
824             .matcher(apiClientHeaderKey)
825             .matches());
826   }
827 
828   @Test
testIamPermissionsExceptionTest()829   public void testIamPermissionsExceptionTest() throws Exception {
830     ApiException exception =
831         ApiExceptionFactory.createException(
832             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
833     mockService.addException(exception);
834 
835     try {
836       String project = "project-6911";
837       String region = "region-9622";
838       String resource = "resource-756";
839       TestPermissionsRequest testPermissionsRequestResource =
840           TestPermissionsRequest.newBuilder().build();
841       client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
842       Assert.fail("No exception raised");
843     } catch (InvalidArgumentException e) {
844       // Expected exception.
845     }
846   }
847 }
848