• 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.InstanceGroupManagersClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.InstanceGroupManagersClient.ListErrorsPagedResponse;
21 import static com.google.cloud.compute.v1.InstanceGroupManagersClient.ListManagedInstancesPagedResponse;
22 import static com.google.cloud.compute.v1.InstanceGroupManagersClient.ListPagedResponse;
23 import static com.google.cloud.compute.v1.InstanceGroupManagersClient.ListPerInstanceConfigsPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
27 import com.google.api.gax.httpjson.testing.MockHttpService;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.ApiException;
30 import com.google.api.gax.rpc.ApiExceptionFactory;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.api.gax.rpc.StatusCode;
33 import com.google.api.gax.rpc.testing.FakeStatusCode;
34 import com.google.cloud.compute.v1.Operation.Status;
35 import com.google.cloud.compute.v1.stub.HttpJsonInstanceGroupManagersStub;
36 import com.google.common.collect.Lists;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.Collections;
41 import java.util.List;
42 import java.util.Map;
43 import java.util.concurrent.ExecutionException;
44 import javax.annotation.Generated;
45 import org.junit.After;
46 import org.junit.AfterClass;
47 import org.junit.Assert;
48 import org.junit.Before;
49 import org.junit.BeforeClass;
50 import org.junit.Test;
51 
52 @Generated("by gapic-generator-java")
53 public class InstanceGroupManagersClientTest {
54   private static MockHttpService mockService;
55   private static InstanceGroupManagersClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() throws IOException {
59     mockService =
60         new MockHttpService(
61             HttpJsonInstanceGroupManagersStub.getMethodDescriptors(),
62             InstanceGroupManagersSettings.getDefaultEndpoint());
63     InstanceGroupManagersSettings settings =
64         InstanceGroupManagersSettings.newBuilder()
65             .setTransportChannelProvider(
66                 InstanceGroupManagersSettings.defaultHttpJsonTransportProviderBuilder()
67                     .setHttpTransport(mockService)
68                     .build())
69             .setCredentialsProvider(NoCredentialsProvider.create())
70             .build();
71     client = InstanceGroupManagersClient.create(settings);
72   }
73 
74   @AfterClass
stopServer()75   public static void stopServer() {
76     client.close();
77   }
78 
79   @Before
setUp()80   public void setUp() {}
81 
82   @After
tearDown()83   public void tearDown() throws Exception {
84     mockService.reset();
85   }
86 
87   @Test
abandonInstancesTest()88   public void abandonInstancesTest() throws Exception {
89     Operation expectedResponse =
90         Operation.newBuilder()
91             .setClientOperationId("clientOperationId-1230366697")
92             .setCreationTimestamp("creationTimestamp-370203401")
93             .setDescription("description-1724546052")
94             .setEndTime("endTime-1607243192")
95             .setError(Error.newBuilder().build())
96             .setHttpErrorMessage("httpErrorMessage1577303431")
97             .setHttpErrorStatusCode(0)
98             .setId(3355)
99             .setInsertTime("insertTime966165798")
100             .setKind("kind3292052")
101             .setName("name3373707")
102             .setOperationGroupId("operationGroupId1716161683")
103             .setOperationType("operationType91999553")
104             .setProgress(-1001078227)
105             .setRegion("region-934795532")
106             .setSelfLink("selfLink1191800166")
107             .setStartTime("startTime-2129294769")
108             .setStatus(Status.DONE)
109             .setStatusMessage("statusMessage-958704715")
110             .setTargetId(-815576439)
111             .setTargetLink("targetLink486368555")
112             .setUser("user3599307")
113             .addAllWarnings(new ArrayList<Warnings>())
114             .setZone("zone3744684")
115             .build();
116     mockService.addResponse(expectedResponse);
117 
118     String project = "project-6911";
119     String zone = "zone-5246";
120     String instanceGroupManager = "instanceGroupManager-7543";
121     InstanceGroupManagersAbandonInstancesRequest
122         instanceGroupManagersAbandonInstancesRequestResource =
123             InstanceGroupManagersAbandonInstancesRequest.newBuilder().build();
124 
125     Operation actualResponse =
126         client
127             .abandonInstancesAsync(
128                 project,
129                 zone,
130                 instanceGroupManager,
131                 instanceGroupManagersAbandonInstancesRequestResource)
132             .get();
133     Assert.assertEquals(expectedResponse, actualResponse);
134 
135     List<String> actualRequests = mockService.getRequestPaths();
136     Assert.assertEquals(1, actualRequests.size());
137 
138     String apiClientHeaderKey =
139         mockService
140             .getRequestHeaders()
141             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
142             .iterator()
143             .next();
144     Assert.assertTrue(
145         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
146             .matcher(apiClientHeaderKey)
147             .matches());
148   }
149 
150   @Test
abandonInstancesExceptionTest()151   public void abandonInstancesExceptionTest() throws Exception {
152     ApiException exception =
153         ApiExceptionFactory.createException(
154             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
155     mockService.addException(exception);
156 
157     try {
158       String project = "project-6911";
159       String zone = "zone-5246";
160       String instanceGroupManager = "instanceGroupManager-7543";
161       InstanceGroupManagersAbandonInstancesRequest
162           instanceGroupManagersAbandonInstancesRequestResource =
163               InstanceGroupManagersAbandonInstancesRequest.newBuilder().build();
164       client
165           .abandonInstancesAsync(
166               project,
167               zone,
168               instanceGroupManager,
169               instanceGroupManagersAbandonInstancesRequestResource)
170           .get();
171       Assert.fail("No exception raised");
172     } catch (ExecutionException e) {
173     }
174   }
175 
176   @Test
aggregatedListTest()177   public void aggregatedListTest() throws Exception {
178     InstanceGroupManagersScopedList responsesElement =
179         InstanceGroupManagersScopedList.newBuilder().build();
180     InstanceGroupManagerAggregatedList expectedResponse =
181         InstanceGroupManagerAggregatedList.newBuilder()
182             .setNextPageToken("")
183             .putAllItems(Collections.singletonMap("items", responsesElement))
184             .build();
185     mockService.addResponse(expectedResponse);
186 
187     String project = "project-6911";
188 
189     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
190 
191     List<Map.Entry<String, InstanceGroupManagersScopedList>> resources =
192         Lists.newArrayList(pagedListResponse.iterateAll());
193 
194     Assert.assertEquals(1, resources.size());
195     Assert.assertEquals(
196         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
197 
198     List<String> actualRequests = mockService.getRequestPaths();
199     Assert.assertEquals(1, actualRequests.size());
200 
201     String apiClientHeaderKey =
202         mockService
203             .getRequestHeaders()
204             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
205             .iterator()
206             .next();
207     Assert.assertTrue(
208         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
209             .matcher(apiClientHeaderKey)
210             .matches());
211   }
212 
213   @Test
aggregatedListExceptionTest()214   public void aggregatedListExceptionTest() throws Exception {
215     ApiException exception =
216         ApiExceptionFactory.createException(
217             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
218     mockService.addException(exception);
219 
220     try {
221       String project = "project-6911";
222       client.aggregatedList(project);
223       Assert.fail("No exception raised");
224     } catch (InvalidArgumentException e) {
225       // Expected exception.
226     }
227   }
228 
229   @Test
applyUpdatesToInstancesTest()230   public void applyUpdatesToInstancesTest() throws Exception {
231     Operation expectedResponse =
232         Operation.newBuilder()
233             .setClientOperationId("clientOperationId-1230366697")
234             .setCreationTimestamp("creationTimestamp-370203401")
235             .setDescription("description-1724546052")
236             .setEndTime("endTime-1607243192")
237             .setError(Error.newBuilder().build())
238             .setHttpErrorMessage("httpErrorMessage1577303431")
239             .setHttpErrorStatusCode(0)
240             .setId(3355)
241             .setInsertTime("insertTime966165798")
242             .setKind("kind3292052")
243             .setName("name3373707")
244             .setOperationGroupId("operationGroupId1716161683")
245             .setOperationType("operationType91999553")
246             .setProgress(-1001078227)
247             .setRegion("region-934795532")
248             .setSelfLink("selfLink1191800166")
249             .setStartTime("startTime-2129294769")
250             .setStatus(Status.DONE)
251             .setStatusMessage("statusMessage-958704715")
252             .setTargetId(-815576439)
253             .setTargetLink("targetLink486368555")
254             .setUser("user3599307")
255             .addAllWarnings(new ArrayList<Warnings>())
256             .setZone("zone3744684")
257             .build();
258     mockService.addResponse(expectedResponse);
259 
260     String project = "project-6911";
261     String zone = "zone-5246";
262     String instanceGroupManager = "instanceGroupManager-7543";
263     InstanceGroupManagersApplyUpdatesRequest instanceGroupManagersApplyUpdatesRequestResource =
264         InstanceGroupManagersApplyUpdatesRequest.newBuilder().build();
265 
266     Operation actualResponse =
267         client
268             .applyUpdatesToInstancesAsync(
269                 project,
270                 zone,
271                 instanceGroupManager,
272                 instanceGroupManagersApplyUpdatesRequestResource)
273             .get();
274     Assert.assertEquals(expectedResponse, actualResponse);
275 
276     List<String> actualRequests = mockService.getRequestPaths();
277     Assert.assertEquals(1, actualRequests.size());
278 
279     String apiClientHeaderKey =
280         mockService
281             .getRequestHeaders()
282             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
283             .iterator()
284             .next();
285     Assert.assertTrue(
286         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
287             .matcher(apiClientHeaderKey)
288             .matches());
289   }
290 
291   @Test
applyUpdatesToInstancesExceptionTest()292   public void applyUpdatesToInstancesExceptionTest() throws Exception {
293     ApiException exception =
294         ApiExceptionFactory.createException(
295             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
296     mockService.addException(exception);
297 
298     try {
299       String project = "project-6911";
300       String zone = "zone-5246";
301       String instanceGroupManager = "instanceGroupManager-7543";
302       InstanceGroupManagersApplyUpdatesRequest instanceGroupManagersApplyUpdatesRequestResource =
303           InstanceGroupManagersApplyUpdatesRequest.newBuilder().build();
304       client
305           .applyUpdatesToInstancesAsync(
306               project, zone, instanceGroupManager, instanceGroupManagersApplyUpdatesRequestResource)
307           .get();
308       Assert.fail("No exception raised");
309     } catch (ExecutionException e) {
310     }
311   }
312 
313   @Test
createInstancesTest()314   public void createInstancesTest() throws Exception {
315     Operation expectedResponse =
316         Operation.newBuilder()
317             .setClientOperationId("clientOperationId-1230366697")
318             .setCreationTimestamp("creationTimestamp-370203401")
319             .setDescription("description-1724546052")
320             .setEndTime("endTime-1607243192")
321             .setError(Error.newBuilder().build())
322             .setHttpErrorMessage("httpErrorMessage1577303431")
323             .setHttpErrorStatusCode(0)
324             .setId(3355)
325             .setInsertTime("insertTime966165798")
326             .setKind("kind3292052")
327             .setName("name3373707")
328             .setOperationGroupId("operationGroupId1716161683")
329             .setOperationType("operationType91999553")
330             .setProgress(-1001078227)
331             .setRegion("region-934795532")
332             .setSelfLink("selfLink1191800166")
333             .setStartTime("startTime-2129294769")
334             .setStatus(Status.DONE)
335             .setStatusMessage("statusMessage-958704715")
336             .setTargetId(-815576439)
337             .setTargetLink("targetLink486368555")
338             .setUser("user3599307")
339             .addAllWarnings(new ArrayList<Warnings>())
340             .setZone("zone3744684")
341             .build();
342     mockService.addResponse(expectedResponse);
343 
344     String project = "project-6911";
345     String zone = "zone-5246";
346     String instanceGroupManager = "instanceGroupManager-7543";
347     InstanceGroupManagersCreateInstancesRequest
348         instanceGroupManagersCreateInstancesRequestResource =
349             InstanceGroupManagersCreateInstancesRequest.newBuilder().build();
350 
351     Operation actualResponse =
352         client
353             .createInstancesAsync(
354                 project,
355                 zone,
356                 instanceGroupManager,
357                 instanceGroupManagersCreateInstancesRequestResource)
358             .get();
359     Assert.assertEquals(expectedResponse, actualResponse);
360 
361     List<String> actualRequests = mockService.getRequestPaths();
362     Assert.assertEquals(1, actualRequests.size());
363 
364     String apiClientHeaderKey =
365         mockService
366             .getRequestHeaders()
367             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
368             .iterator()
369             .next();
370     Assert.assertTrue(
371         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
372             .matcher(apiClientHeaderKey)
373             .matches());
374   }
375 
376   @Test
createInstancesExceptionTest()377   public void createInstancesExceptionTest() throws Exception {
378     ApiException exception =
379         ApiExceptionFactory.createException(
380             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
381     mockService.addException(exception);
382 
383     try {
384       String project = "project-6911";
385       String zone = "zone-5246";
386       String instanceGroupManager = "instanceGroupManager-7543";
387       InstanceGroupManagersCreateInstancesRequest
388           instanceGroupManagersCreateInstancesRequestResource =
389               InstanceGroupManagersCreateInstancesRequest.newBuilder().build();
390       client
391           .createInstancesAsync(
392               project,
393               zone,
394               instanceGroupManager,
395               instanceGroupManagersCreateInstancesRequestResource)
396           .get();
397       Assert.fail("No exception raised");
398     } catch (ExecutionException e) {
399     }
400   }
401 
402   @Test
deleteTest()403   public void deleteTest() throws Exception {
404     Operation expectedResponse =
405         Operation.newBuilder()
406             .setClientOperationId("clientOperationId-1230366697")
407             .setCreationTimestamp("creationTimestamp-370203401")
408             .setDescription("description-1724546052")
409             .setEndTime("endTime-1607243192")
410             .setError(Error.newBuilder().build())
411             .setHttpErrorMessage("httpErrorMessage1577303431")
412             .setHttpErrorStatusCode(0)
413             .setId(3355)
414             .setInsertTime("insertTime966165798")
415             .setKind("kind3292052")
416             .setName("name3373707")
417             .setOperationGroupId("operationGroupId1716161683")
418             .setOperationType("operationType91999553")
419             .setProgress(-1001078227)
420             .setRegion("region-934795532")
421             .setSelfLink("selfLink1191800166")
422             .setStartTime("startTime-2129294769")
423             .setStatus(Status.DONE)
424             .setStatusMessage("statusMessage-958704715")
425             .setTargetId(-815576439)
426             .setTargetLink("targetLink486368555")
427             .setUser("user3599307")
428             .addAllWarnings(new ArrayList<Warnings>())
429             .setZone("zone3744684")
430             .build();
431     mockService.addResponse(expectedResponse);
432 
433     String project = "project-6911";
434     String zone = "zone-5246";
435     String instanceGroupManager = "instanceGroupManager-7543";
436 
437     Operation actualResponse = client.deleteAsync(project, zone, instanceGroupManager).get();
438     Assert.assertEquals(expectedResponse, actualResponse);
439 
440     List<String> actualRequests = mockService.getRequestPaths();
441     Assert.assertEquals(1, actualRequests.size());
442 
443     String apiClientHeaderKey =
444         mockService
445             .getRequestHeaders()
446             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
447             .iterator()
448             .next();
449     Assert.assertTrue(
450         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
451             .matcher(apiClientHeaderKey)
452             .matches());
453   }
454 
455   @Test
deleteExceptionTest()456   public void deleteExceptionTest() throws Exception {
457     ApiException exception =
458         ApiExceptionFactory.createException(
459             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
460     mockService.addException(exception);
461 
462     try {
463       String project = "project-6911";
464       String zone = "zone-5246";
465       String instanceGroupManager = "instanceGroupManager-7543";
466       client.deleteAsync(project, zone, instanceGroupManager).get();
467       Assert.fail("No exception raised");
468     } catch (ExecutionException e) {
469     }
470   }
471 
472   @Test
deleteInstancesTest()473   public void deleteInstancesTest() throws Exception {
474     Operation expectedResponse =
475         Operation.newBuilder()
476             .setClientOperationId("clientOperationId-1230366697")
477             .setCreationTimestamp("creationTimestamp-370203401")
478             .setDescription("description-1724546052")
479             .setEndTime("endTime-1607243192")
480             .setError(Error.newBuilder().build())
481             .setHttpErrorMessage("httpErrorMessage1577303431")
482             .setHttpErrorStatusCode(0)
483             .setId(3355)
484             .setInsertTime("insertTime966165798")
485             .setKind("kind3292052")
486             .setName("name3373707")
487             .setOperationGroupId("operationGroupId1716161683")
488             .setOperationType("operationType91999553")
489             .setProgress(-1001078227)
490             .setRegion("region-934795532")
491             .setSelfLink("selfLink1191800166")
492             .setStartTime("startTime-2129294769")
493             .setStatus(Status.DONE)
494             .setStatusMessage("statusMessage-958704715")
495             .setTargetId(-815576439)
496             .setTargetLink("targetLink486368555")
497             .setUser("user3599307")
498             .addAllWarnings(new ArrayList<Warnings>())
499             .setZone("zone3744684")
500             .build();
501     mockService.addResponse(expectedResponse);
502 
503     String project = "project-6911";
504     String zone = "zone-5246";
505     String instanceGroupManager = "instanceGroupManager-7543";
506     InstanceGroupManagersDeleteInstancesRequest
507         instanceGroupManagersDeleteInstancesRequestResource =
508             InstanceGroupManagersDeleteInstancesRequest.newBuilder().build();
509 
510     Operation actualResponse =
511         client
512             .deleteInstancesAsync(
513                 project,
514                 zone,
515                 instanceGroupManager,
516                 instanceGroupManagersDeleteInstancesRequestResource)
517             .get();
518     Assert.assertEquals(expectedResponse, actualResponse);
519 
520     List<String> actualRequests = mockService.getRequestPaths();
521     Assert.assertEquals(1, actualRequests.size());
522 
523     String apiClientHeaderKey =
524         mockService
525             .getRequestHeaders()
526             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
527             .iterator()
528             .next();
529     Assert.assertTrue(
530         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
531             .matcher(apiClientHeaderKey)
532             .matches());
533   }
534 
535   @Test
deleteInstancesExceptionTest()536   public void deleteInstancesExceptionTest() throws Exception {
537     ApiException exception =
538         ApiExceptionFactory.createException(
539             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
540     mockService.addException(exception);
541 
542     try {
543       String project = "project-6911";
544       String zone = "zone-5246";
545       String instanceGroupManager = "instanceGroupManager-7543";
546       InstanceGroupManagersDeleteInstancesRequest
547           instanceGroupManagersDeleteInstancesRequestResource =
548               InstanceGroupManagersDeleteInstancesRequest.newBuilder().build();
549       client
550           .deleteInstancesAsync(
551               project,
552               zone,
553               instanceGroupManager,
554               instanceGroupManagersDeleteInstancesRequestResource)
555           .get();
556       Assert.fail("No exception raised");
557     } catch (ExecutionException e) {
558     }
559   }
560 
561   @Test
deletePerInstanceConfigsTest()562   public void deletePerInstanceConfigsTest() throws Exception {
563     Operation expectedResponse =
564         Operation.newBuilder()
565             .setClientOperationId("clientOperationId-1230366697")
566             .setCreationTimestamp("creationTimestamp-370203401")
567             .setDescription("description-1724546052")
568             .setEndTime("endTime-1607243192")
569             .setError(Error.newBuilder().build())
570             .setHttpErrorMessage("httpErrorMessage1577303431")
571             .setHttpErrorStatusCode(0)
572             .setId(3355)
573             .setInsertTime("insertTime966165798")
574             .setKind("kind3292052")
575             .setName("name3373707")
576             .setOperationGroupId("operationGroupId1716161683")
577             .setOperationType("operationType91999553")
578             .setProgress(-1001078227)
579             .setRegion("region-934795532")
580             .setSelfLink("selfLink1191800166")
581             .setStartTime("startTime-2129294769")
582             .setStatus(Status.DONE)
583             .setStatusMessage("statusMessage-958704715")
584             .setTargetId(-815576439)
585             .setTargetLink("targetLink486368555")
586             .setUser("user3599307")
587             .addAllWarnings(new ArrayList<Warnings>())
588             .setZone("zone3744684")
589             .build();
590     mockService.addResponse(expectedResponse);
591 
592     String project = "project-6911";
593     String zone = "zone-5246";
594     String instanceGroupManager = "instanceGroupManager-7543";
595     InstanceGroupManagersDeletePerInstanceConfigsReq
596         instanceGroupManagersDeletePerInstanceConfigsReqResource =
597             InstanceGroupManagersDeletePerInstanceConfigsReq.newBuilder().build();
598 
599     Operation actualResponse =
600         client
601             .deletePerInstanceConfigsAsync(
602                 project,
603                 zone,
604                 instanceGroupManager,
605                 instanceGroupManagersDeletePerInstanceConfigsReqResource)
606             .get();
607     Assert.assertEquals(expectedResponse, actualResponse);
608 
609     List<String> actualRequests = mockService.getRequestPaths();
610     Assert.assertEquals(1, actualRequests.size());
611 
612     String apiClientHeaderKey =
613         mockService
614             .getRequestHeaders()
615             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
616             .iterator()
617             .next();
618     Assert.assertTrue(
619         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
620             .matcher(apiClientHeaderKey)
621             .matches());
622   }
623 
624   @Test
deletePerInstanceConfigsExceptionTest()625   public void deletePerInstanceConfigsExceptionTest() throws Exception {
626     ApiException exception =
627         ApiExceptionFactory.createException(
628             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
629     mockService.addException(exception);
630 
631     try {
632       String project = "project-6911";
633       String zone = "zone-5246";
634       String instanceGroupManager = "instanceGroupManager-7543";
635       InstanceGroupManagersDeletePerInstanceConfigsReq
636           instanceGroupManagersDeletePerInstanceConfigsReqResource =
637               InstanceGroupManagersDeletePerInstanceConfigsReq.newBuilder().build();
638       client
639           .deletePerInstanceConfigsAsync(
640               project,
641               zone,
642               instanceGroupManager,
643               instanceGroupManagersDeletePerInstanceConfigsReqResource)
644           .get();
645       Assert.fail("No exception raised");
646     } catch (ExecutionException e) {
647     }
648   }
649 
650   @Test
getTest()651   public void getTest() throws Exception {
652     InstanceGroupManager expectedResponse =
653         InstanceGroupManager.newBuilder()
654             .addAllAutoHealingPolicies(new ArrayList<InstanceGroupManagerAutoHealingPolicy>())
655             .setBaseInstanceName("baseInstanceName-736241103")
656             .setCreationTimestamp("creationTimestamp-370203401")
657             .setCurrentActions(InstanceGroupManagerActionsSummary.newBuilder().build())
658             .setDescription("description-1724546052")
659             .setDistributionPolicy(DistributionPolicy.newBuilder().build())
660             .setFingerprint("fingerprint-1375934236")
661             .setId(3355)
662             .setInstanceGroup("instanceGroup-1404696854")
663             .setInstanceTemplate("instanceTemplate1009541167")
664             .setKind("kind3292052")
665             .setListManagedInstancesResults("listManagedInstancesResults1836889817")
666             .setName("name3373707")
667             .addAllNamedPorts(new ArrayList<NamedPort>())
668             .setRegion("region-934795532")
669             .setSelfLink("selfLink1191800166")
670             .setStatefulPolicy(StatefulPolicy.newBuilder().build())
671             .setStatus(InstanceGroupManagerStatus.newBuilder().build())
672             .addAllTargetPools(new ArrayList<String>())
673             .setTargetSize(-2084603409)
674             .setUpdatePolicy(InstanceGroupManagerUpdatePolicy.newBuilder().build())
675             .addAllVersions(new ArrayList<InstanceGroupManagerVersion>())
676             .setZone("zone3744684")
677             .build();
678     mockService.addResponse(expectedResponse);
679 
680     String project = "project-6911";
681     String zone = "zone-5246";
682     String instanceGroupManager = "instanceGroupManager-7543";
683 
684     InstanceGroupManager actualResponse = client.get(project, zone, instanceGroupManager);
685     Assert.assertEquals(expectedResponse, actualResponse);
686 
687     List<String> actualRequests = mockService.getRequestPaths();
688     Assert.assertEquals(1, actualRequests.size());
689 
690     String apiClientHeaderKey =
691         mockService
692             .getRequestHeaders()
693             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
694             .iterator()
695             .next();
696     Assert.assertTrue(
697         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
698             .matcher(apiClientHeaderKey)
699             .matches());
700   }
701 
702   @Test
getExceptionTest()703   public void getExceptionTest() throws Exception {
704     ApiException exception =
705         ApiExceptionFactory.createException(
706             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
707     mockService.addException(exception);
708 
709     try {
710       String project = "project-6911";
711       String zone = "zone-5246";
712       String instanceGroupManager = "instanceGroupManager-7543";
713       client.get(project, zone, instanceGroupManager);
714       Assert.fail("No exception raised");
715     } catch (InvalidArgumentException e) {
716       // Expected exception.
717     }
718   }
719 
720   @Test
insertTest()721   public void insertTest() throws Exception {
722     Operation expectedResponse =
723         Operation.newBuilder()
724             .setClientOperationId("clientOperationId-1230366697")
725             .setCreationTimestamp("creationTimestamp-370203401")
726             .setDescription("description-1724546052")
727             .setEndTime("endTime-1607243192")
728             .setError(Error.newBuilder().build())
729             .setHttpErrorMessage("httpErrorMessage1577303431")
730             .setHttpErrorStatusCode(0)
731             .setId(3355)
732             .setInsertTime("insertTime966165798")
733             .setKind("kind3292052")
734             .setName("name3373707")
735             .setOperationGroupId("operationGroupId1716161683")
736             .setOperationType("operationType91999553")
737             .setProgress(-1001078227)
738             .setRegion("region-934795532")
739             .setSelfLink("selfLink1191800166")
740             .setStartTime("startTime-2129294769")
741             .setStatus(Status.DONE)
742             .setStatusMessage("statusMessage-958704715")
743             .setTargetId(-815576439)
744             .setTargetLink("targetLink486368555")
745             .setUser("user3599307")
746             .addAllWarnings(new ArrayList<Warnings>())
747             .setZone("zone3744684")
748             .build();
749     mockService.addResponse(expectedResponse);
750 
751     String project = "project-6911";
752     String zone = "zone-5246";
753     InstanceGroupManager instanceGroupManagerResource = InstanceGroupManager.newBuilder().build();
754 
755     Operation actualResponse =
756         client.insertAsync(project, zone, instanceGroupManagerResource).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
insertExceptionTest()775   public void insertExceptionTest() 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 zone = "zone-5246";
784       InstanceGroupManager instanceGroupManagerResource = InstanceGroupManager.newBuilder().build();
785       client.insertAsync(project, zone, instanceGroupManagerResource).get();
786       Assert.fail("No exception raised");
787     } catch (ExecutionException e) {
788     }
789   }
790 
791   @Test
listTest()792   public void listTest() throws Exception {
793     InstanceGroupManager responsesElement = InstanceGroupManager.newBuilder().build();
794     InstanceGroupManagerList expectedResponse =
795         InstanceGroupManagerList.newBuilder()
796             .setNextPageToken("")
797             .addAllItems(Arrays.asList(responsesElement))
798             .build();
799     mockService.addResponse(expectedResponse);
800 
801     String project = "project-6911";
802     String zone = "zone-5246";
803 
804     ListPagedResponse pagedListResponse = client.list(project, zone);
805 
806     List<InstanceGroupManager> resources = Lists.newArrayList(pagedListResponse.iterateAll());
807 
808     Assert.assertEquals(1, resources.size());
809     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
810 
811     List<String> actualRequests = mockService.getRequestPaths();
812     Assert.assertEquals(1, actualRequests.size());
813 
814     String apiClientHeaderKey =
815         mockService
816             .getRequestHeaders()
817             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
818             .iterator()
819             .next();
820     Assert.assertTrue(
821         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
822             .matcher(apiClientHeaderKey)
823             .matches());
824   }
825 
826   @Test
listExceptionTest()827   public void listExceptionTest() throws Exception {
828     ApiException exception =
829         ApiExceptionFactory.createException(
830             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
831     mockService.addException(exception);
832 
833     try {
834       String project = "project-6911";
835       String zone = "zone-5246";
836       client.list(project, zone);
837       Assert.fail("No exception raised");
838     } catch (InvalidArgumentException e) {
839       // Expected exception.
840     }
841   }
842 
843   @Test
listErrorsTest()844   public void listErrorsTest() throws Exception {
845     InstanceManagedByIgmError responsesElement = InstanceManagedByIgmError.newBuilder().build();
846     InstanceGroupManagersListErrorsResponse expectedResponse =
847         InstanceGroupManagersListErrorsResponse.newBuilder()
848             .setNextPageToken("")
849             .addAllItems(Arrays.asList(responsesElement))
850             .build();
851     mockService.addResponse(expectedResponse);
852 
853     String project = "project-6911";
854     String zone = "zone-5246";
855     String instanceGroupManager = "instanceGroupManager-7543";
856 
857     ListErrorsPagedResponse pagedListResponse =
858         client.listErrors(project, zone, instanceGroupManager);
859 
860     List<InstanceManagedByIgmError> resources = Lists.newArrayList(pagedListResponse.iterateAll());
861 
862     Assert.assertEquals(1, resources.size());
863     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
864 
865     List<String> actualRequests = mockService.getRequestPaths();
866     Assert.assertEquals(1, actualRequests.size());
867 
868     String apiClientHeaderKey =
869         mockService
870             .getRequestHeaders()
871             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
872             .iterator()
873             .next();
874     Assert.assertTrue(
875         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
876             .matcher(apiClientHeaderKey)
877             .matches());
878   }
879 
880   @Test
listErrorsExceptionTest()881   public void listErrorsExceptionTest() throws Exception {
882     ApiException exception =
883         ApiExceptionFactory.createException(
884             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
885     mockService.addException(exception);
886 
887     try {
888       String project = "project-6911";
889       String zone = "zone-5246";
890       String instanceGroupManager = "instanceGroupManager-7543";
891       client.listErrors(project, zone, instanceGroupManager);
892       Assert.fail("No exception raised");
893     } catch (InvalidArgumentException e) {
894       // Expected exception.
895     }
896   }
897 
898   @Test
listManagedInstancesTest()899   public void listManagedInstancesTest() throws Exception {
900     ManagedInstance responsesElement = ManagedInstance.newBuilder().build();
901     InstanceGroupManagersListManagedInstancesResponse expectedResponse =
902         InstanceGroupManagersListManagedInstancesResponse.newBuilder()
903             .setNextPageToken("")
904             .addAllManagedInstances(Arrays.asList(responsesElement))
905             .build();
906     mockService.addResponse(expectedResponse);
907 
908     String project = "project-6911";
909     String zone = "zone-5246";
910     String instanceGroupManager = "instanceGroupManager-7543";
911 
912     ListManagedInstancesPagedResponse pagedListResponse =
913         client.listManagedInstances(project, zone, instanceGroupManager);
914 
915     List<ManagedInstance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
916 
917     Assert.assertEquals(1, resources.size());
918     Assert.assertEquals(expectedResponse.getManagedInstancesList().get(0), resources.get(0));
919 
920     List<String> actualRequests = mockService.getRequestPaths();
921     Assert.assertEquals(1, actualRequests.size());
922 
923     String apiClientHeaderKey =
924         mockService
925             .getRequestHeaders()
926             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
927             .iterator()
928             .next();
929     Assert.assertTrue(
930         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
931             .matcher(apiClientHeaderKey)
932             .matches());
933   }
934 
935   @Test
listManagedInstancesExceptionTest()936   public void listManagedInstancesExceptionTest() throws Exception {
937     ApiException exception =
938         ApiExceptionFactory.createException(
939             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
940     mockService.addException(exception);
941 
942     try {
943       String project = "project-6911";
944       String zone = "zone-5246";
945       String instanceGroupManager = "instanceGroupManager-7543";
946       client.listManagedInstances(project, zone, instanceGroupManager);
947       Assert.fail("No exception raised");
948     } catch (InvalidArgumentException e) {
949       // Expected exception.
950     }
951   }
952 
953   @Test
listPerInstanceConfigsTest()954   public void listPerInstanceConfigsTest() throws Exception {
955     PerInstanceConfig responsesElement = PerInstanceConfig.newBuilder().build();
956     InstanceGroupManagersListPerInstanceConfigsResp expectedResponse =
957         InstanceGroupManagersListPerInstanceConfigsResp.newBuilder()
958             .setNextPageToken("")
959             .addAllItems(Arrays.asList(responsesElement))
960             .build();
961     mockService.addResponse(expectedResponse);
962 
963     String project = "project-6911";
964     String zone = "zone-5246";
965     String instanceGroupManager = "instanceGroupManager-7543";
966 
967     ListPerInstanceConfigsPagedResponse pagedListResponse =
968         client.listPerInstanceConfigs(project, zone, instanceGroupManager);
969 
970     List<PerInstanceConfig> resources = Lists.newArrayList(pagedListResponse.iterateAll());
971 
972     Assert.assertEquals(1, resources.size());
973     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
974 
975     List<String> actualRequests = mockService.getRequestPaths();
976     Assert.assertEquals(1, actualRequests.size());
977 
978     String apiClientHeaderKey =
979         mockService
980             .getRequestHeaders()
981             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
982             .iterator()
983             .next();
984     Assert.assertTrue(
985         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
986             .matcher(apiClientHeaderKey)
987             .matches());
988   }
989 
990   @Test
listPerInstanceConfigsExceptionTest()991   public void listPerInstanceConfigsExceptionTest() throws Exception {
992     ApiException exception =
993         ApiExceptionFactory.createException(
994             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
995     mockService.addException(exception);
996 
997     try {
998       String project = "project-6911";
999       String zone = "zone-5246";
1000       String instanceGroupManager = "instanceGroupManager-7543";
1001       client.listPerInstanceConfigs(project, zone, instanceGroupManager);
1002       Assert.fail("No exception raised");
1003     } catch (InvalidArgumentException e) {
1004       // Expected exception.
1005     }
1006   }
1007 
1008   @Test
patchTest()1009   public void patchTest() throws Exception {
1010     Operation expectedResponse =
1011         Operation.newBuilder()
1012             .setClientOperationId("clientOperationId-1230366697")
1013             .setCreationTimestamp("creationTimestamp-370203401")
1014             .setDescription("description-1724546052")
1015             .setEndTime("endTime-1607243192")
1016             .setError(Error.newBuilder().build())
1017             .setHttpErrorMessage("httpErrorMessage1577303431")
1018             .setHttpErrorStatusCode(0)
1019             .setId(3355)
1020             .setInsertTime("insertTime966165798")
1021             .setKind("kind3292052")
1022             .setName("name3373707")
1023             .setOperationGroupId("operationGroupId1716161683")
1024             .setOperationType("operationType91999553")
1025             .setProgress(-1001078227)
1026             .setRegion("region-934795532")
1027             .setSelfLink("selfLink1191800166")
1028             .setStartTime("startTime-2129294769")
1029             .setStatus(Status.DONE)
1030             .setStatusMessage("statusMessage-958704715")
1031             .setTargetId(-815576439)
1032             .setTargetLink("targetLink486368555")
1033             .setUser("user3599307")
1034             .addAllWarnings(new ArrayList<Warnings>())
1035             .setZone("zone3744684")
1036             .build();
1037     mockService.addResponse(expectedResponse);
1038 
1039     String project = "project-6911";
1040     String zone = "zone-5246";
1041     String instanceGroupManager = "instanceGroupManager-7543";
1042     InstanceGroupManager instanceGroupManagerResource = InstanceGroupManager.newBuilder().build();
1043 
1044     Operation actualResponse =
1045         client.patchAsync(project, zone, instanceGroupManager, instanceGroupManagerResource).get();
1046     Assert.assertEquals(expectedResponse, actualResponse);
1047 
1048     List<String> actualRequests = mockService.getRequestPaths();
1049     Assert.assertEquals(1, actualRequests.size());
1050 
1051     String apiClientHeaderKey =
1052         mockService
1053             .getRequestHeaders()
1054             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1055             .iterator()
1056             .next();
1057     Assert.assertTrue(
1058         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1059             .matcher(apiClientHeaderKey)
1060             .matches());
1061   }
1062 
1063   @Test
patchExceptionTest()1064   public void patchExceptionTest() throws Exception {
1065     ApiException exception =
1066         ApiExceptionFactory.createException(
1067             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1068     mockService.addException(exception);
1069 
1070     try {
1071       String project = "project-6911";
1072       String zone = "zone-5246";
1073       String instanceGroupManager = "instanceGroupManager-7543";
1074       InstanceGroupManager instanceGroupManagerResource = InstanceGroupManager.newBuilder().build();
1075       client.patchAsync(project, zone, instanceGroupManager, instanceGroupManagerResource).get();
1076       Assert.fail("No exception raised");
1077     } catch (ExecutionException e) {
1078     }
1079   }
1080 
1081   @Test
patchPerInstanceConfigsTest()1082   public void patchPerInstanceConfigsTest() throws Exception {
1083     Operation expectedResponse =
1084         Operation.newBuilder()
1085             .setClientOperationId("clientOperationId-1230366697")
1086             .setCreationTimestamp("creationTimestamp-370203401")
1087             .setDescription("description-1724546052")
1088             .setEndTime("endTime-1607243192")
1089             .setError(Error.newBuilder().build())
1090             .setHttpErrorMessage("httpErrorMessage1577303431")
1091             .setHttpErrorStatusCode(0)
1092             .setId(3355)
1093             .setInsertTime("insertTime966165798")
1094             .setKind("kind3292052")
1095             .setName("name3373707")
1096             .setOperationGroupId("operationGroupId1716161683")
1097             .setOperationType("operationType91999553")
1098             .setProgress(-1001078227)
1099             .setRegion("region-934795532")
1100             .setSelfLink("selfLink1191800166")
1101             .setStartTime("startTime-2129294769")
1102             .setStatus(Status.DONE)
1103             .setStatusMessage("statusMessage-958704715")
1104             .setTargetId(-815576439)
1105             .setTargetLink("targetLink486368555")
1106             .setUser("user3599307")
1107             .addAllWarnings(new ArrayList<Warnings>())
1108             .setZone("zone3744684")
1109             .build();
1110     mockService.addResponse(expectedResponse);
1111 
1112     String project = "project-6911";
1113     String zone = "zone-5246";
1114     String instanceGroupManager = "instanceGroupManager-7543";
1115     InstanceGroupManagersPatchPerInstanceConfigsReq
1116         instanceGroupManagersPatchPerInstanceConfigsReqResource =
1117             InstanceGroupManagersPatchPerInstanceConfigsReq.newBuilder().build();
1118 
1119     Operation actualResponse =
1120         client
1121             .patchPerInstanceConfigsAsync(
1122                 project,
1123                 zone,
1124                 instanceGroupManager,
1125                 instanceGroupManagersPatchPerInstanceConfigsReqResource)
1126             .get();
1127     Assert.assertEquals(expectedResponse, actualResponse);
1128 
1129     List<String> actualRequests = mockService.getRequestPaths();
1130     Assert.assertEquals(1, actualRequests.size());
1131 
1132     String apiClientHeaderKey =
1133         mockService
1134             .getRequestHeaders()
1135             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1136             .iterator()
1137             .next();
1138     Assert.assertTrue(
1139         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1140             .matcher(apiClientHeaderKey)
1141             .matches());
1142   }
1143 
1144   @Test
patchPerInstanceConfigsExceptionTest()1145   public void patchPerInstanceConfigsExceptionTest() throws Exception {
1146     ApiException exception =
1147         ApiExceptionFactory.createException(
1148             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1149     mockService.addException(exception);
1150 
1151     try {
1152       String project = "project-6911";
1153       String zone = "zone-5246";
1154       String instanceGroupManager = "instanceGroupManager-7543";
1155       InstanceGroupManagersPatchPerInstanceConfigsReq
1156           instanceGroupManagersPatchPerInstanceConfigsReqResource =
1157               InstanceGroupManagersPatchPerInstanceConfigsReq.newBuilder().build();
1158       client
1159           .patchPerInstanceConfigsAsync(
1160               project,
1161               zone,
1162               instanceGroupManager,
1163               instanceGroupManagersPatchPerInstanceConfigsReqResource)
1164           .get();
1165       Assert.fail("No exception raised");
1166     } catch (ExecutionException e) {
1167     }
1168   }
1169 
1170   @Test
recreateInstancesTest()1171   public void recreateInstancesTest() throws Exception {
1172     Operation expectedResponse =
1173         Operation.newBuilder()
1174             .setClientOperationId("clientOperationId-1230366697")
1175             .setCreationTimestamp("creationTimestamp-370203401")
1176             .setDescription("description-1724546052")
1177             .setEndTime("endTime-1607243192")
1178             .setError(Error.newBuilder().build())
1179             .setHttpErrorMessage("httpErrorMessage1577303431")
1180             .setHttpErrorStatusCode(0)
1181             .setId(3355)
1182             .setInsertTime("insertTime966165798")
1183             .setKind("kind3292052")
1184             .setName("name3373707")
1185             .setOperationGroupId("operationGroupId1716161683")
1186             .setOperationType("operationType91999553")
1187             .setProgress(-1001078227)
1188             .setRegion("region-934795532")
1189             .setSelfLink("selfLink1191800166")
1190             .setStartTime("startTime-2129294769")
1191             .setStatus(Status.DONE)
1192             .setStatusMessage("statusMessage-958704715")
1193             .setTargetId(-815576439)
1194             .setTargetLink("targetLink486368555")
1195             .setUser("user3599307")
1196             .addAllWarnings(new ArrayList<Warnings>())
1197             .setZone("zone3744684")
1198             .build();
1199     mockService.addResponse(expectedResponse);
1200 
1201     String project = "project-6911";
1202     String zone = "zone-5246";
1203     String instanceGroupManager = "instanceGroupManager-7543";
1204     InstanceGroupManagersRecreateInstancesRequest
1205         instanceGroupManagersRecreateInstancesRequestResource =
1206             InstanceGroupManagersRecreateInstancesRequest.newBuilder().build();
1207 
1208     Operation actualResponse =
1209         client
1210             .recreateInstancesAsync(
1211                 project,
1212                 zone,
1213                 instanceGroupManager,
1214                 instanceGroupManagersRecreateInstancesRequestResource)
1215             .get();
1216     Assert.assertEquals(expectedResponse, actualResponse);
1217 
1218     List<String> actualRequests = mockService.getRequestPaths();
1219     Assert.assertEquals(1, actualRequests.size());
1220 
1221     String apiClientHeaderKey =
1222         mockService
1223             .getRequestHeaders()
1224             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1225             .iterator()
1226             .next();
1227     Assert.assertTrue(
1228         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1229             .matcher(apiClientHeaderKey)
1230             .matches());
1231   }
1232 
1233   @Test
recreateInstancesExceptionTest()1234   public void recreateInstancesExceptionTest() throws Exception {
1235     ApiException exception =
1236         ApiExceptionFactory.createException(
1237             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1238     mockService.addException(exception);
1239 
1240     try {
1241       String project = "project-6911";
1242       String zone = "zone-5246";
1243       String instanceGroupManager = "instanceGroupManager-7543";
1244       InstanceGroupManagersRecreateInstancesRequest
1245           instanceGroupManagersRecreateInstancesRequestResource =
1246               InstanceGroupManagersRecreateInstancesRequest.newBuilder().build();
1247       client
1248           .recreateInstancesAsync(
1249               project,
1250               zone,
1251               instanceGroupManager,
1252               instanceGroupManagersRecreateInstancesRequestResource)
1253           .get();
1254       Assert.fail("No exception raised");
1255     } catch (ExecutionException e) {
1256     }
1257   }
1258 
1259   @Test
resizeTest()1260   public void resizeTest() throws Exception {
1261     Operation expectedResponse =
1262         Operation.newBuilder()
1263             .setClientOperationId("clientOperationId-1230366697")
1264             .setCreationTimestamp("creationTimestamp-370203401")
1265             .setDescription("description-1724546052")
1266             .setEndTime("endTime-1607243192")
1267             .setError(Error.newBuilder().build())
1268             .setHttpErrorMessage("httpErrorMessage1577303431")
1269             .setHttpErrorStatusCode(0)
1270             .setId(3355)
1271             .setInsertTime("insertTime966165798")
1272             .setKind("kind3292052")
1273             .setName("name3373707")
1274             .setOperationGroupId("operationGroupId1716161683")
1275             .setOperationType("operationType91999553")
1276             .setProgress(-1001078227)
1277             .setRegion("region-934795532")
1278             .setSelfLink("selfLink1191800166")
1279             .setStartTime("startTime-2129294769")
1280             .setStatus(Status.DONE)
1281             .setStatusMessage("statusMessage-958704715")
1282             .setTargetId(-815576439)
1283             .setTargetLink("targetLink486368555")
1284             .setUser("user3599307")
1285             .addAllWarnings(new ArrayList<Warnings>())
1286             .setZone("zone3744684")
1287             .build();
1288     mockService.addResponse(expectedResponse);
1289 
1290     String project = "project-6911";
1291     String zone = "zone-5246";
1292     String instanceGroupManager = "instanceGroupManager-7543";
1293     int size = 3530753;
1294 
1295     Operation actualResponse = client.resizeAsync(project, zone, instanceGroupManager, size).get();
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
resizeExceptionTest()1314   public void resizeExceptionTest() 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 project = "project-6911";
1322       String zone = "zone-5246";
1323       String instanceGroupManager = "instanceGroupManager-7543";
1324       int size = 3530753;
1325       client.resizeAsync(project, zone, instanceGroupManager, size).get();
1326       Assert.fail("No exception raised");
1327     } catch (ExecutionException e) {
1328     }
1329   }
1330 
1331   @Test
setInstanceTemplateTest()1332   public void setInstanceTemplateTest() throws Exception {
1333     Operation expectedResponse =
1334         Operation.newBuilder()
1335             .setClientOperationId("clientOperationId-1230366697")
1336             .setCreationTimestamp("creationTimestamp-370203401")
1337             .setDescription("description-1724546052")
1338             .setEndTime("endTime-1607243192")
1339             .setError(Error.newBuilder().build())
1340             .setHttpErrorMessage("httpErrorMessage1577303431")
1341             .setHttpErrorStatusCode(0)
1342             .setId(3355)
1343             .setInsertTime("insertTime966165798")
1344             .setKind("kind3292052")
1345             .setName("name3373707")
1346             .setOperationGroupId("operationGroupId1716161683")
1347             .setOperationType("operationType91999553")
1348             .setProgress(-1001078227)
1349             .setRegion("region-934795532")
1350             .setSelfLink("selfLink1191800166")
1351             .setStartTime("startTime-2129294769")
1352             .setStatus(Status.DONE)
1353             .setStatusMessage("statusMessage-958704715")
1354             .setTargetId(-815576439)
1355             .setTargetLink("targetLink486368555")
1356             .setUser("user3599307")
1357             .addAllWarnings(new ArrayList<Warnings>())
1358             .setZone("zone3744684")
1359             .build();
1360     mockService.addResponse(expectedResponse);
1361 
1362     String project = "project-6911";
1363     String zone = "zone-5246";
1364     String instanceGroupManager = "instanceGroupManager-7543";
1365     InstanceGroupManagersSetInstanceTemplateRequest
1366         instanceGroupManagersSetInstanceTemplateRequestResource =
1367             InstanceGroupManagersSetInstanceTemplateRequest.newBuilder().build();
1368 
1369     Operation actualResponse =
1370         client
1371             .setInstanceTemplateAsync(
1372                 project,
1373                 zone,
1374                 instanceGroupManager,
1375                 instanceGroupManagersSetInstanceTemplateRequestResource)
1376             .get();
1377     Assert.assertEquals(expectedResponse, actualResponse);
1378 
1379     List<String> actualRequests = mockService.getRequestPaths();
1380     Assert.assertEquals(1, actualRequests.size());
1381 
1382     String apiClientHeaderKey =
1383         mockService
1384             .getRequestHeaders()
1385             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1386             .iterator()
1387             .next();
1388     Assert.assertTrue(
1389         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1390             .matcher(apiClientHeaderKey)
1391             .matches());
1392   }
1393 
1394   @Test
setInstanceTemplateExceptionTest()1395   public void setInstanceTemplateExceptionTest() throws Exception {
1396     ApiException exception =
1397         ApiExceptionFactory.createException(
1398             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1399     mockService.addException(exception);
1400 
1401     try {
1402       String project = "project-6911";
1403       String zone = "zone-5246";
1404       String instanceGroupManager = "instanceGroupManager-7543";
1405       InstanceGroupManagersSetInstanceTemplateRequest
1406           instanceGroupManagersSetInstanceTemplateRequestResource =
1407               InstanceGroupManagersSetInstanceTemplateRequest.newBuilder().build();
1408       client
1409           .setInstanceTemplateAsync(
1410               project,
1411               zone,
1412               instanceGroupManager,
1413               instanceGroupManagersSetInstanceTemplateRequestResource)
1414           .get();
1415       Assert.fail("No exception raised");
1416     } catch (ExecutionException e) {
1417     }
1418   }
1419 
1420   @Test
setTargetPoolsTest()1421   public void setTargetPoolsTest() throws Exception {
1422     Operation expectedResponse =
1423         Operation.newBuilder()
1424             .setClientOperationId("clientOperationId-1230366697")
1425             .setCreationTimestamp("creationTimestamp-370203401")
1426             .setDescription("description-1724546052")
1427             .setEndTime("endTime-1607243192")
1428             .setError(Error.newBuilder().build())
1429             .setHttpErrorMessage("httpErrorMessage1577303431")
1430             .setHttpErrorStatusCode(0)
1431             .setId(3355)
1432             .setInsertTime("insertTime966165798")
1433             .setKind("kind3292052")
1434             .setName("name3373707")
1435             .setOperationGroupId("operationGroupId1716161683")
1436             .setOperationType("operationType91999553")
1437             .setProgress(-1001078227)
1438             .setRegion("region-934795532")
1439             .setSelfLink("selfLink1191800166")
1440             .setStartTime("startTime-2129294769")
1441             .setStatus(Status.DONE)
1442             .setStatusMessage("statusMessage-958704715")
1443             .setTargetId(-815576439)
1444             .setTargetLink("targetLink486368555")
1445             .setUser("user3599307")
1446             .addAllWarnings(new ArrayList<Warnings>())
1447             .setZone("zone3744684")
1448             .build();
1449     mockService.addResponse(expectedResponse);
1450 
1451     String project = "project-6911";
1452     String zone = "zone-5246";
1453     String instanceGroupManager = "instanceGroupManager-7543";
1454     InstanceGroupManagersSetTargetPoolsRequest instanceGroupManagersSetTargetPoolsRequestResource =
1455         InstanceGroupManagersSetTargetPoolsRequest.newBuilder().build();
1456 
1457     Operation actualResponse =
1458         client
1459             .setTargetPoolsAsync(
1460                 project,
1461                 zone,
1462                 instanceGroupManager,
1463                 instanceGroupManagersSetTargetPoolsRequestResource)
1464             .get();
1465     Assert.assertEquals(expectedResponse, actualResponse);
1466 
1467     List<String> actualRequests = mockService.getRequestPaths();
1468     Assert.assertEquals(1, actualRequests.size());
1469 
1470     String apiClientHeaderKey =
1471         mockService
1472             .getRequestHeaders()
1473             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1474             .iterator()
1475             .next();
1476     Assert.assertTrue(
1477         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1478             .matcher(apiClientHeaderKey)
1479             .matches());
1480   }
1481 
1482   @Test
setTargetPoolsExceptionTest()1483   public void setTargetPoolsExceptionTest() throws Exception {
1484     ApiException exception =
1485         ApiExceptionFactory.createException(
1486             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1487     mockService.addException(exception);
1488 
1489     try {
1490       String project = "project-6911";
1491       String zone = "zone-5246";
1492       String instanceGroupManager = "instanceGroupManager-7543";
1493       InstanceGroupManagersSetTargetPoolsRequest
1494           instanceGroupManagersSetTargetPoolsRequestResource =
1495               InstanceGroupManagersSetTargetPoolsRequest.newBuilder().build();
1496       client
1497           .setTargetPoolsAsync(
1498               project,
1499               zone,
1500               instanceGroupManager,
1501               instanceGroupManagersSetTargetPoolsRequestResource)
1502           .get();
1503       Assert.fail("No exception raised");
1504     } catch (ExecutionException e) {
1505     }
1506   }
1507 
1508   @Test
updatePerInstanceConfigsTest()1509   public void updatePerInstanceConfigsTest() throws Exception {
1510     Operation expectedResponse =
1511         Operation.newBuilder()
1512             .setClientOperationId("clientOperationId-1230366697")
1513             .setCreationTimestamp("creationTimestamp-370203401")
1514             .setDescription("description-1724546052")
1515             .setEndTime("endTime-1607243192")
1516             .setError(Error.newBuilder().build())
1517             .setHttpErrorMessage("httpErrorMessage1577303431")
1518             .setHttpErrorStatusCode(0)
1519             .setId(3355)
1520             .setInsertTime("insertTime966165798")
1521             .setKind("kind3292052")
1522             .setName("name3373707")
1523             .setOperationGroupId("operationGroupId1716161683")
1524             .setOperationType("operationType91999553")
1525             .setProgress(-1001078227)
1526             .setRegion("region-934795532")
1527             .setSelfLink("selfLink1191800166")
1528             .setStartTime("startTime-2129294769")
1529             .setStatus(Status.DONE)
1530             .setStatusMessage("statusMessage-958704715")
1531             .setTargetId(-815576439)
1532             .setTargetLink("targetLink486368555")
1533             .setUser("user3599307")
1534             .addAllWarnings(new ArrayList<Warnings>())
1535             .setZone("zone3744684")
1536             .build();
1537     mockService.addResponse(expectedResponse);
1538 
1539     String project = "project-6911";
1540     String zone = "zone-5246";
1541     String instanceGroupManager = "instanceGroupManager-7543";
1542     InstanceGroupManagersUpdatePerInstanceConfigsReq
1543         instanceGroupManagersUpdatePerInstanceConfigsReqResource =
1544             InstanceGroupManagersUpdatePerInstanceConfigsReq.newBuilder().build();
1545 
1546     Operation actualResponse =
1547         client
1548             .updatePerInstanceConfigsAsync(
1549                 project,
1550                 zone,
1551                 instanceGroupManager,
1552                 instanceGroupManagersUpdatePerInstanceConfigsReqResource)
1553             .get();
1554     Assert.assertEquals(expectedResponse, actualResponse);
1555 
1556     List<String> actualRequests = mockService.getRequestPaths();
1557     Assert.assertEquals(1, actualRequests.size());
1558 
1559     String apiClientHeaderKey =
1560         mockService
1561             .getRequestHeaders()
1562             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1563             .iterator()
1564             .next();
1565     Assert.assertTrue(
1566         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1567             .matcher(apiClientHeaderKey)
1568             .matches());
1569   }
1570 
1571   @Test
updatePerInstanceConfigsExceptionTest()1572   public void updatePerInstanceConfigsExceptionTest() throws Exception {
1573     ApiException exception =
1574         ApiExceptionFactory.createException(
1575             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1576     mockService.addException(exception);
1577 
1578     try {
1579       String project = "project-6911";
1580       String zone = "zone-5246";
1581       String instanceGroupManager = "instanceGroupManager-7543";
1582       InstanceGroupManagersUpdatePerInstanceConfigsReq
1583           instanceGroupManagersUpdatePerInstanceConfigsReqResource =
1584               InstanceGroupManagersUpdatePerInstanceConfigsReq.newBuilder().build();
1585       client
1586           .updatePerInstanceConfigsAsync(
1587               project,
1588               zone,
1589               instanceGroupManager,
1590               instanceGroupManagersUpdatePerInstanceConfigsReqResource)
1591           .get();
1592       Assert.fail("No exception raised");
1593     } catch (ExecutionException e) {
1594     }
1595   }
1596 }
1597