• 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.NodeGroupsClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.NodeGroupsClient.ListNodesPagedResponse;
21 import static com.google.cloud.compute.v1.NodeGroupsClient.ListPagedResponse;
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.HttpJsonNodeGroupsStub;
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 NodeGroupsClientTest {
52   private static MockHttpService mockService;
53   private static NodeGroupsClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonNodeGroupsStub.getMethodDescriptors(), NodeGroupsSettings.getDefaultEndpoint());
60     NodeGroupsSettings settings =
61         NodeGroupsSettings.newBuilder()
62             .setTransportChannelProvider(
63                 NodeGroupsSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = NodeGroupsClient.create(settings);
69   }
70 
71   @AfterClass
stopServer()72   public static void stopServer() {
73     client.close();
74   }
75 
76   @Before
setUp()77   public void setUp() {}
78 
79   @After
tearDown()80   public void tearDown() throws Exception {
81     mockService.reset();
82   }
83 
84   @Test
addNodesTest()85   public void addNodesTest() throws Exception {
86     Operation expectedResponse =
87         Operation.newBuilder()
88             .setClientOperationId("clientOperationId-1230366697")
89             .setCreationTimestamp("creationTimestamp-370203401")
90             .setDescription("description-1724546052")
91             .setEndTime("endTime-1607243192")
92             .setError(Error.newBuilder().build())
93             .setHttpErrorMessage("httpErrorMessage1577303431")
94             .setHttpErrorStatusCode(0)
95             .setId(3355)
96             .setInsertTime("insertTime966165798")
97             .setKind("kind3292052")
98             .setName("name3373707")
99             .setOperationGroupId("operationGroupId1716161683")
100             .setOperationType("operationType91999553")
101             .setProgress(-1001078227)
102             .setRegion("region-934795532")
103             .setSelfLink("selfLink1191800166")
104             .setStartTime("startTime-2129294769")
105             .setStatus(Status.DONE)
106             .setStatusMessage("statusMessage-958704715")
107             .setTargetId(-815576439)
108             .setTargetLink("targetLink486368555")
109             .setUser("user3599307")
110             .addAllWarnings(new ArrayList<Warnings>())
111             .setZone("zone3744684")
112             .build();
113     mockService.addResponse(expectedResponse);
114 
115     String project = "project-6911";
116     String zone = "zone-5246";
117     String nodeGroup = "nodeGroup-5245";
118     NodeGroupsAddNodesRequest nodeGroupsAddNodesRequestResource =
119         NodeGroupsAddNodesRequest.newBuilder().build();
120 
121     Operation actualResponse =
122         client.addNodesAsync(project, zone, nodeGroup, nodeGroupsAddNodesRequestResource).get();
123     Assert.assertEquals(expectedResponse, actualResponse);
124 
125     List<String> actualRequests = mockService.getRequestPaths();
126     Assert.assertEquals(1, actualRequests.size());
127 
128     String apiClientHeaderKey =
129         mockService
130             .getRequestHeaders()
131             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
132             .iterator()
133             .next();
134     Assert.assertTrue(
135         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
136             .matcher(apiClientHeaderKey)
137             .matches());
138   }
139 
140   @Test
addNodesExceptionTest()141   public void addNodesExceptionTest() throws Exception {
142     ApiException exception =
143         ApiExceptionFactory.createException(
144             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
145     mockService.addException(exception);
146 
147     try {
148       String project = "project-6911";
149       String zone = "zone-5246";
150       String nodeGroup = "nodeGroup-5245";
151       NodeGroupsAddNodesRequest nodeGroupsAddNodesRequestResource =
152           NodeGroupsAddNodesRequest.newBuilder().build();
153       client.addNodesAsync(project, zone, nodeGroup, nodeGroupsAddNodesRequestResource).get();
154       Assert.fail("No exception raised");
155     } catch (ExecutionException e) {
156     }
157   }
158 
159   @Test
aggregatedListTest()160   public void aggregatedListTest() throws Exception {
161     NodeGroupsScopedList responsesElement = NodeGroupsScopedList.newBuilder().build();
162     NodeGroupAggregatedList expectedResponse =
163         NodeGroupAggregatedList.newBuilder()
164             .setNextPageToken("")
165             .putAllItems(Collections.singletonMap("items", responsesElement))
166             .build();
167     mockService.addResponse(expectedResponse);
168 
169     String project = "project-6911";
170 
171     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
172 
173     List<Map.Entry<String, NodeGroupsScopedList>> resources =
174         Lists.newArrayList(pagedListResponse.iterateAll());
175 
176     Assert.assertEquals(1, resources.size());
177     Assert.assertEquals(
178         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
179 
180     List<String> actualRequests = mockService.getRequestPaths();
181     Assert.assertEquals(1, actualRequests.size());
182 
183     String apiClientHeaderKey =
184         mockService
185             .getRequestHeaders()
186             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
187             .iterator()
188             .next();
189     Assert.assertTrue(
190         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
191             .matcher(apiClientHeaderKey)
192             .matches());
193   }
194 
195   @Test
aggregatedListExceptionTest()196   public void aggregatedListExceptionTest() throws Exception {
197     ApiException exception =
198         ApiExceptionFactory.createException(
199             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
200     mockService.addException(exception);
201 
202     try {
203       String project = "project-6911";
204       client.aggregatedList(project);
205       Assert.fail("No exception raised");
206     } catch (InvalidArgumentException e) {
207       // Expected exception.
208     }
209   }
210 
211   @Test
deleteTest()212   public void deleteTest() throws Exception {
213     Operation expectedResponse =
214         Operation.newBuilder()
215             .setClientOperationId("clientOperationId-1230366697")
216             .setCreationTimestamp("creationTimestamp-370203401")
217             .setDescription("description-1724546052")
218             .setEndTime("endTime-1607243192")
219             .setError(Error.newBuilder().build())
220             .setHttpErrorMessage("httpErrorMessage1577303431")
221             .setHttpErrorStatusCode(0)
222             .setId(3355)
223             .setInsertTime("insertTime966165798")
224             .setKind("kind3292052")
225             .setName("name3373707")
226             .setOperationGroupId("operationGroupId1716161683")
227             .setOperationType("operationType91999553")
228             .setProgress(-1001078227)
229             .setRegion("region-934795532")
230             .setSelfLink("selfLink1191800166")
231             .setStartTime("startTime-2129294769")
232             .setStatus(Status.DONE)
233             .setStatusMessage("statusMessage-958704715")
234             .setTargetId(-815576439)
235             .setTargetLink("targetLink486368555")
236             .setUser("user3599307")
237             .addAllWarnings(new ArrayList<Warnings>())
238             .setZone("zone3744684")
239             .build();
240     mockService.addResponse(expectedResponse);
241 
242     String project = "project-6911";
243     String zone = "zone-5246";
244     String nodeGroup = "nodeGroup-5245";
245 
246     Operation actualResponse = client.deleteAsync(project, zone, nodeGroup).get();
247     Assert.assertEquals(expectedResponse, actualResponse);
248 
249     List<String> actualRequests = mockService.getRequestPaths();
250     Assert.assertEquals(1, actualRequests.size());
251 
252     String apiClientHeaderKey =
253         mockService
254             .getRequestHeaders()
255             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
256             .iterator()
257             .next();
258     Assert.assertTrue(
259         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
260             .matcher(apiClientHeaderKey)
261             .matches());
262   }
263 
264   @Test
deleteExceptionTest()265   public void deleteExceptionTest() throws Exception {
266     ApiException exception =
267         ApiExceptionFactory.createException(
268             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
269     mockService.addException(exception);
270 
271     try {
272       String project = "project-6911";
273       String zone = "zone-5246";
274       String nodeGroup = "nodeGroup-5245";
275       client.deleteAsync(project, zone, nodeGroup).get();
276       Assert.fail("No exception raised");
277     } catch (ExecutionException e) {
278     }
279   }
280 
281   @Test
deleteNodesTest()282   public void deleteNodesTest() throws Exception {
283     Operation expectedResponse =
284         Operation.newBuilder()
285             .setClientOperationId("clientOperationId-1230366697")
286             .setCreationTimestamp("creationTimestamp-370203401")
287             .setDescription("description-1724546052")
288             .setEndTime("endTime-1607243192")
289             .setError(Error.newBuilder().build())
290             .setHttpErrorMessage("httpErrorMessage1577303431")
291             .setHttpErrorStatusCode(0)
292             .setId(3355)
293             .setInsertTime("insertTime966165798")
294             .setKind("kind3292052")
295             .setName("name3373707")
296             .setOperationGroupId("operationGroupId1716161683")
297             .setOperationType("operationType91999553")
298             .setProgress(-1001078227)
299             .setRegion("region-934795532")
300             .setSelfLink("selfLink1191800166")
301             .setStartTime("startTime-2129294769")
302             .setStatus(Status.DONE)
303             .setStatusMessage("statusMessage-958704715")
304             .setTargetId(-815576439)
305             .setTargetLink("targetLink486368555")
306             .setUser("user3599307")
307             .addAllWarnings(new ArrayList<Warnings>())
308             .setZone("zone3744684")
309             .build();
310     mockService.addResponse(expectedResponse);
311 
312     String project = "project-6911";
313     String zone = "zone-5246";
314     String nodeGroup = "nodeGroup-5245";
315     NodeGroupsDeleteNodesRequest nodeGroupsDeleteNodesRequestResource =
316         NodeGroupsDeleteNodesRequest.newBuilder().build();
317 
318     Operation actualResponse =
319         client
320             .deleteNodesAsync(project, zone, nodeGroup, nodeGroupsDeleteNodesRequestResource)
321             .get();
322     Assert.assertEquals(expectedResponse, actualResponse);
323 
324     List<String> actualRequests = mockService.getRequestPaths();
325     Assert.assertEquals(1, actualRequests.size());
326 
327     String apiClientHeaderKey =
328         mockService
329             .getRequestHeaders()
330             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
331             .iterator()
332             .next();
333     Assert.assertTrue(
334         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
335             .matcher(apiClientHeaderKey)
336             .matches());
337   }
338 
339   @Test
deleteNodesExceptionTest()340   public void deleteNodesExceptionTest() throws Exception {
341     ApiException exception =
342         ApiExceptionFactory.createException(
343             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
344     mockService.addException(exception);
345 
346     try {
347       String project = "project-6911";
348       String zone = "zone-5246";
349       String nodeGroup = "nodeGroup-5245";
350       NodeGroupsDeleteNodesRequest nodeGroupsDeleteNodesRequestResource =
351           NodeGroupsDeleteNodesRequest.newBuilder().build();
352       client.deleteNodesAsync(project, zone, nodeGroup, nodeGroupsDeleteNodesRequestResource).get();
353       Assert.fail("No exception raised");
354     } catch (ExecutionException e) {
355     }
356   }
357 
358   @Test
getTest()359   public void getTest() throws Exception {
360     NodeGroup expectedResponse =
361         NodeGroup.newBuilder()
362             .setAutoscalingPolicy(NodeGroupAutoscalingPolicy.newBuilder().build())
363             .setCreationTimestamp("creationTimestamp-370203401")
364             .setDescription("description-1724546052")
365             .setFingerprint("fingerprint-1375934236")
366             .setId(3355)
367             .setKind("kind3292052")
368             .setLocationHint("locationHint-58650660")
369             .setMaintenancePolicy("maintenancePolicy-1365923291")
370             .setMaintenanceWindow(NodeGroupMaintenanceWindow.newBuilder().build())
371             .setName("name3373707")
372             .setNodeTemplate("nodeTemplate2118368412")
373             .setSelfLink("selfLink1191800166")
374             .setShareSettings(ShareSettings.newBuilder().build())
375             .setSize(3530753)
376             .setStatus("status-892481550")
377             .setZone("zone3744684")
378             .build();
379     mockService.addResponse(expectedResponse);
380 
381     String project = "project-6911";
382     String zone = "zone-5246";
383     String nodeGroup = "nodeGroup-5245";
384 
385     NodeGroup actualResponse = client.get(project, zone, nodeGroup);
386     Assert.assertEquals(expectedResponse, actualResponse);
387 
388     List<String> actualRequests = mockService.getRequestPaths();
389     Assert.assertEquals(1, actualRequests.size());
390 
391     String apiClientHeaderKey =
392         mockService
393             .getRequestHeaders()
394             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
395             .iterator()
396             .next();
397     Assert.assertTrue(
398         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
399             .matcher(apiClientHeaderKey)
400             .matches());
401   }
402 
403   @Test
getExceptionTest()404   public void getExceptionTest() throws Exception {
405     ApiException exception =
406         ApiExceptionFactory.createException(
407             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
408     mockService.addException(exception);
409 
410     try {
411       String project = "project-6911";
412       String zone = "zone-5246";
413       String nodeGroup = "nodeGroup-5245";
414       client.get(project, zone, nodeGroup);
415       Assert.fail("No exception raised");
416     } catch (InvalidArgumentException e) {
417       // Expected exception.
418     }
419   }
420 
421   @Test
getIamPolicyTest()422   public void getIamPolicyTest() throws Exception {
423     Policy expectedResponse =
424         Policy.newBuilder()
425             .addAllAuditConfigs(new ArrayList<AuditConfig>())
426             .addAllBindings(new ArrayList<Binding>())
427             .setEtag("etag3123477")
428             .setIamOwned(true)
429             .addAllRules(new ArrayList<Rule>())
430             .setVersion(351608024)
431             .build();
432     mockService.addResponse(expectedResponse);
433 
434     String project = "project-6911";
435     String zone = "zone-5246";
436     String resource = "resource-756";
437 
438     Policy actualResponse = client.getIamPolicy(project, zone, resource);
439     Assert.assertEquals(expectedResponse, actualResponse);
440 
441     List<String> actualRequests = mockService.getRequestPaths();
442     Assert.assertEquals(1, actualRequests.size());
443 
444     String apiClientHeaderKey =
445         mockService
446             .getRequestHeaders()
447             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
448             .iterator()
449             .next();
450     Assert.assertTrue(
451         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
452             .matcher(apiClientHeaderKey)
453             .matches());
454   }
455 
456   @Test
getIamPolicyExceptionTest()457   public void getIamPolicyExceptionTest() throws Exception {
458     ApiException exception =
459         ApiExceptionFactory.createException(
460             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
461     mockService.addException(exception);
462 
463     try {
464       String project = "project-6911";
465       String zone = "zone-5246";
466       String resource = "resource-756";
467       client.getIamPolicy(project, zone, resource);
468       Assert.fail("No exception raised");
469     } catch (InvalidArgumentException e) {
470       // Expected exception.
471     }
472   }
473 
474   @Test
insertTest()475   public void insertTest() throws Exception {
476     Operation expectedResponse =
477         Operation.newBuilder()
478             .setClientOperationId("clientOperationId-1230366697")
479             .setCreationTimestamp("creationTimestamp-370203401")
480             .setDescription("description-1724546052")
481             .setEndTime("endTime-1607243192")
482             .setError(Error.newBuilder().build())
483             .setHttpErrorMessage("httpErrorMessage1577303431")
484             .setHttpErrorStatusCode(0)
485             .setId(3355)
486             .setInsertTime("insertTime966165798")
487             .setKind("kind3292052")
488             .setName("name3373707")
489             .setOperationGroupId("operationGroupId1716161683")
490             .setOperationType("operationType91999553")
491             .setProgress(-1001078227)
492             .setRegion("region-934795532")
493             .setSelfLink("selfLink1191800166")
494             .setStartTime("startTime-2129294769")
495             .setStatus(Status.DONE)
496             .setStatusMessage("statusMessage-958704715")
497             .setTargetId(-815576439)
498             .setTargetLink("targetLink486368555")
499             .setUser("user3599307")
500             .addAllWarnings(new ArrayList<Warnings>())
501             .setZone("zone3744684")
502             .build();
503     mockService.addResponse(expectedResponse);
504 
505     String project = "project-6911";
506     String zone = "zone-5246";
507     int initialNodeCount = 1682564205;
508     NodeGroup nodeGroupResource = NodeGroup.newBuilder().build();
509 
510     Operation actualResponse =
511         client.insertAsync(project, zone, initialNodeCount, nodeGroupResource).get();
512     Assert.assertEquals(expectedResponse, actualResponse);
513 
514     List<String> actualRequests = mockService.getRequestPaths();
515     Assert.assertEquals(1, actualRequests.size());
516 
517     String apiClientHeaderKey =
518         mockService
519             .getRequestHeaders()
520             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
521             .iterator()
522             .next();
523     Assert.assertTrue(
524         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
525             .matcher(apiClientHeaderKey)
526             .matches());
527   }
528 
529   @Test
insertExceptionTest()530   public void insertExceptionTest() throws Exception {
531     ApiException exception =
532         ApiExceptionFactory.createException(
533             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
534     mockService.addException(exception);
535 
536     try {
537       String project = "project-6911";
538       String zone = "zone-5246";
539       int initialNodeCount = 1682564205;
540       NodeGroup nodeGroupResource = NodeGroup.newBuilder().build();
541       client.insertAsync(project, zone, initialNodeCount, nodeGroupResource).get();
542       Assert.fail("No exception raised");
543     } catch (ExecutionException e) {
544     }
545   }
546 
547   @Test
listTest()548   public void listTest() throws Exception {
549     NodeGroup responsesElement = NodeGroup.newBuilder().build();
550     NodeGroupList expectedResponse =
551         NodeGroupList.newBuilder()
552             .setNextPageToken("")
553             .addAllItems(Arrays.asList(responsesElement))
554             .build();
555     mockService.addResponse(expectedResponse);
556 
557     String project = "project-6911";
558     String zone = "zone-5246";
559 
560     ListPagedResponse pagedListResponse = client.list(project, zone);
561 
562     List<NodeGroup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
563 
564     Assert.assertEquals(1, resources.size());
565     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
566 
567     List<String> actualRequests = mockService.getRequestPaths();
568     Assert.assertEquals(1, actualRequests.size());
569 
570     String apiClientHeaderKey =
571         mockService
572             .getRequestHeaders()
573             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
574             .iterator()
575             .next();
576     Assert.assertTrue(
577         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
578             .matcher(apiClientHeaderKey)
579             .matches());
580   }
581 
582   @Test
listExceptionTest()583   public void listExceptionTest() throws Exception {
584     ApiException exception =
585         ApiExceptionFactory.createException(
586             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
587     mockService.addException(exception);
588 
589     try {
590       String project = "project-6911";
591       String zone = "zone-5246";
592       client.list(project, zone);
593       Assert.fail("No exception raised");
594     } catch (InvalidArgumentException e) {
595       // Expected exception.
596     }
597   }
598 
599   @Test
listNodesTest()600   public void listNodesTest() throws Exception {
601     NodeGroupNode responsesElement = NodeGroupNode.newBuilder().build();
602     NodeGroupsListNodes expectedResponse =
603         NodeGroupsListNodes.newBuilder()
604             .setNextPageToken("")
605             .addAllItems(Arrays.asList(responsesElement))
606             .build();
607     mockService.addResponse(expectedResponse);
608 
609     String project = "project-6911";
610     String zone = "zone-5246";
611     String nodeGroup = "nodeGroup-5245";
612 
613     ListNodesPagedResponse pagedListResponse = client.listNodes(project, zone, nodeGroup);
614 
615     List<NodeGroupNode> resources = Lists.newArrayList(pagedListResponse.iterateAll());
616 
617     Assert.assertEquals(1, resources.size());
618     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
619 
620     List<String> actualRequests = mockService.getRequestPaths();
621     Assert.assertEquals(1, actualRequests.size());
622 
623     String apiClientHeaderKey =
624         mockService
625             .getRequestHeaders()
626             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
627             .iterator()
628             .next();
629     Assert.assertTrue(
630         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
631             .matcher(apiClientHeaderKey)
632             .matches());
633   }
634 
635   @Test
listNodesExceptionTest()636   public void listNodesExceptionTest() throws Exception {
637     ApiException exception =
638         ApiExceptionFactory.createException(
639             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
640     mockService.addException(exception);
641 
642     try {
643       String project = "project-6911";
644       String zone = "zone-5246";
645       String nodeGroup = "nodeGroup-5245";
646       client.listNodes(project, zone, nodeGroup);
647       Assert.fail("No exception raised");
648     } catch (InvalidArgumentException e) {
649       // Expected exception.
650     }
651   }
652 
653   @Test
patchTest()654   public void patchTest() throws Exception {
655     Operation expectedResponse =
656         Operation.newBuilder()
657             .setClientOperationId("clientOperationId-1230366697")
658             .setCreationTimestamp("creationTimestamp-370203401")
659             .setDescription("description-1724546052")
660             .setEndTime("endTime-1607243192")
661             .setError(Error.newBuilder().build())
662             .setHttpErrorMessage("httpErrorMessage1577303431")
663             .setHttpErrorStatusCode(0)
664             .setId(3355)
665             .setInsertTime("insertTime966165798")
666             .setKind("kind3292052")
667             .setName("name3373707")
668             .setOperationGroupId("operationGroupId1716161683")
669             .setOperationType("operationType91999553")
670             .setProgress(-1001078227)
671             .setRegion("region-934795532")
672             .setSelfLink("selfLink1191800166")
673             .setStartTime("startTime-2129294769")
674             .setStatus(Status.DONE)
675             .setStatusMessage("statusMessage-958704715")
676             .setTargetId(-815576439)
677             .setTargetLink("targetLink486368555")
678             .setUser("user3599307")
679             .addAllWarnings(new ArrayList<Warnings>())
680             .setZone("zone3744684")
681             .build();
682     mockService.addResponse(expectedResponse);
683 
684     String project = "project-6911";
685     String zone = "zone-5246";
686     String nodeGroup = "nodeGroup-5245";
687     NodeGroup nodeGroupResource = NodeGroup.newBuilder().build();
688 
689     Operation actualResponse = client.patchAsync(project, zone, nodeGroup, nodeGroupResource).get();
690     Assert.assertEquals(expectedResponse, actualResponse);
691 
692     List<String> actualRequests = mockService.getRequestPaths();
693     Assert.assertEquals(1, actualRequests.size());
694 
695     String apiClientHeaderKey =
696         mockService
697             .getRequestHeaders()
698             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
699             .iterator()
700             .next();
701     Assert.assertTrue(
702         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
703             .matcher(apiClientHeaderKey)
704             .matches());
705   }
706 
707   @Test
patchExceptionTest()708   public void patchExceptionTest() throws Exception {
709     ApiException exception =
710         ApiExceptionFactory.createException(
711             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
712     mockService.addException(exception);
713 
714     try {
715       String project = "project-6911";
716       String zone = "zone-5246";
717       String nodeGroup = "nodeGroup-5245";
718       NodeGroup nodeGroupResource = NodeGroup.newBuilder().build();
719       client.patchAsync(project, zone, nodeGroup, nodeGroupResource).get();
720       Assert.fail("No exception raised");
721     } catch (ExecutionException e) {
722     }
723   }
724 
725   @Test
setIamPolicyTest()726   public void setIamPolicyTest() throws Exception {
727     Policy expectedResponse =
728         Policy.newBuilder()
729             .addAllAuditConfigs(new ArrayList<AuditConfig>())
730             .addAllBindings(new ArrayList<Binding>())
731             .setEtag("etag3123477")
732             .setIamOwned(true)
733             .addAllRules(new ArrayList<Rule>())
734             .setVersion(351608024)
735             .build();
736     mockService.addResponse(expectedResponse);
737 
738     String project = "project-6911";
739     String zone = "zone-5246";
740     String resource = "resource-756";
741     ZoneSetPolicyRequest zoneSetPolicyRequestResource = ZoneSetPolicyRequest.newBuilder().build();
742 
743     Policy actualResponse =
744         client.setIamPolicy(project, zone, resource, zoneSetPolicyRequestResource);
745     Assert.assertEquals(expectedResponse, actualResponse);
746 
747     List<String> actualRequests = mockService.getRequestPaths();
748     Assert.assertEquals(1, actualRequests.size());
749 
750     String apiClientHeaderKey =
751         mockService
752             .getRequestHeaders()
753             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
754             .iterator()
755             .next();
756     Assert.assertTrue(
757         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
758             .matcher(apiClientHeaderKey)
759             .matches());
760   }
761 
762   @Test
setIamPolicyExceptionTest()763   public void setIamPolicyExceptionTest() throws Exception {
764     ApiException exception =
765         ApiExceptionFactory.createException(
766             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
767     mockService.addException(exception);
768 
769     try {
770       String project = "project-6911";
771       String zone = "zone-5246";
772       String resource = "resource-756";
773       ZoneSetPolicyRequest zoneSetPolicyRequestResource = ZoneSetPolicyRequest.newBuilder().build();
774       client.setIamPolicy(project, zone, resource, zoneSetPolicyRequestResource);
775       Assert.fail("No exception raised");
776     } catch (InvalidArgumentException e) {
777       // Expected exception.
778     }
779   }
780 
781   @Test
setNodeTemplateTest()782   public void setNodeTemplateTest() throws Exception {
783     Operation expectedResponse =
784         Operation.newBuilder()
785             .setClientOperationId("clientOperationId-1230366697")
786             .setCreationTimestamp("creationTimestamp-370203401")
787             .setDescription("description-1724546052")
788             .setEndTime("endTime-1607243192")
789             .setError(Error.newBuilder().build())
790             .setHttpErrorMessage("httpErrorMessage1577303431")
791             .setHttpErrorStatusCode(0)
792             .setId(3355)
793             .setInsertTime("insertTime966165798")
794             .setKind("kind3292052")
795             .setName("name3373707")
796             .setOperationGroupId("operationGroupId1716161683")
797             .setOperationType("operationType91999553")
798             .setProgress(-1001078227)
799             .setRegion("region-934795532")
800             .setSelfLink("selfLink1191800166")
801             .setStartTime("startTime-2129294769")
802             .setStatus(Status.DONE)
803             .setStatusMessage("statusMessage-958704715")
804             .setTargetId(-815576439)
805             .setTargetLink("targetLink486368555")
806             .setUser("user3599307")
807             .addAllWarnings(new ArrayList<Warnings>())
808             .setZone("zone3744684")
809             .build();
810     mockService.addResponse(expectedResponse);
811 
812     String project = "project-6911";
813     String zone = "zone-5246";
814     String nodeGroup = "nodeGroup-5245";
815     NodeGroupsSetNodeTemplateRequest nodeGroupsSetNodeTemplateRequestResource =
816         NodeGroupsSetNodeTemplateRequest.newBuilder().build();
817 
818     Operation actualResponse =
819         client
820             .setNodeTemplateAsync(
821                 project, zone, nodeGroup, nodeGroupsSetNodeTemplateRequestResource)
822             .get();
823     Assert.assertEquals(expectedResponse, actualResponse);
824 
825     List<String> actualRequests = mockService.getRequestPaths();
826     Assert.assertEquals(1, actualRequests.size());
827 
828     String apiClientHeaderKey =
829         mockService
830             .getRequestHeaders()
831             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
832             .iterator()
833             .next();
834     Assert.assertTrue(
835         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
836             .matcher(apiClientHeaderKey)
837             .matches());
838   }
839 
840   @Test
setNodeTemplateExceptionTest()841   public void setNodeTemplateExceptionTest() throws Exception {
842     ApiException exception =
843         ApiExceptionFactory.createException(
844             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
845     mockService.addException(exception);
846 
847     try {
848       String project = "project-6911";
849       String zone = "zone-5246";
850       String nodeGroup = "nodeGroup-5245";
851       NodeGroupsSetNodeTemplateRequest nodeGroupsSetNodeTemplateRequestResource =
852           NodeGroupsSetNodeTemplateRequest.newBuilder().build();
853       client
854           .setNodeTemplateAsync(project, zone, nodeGroup, nodeGroupsSetNodeTemplateRequestResource)
855           .get();
856       Assert.fail("No exception raised");
857     } catch (ExecutionException e) {
858     }
859   }
860 
861   @Test
simulateMaintenanceEventTest()862   public void simulateMaintenanceEventTest() throws Exception {
863     Operation expectedResponse =
864         Operation.newBuilder()
865             .setClientOperationId("clientOperationId-1230366697")
866             .setCreationTimestamp("creationTimestamp-370203401")
867             .setDescription("description-1724546052")
868             .setEndTime("endTime-1607243192")
869             .setError(Error.newBuilder().build())
870             .setHttpErrorMessage("httpErrorMessage1577303431")
871             .setHttpErrorStatusCode(0)
872             .setId(3355)
873             .setInsertTime("insertTime966165798")
874             .setKind("kind3292052")
875             .setName("name3373707")
876             .setOperationGroupId("operationGroupId1716161683")
877             .setOperationType("operationType91999553")
878             .setProgress(-1001078227)
879             .setRegion("region-934795532")
880             .setSelfLink("selfLink1191800166")
881             .setStartTime("startTime-2129294769")
882             .setStatus(Status.DONE)
883             .setStatusMessage("statusMessage-958704715")
884             .setTargetId(-815576439)
885             .setTargetLink("targetLink486368555")
886             .setUser("user3599307")
887             .addAllWarnings(new ArrayList<Warnings>())
888             .setZone("zone3744684")
889             .build();
890     mockService.addResponse(expectedResponse);
891 
892     String project = "project-6911";
893     String zone = "zone-5246";
894     String nodeGroup = "nodeGroup-5245";
895     NodeGroupsSimulateMaintenanceEventRequest nodeGroupsSimulateMaintenanceEventRequestResource =
896         NodeGroupsSimulateMaintenanceEventRequest.newBuilder().build();
897 
898     Operation actualResponse =
899         client
900             .simulateMaintenanceEventAsync(
901                 project, zone, nodeGroup, nodeGroupsSimulateMaintenanceEventRequestResource)
902             .get();
903     Assert.assertEquals(expectedResponse, actualResponse);
904 
905     List<String> actualRequests = mockService.getRequestPaths();
906     Assert.assertEquals(1, actualRequests.size());
907 
908     String apiClientHeaderKey =
909         mockService
910             .getRequestHeaders()
911             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
912             .iterator()
913             .next();
914     Assert.assertTrue(
915         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
916             .matcher(apiClientHeaderKey)
917             .matches());
918   }
919 
920   @Test
simulateMaintenanceEventExceptionTest()921   public void simulateMaintenanceEventExceptionTest() throws Exception {
922     ApiException exception =
923         ApiExceptionFactory.createException(
924             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
925     mockService.addException(exception);
926 
927     try {
928       String project = "project-6911";
929       String zone = "zone-5246";
930       String nodeGroup = "nodeGroup-5245";
931       NodeGroupsSimulateMaintenanceEventRequest nodeGroupsSimulateMaintenanceEventRequestResource =
932           NodeGroupsSimulateMaintenanceEventRequest.newBuilder().build();
933       client
934           .simulateMaintenanceEventAsync(
935               project, zone, nodeGroup, nodeGroupsSimulateMaintenanceEventRequestResource)
936           .get();
937       Assert.fail("No exception raised");
938     } catch (ExecutionException e) {
939     }
940   }
941 
942   @Test
testIamPermissionsTest()943   public void testIamPermissionsTest() throws Exception {
944     TestPermissionsResponse expectedResponse =
945         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
946     mockService.addResponse(expectedResponse);
947 
948     String project = "project-6911";
949     String zone = "zone-5246";
950     String resource = "resource-756";
951     TestPermissionsRequest testPermissionsRequestResource =
952         TestPermissionsRequest.newBuilder().build();
953 
954     TestPermissionsResponse actualResponse =
955         client.testIamPermissions(project, zone, resource, testPermissionsRequestResource);
956     Assert.assertEquals(expectedResponse, actualResponse);
957 
958     List<String> actualRequests = mockService.getRequestPaths();
959     Assert.assertEquals(1, actualRequests.size());
960 
961     String apiClientHeaderKey =
962         mockService
963             .getRequestHeaders()
964             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
965             .iterator()
966             .next();
967     Assert.assertTrue(
968         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
969             .matcher(apiClientHeaderKey)
970             .matches());
971   }
972 
973   @Test
testIamPermissionsExceptionTest()974   public void testIamPermissionsExceptionTest() throws Exception {
975     ApiException exception =
976         ApiExceptionFactory.createException(
977             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
978     mockService.addException(exception);
979 
980     try {
981       String project = "project-6911";
982       String zone = "zone-5246";
983       String resource = "resource-756";
984       TestPermissionsRequest testPermissionsRequestResource =
985           TestPermissionsRequest.newBuilder().build();
986       client.testIamPermissions(project, zone, resource, testPermissionsRequestResource);
987       Assert.fail("No exception raised");
988     } catch (InvalidArgumentException e) {
989       // Expected exception.
990     }
991   }
992 }
993