• 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.TargetPoolsClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.TargetPoolsClient.ListPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.cloud.compute.v1.Operation.Status;
32 import com.google.cloud.compute.v1.stub.HttpJsonTargetPoolsStub;
33 import com.google.common.collect.Lists;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.Collections;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.concurrent.ExecutionException;
41 import javax.annotation.Generated;
42 import org.junit.After;
43 import org.junit.AfterClass;
44 import org.junit.Assert;
45 import org.junit.Before;
46 import org.junit.BeforeClass;
47 import org.junit.Test;
48 
49 @Generated("by gapic-generator-java")
50 public class TargetPoolsClientTest {
51   private static MockHttpService mockService;
52   private static TargetPoolsClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonTargetPoolsStub.getMethodDescriptors(),
59             TargetPoolsSettings.getDefaultEndpoint());
60     TargetPoolsSettings settings =
61         TargetPoolsSettings.newBuilder()
62             .setTransportChannelProvider(
63                 TargetPoolsSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = TargetPoolsClient.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
addHealthCheckTest()85   public void addHealthCheckTest() 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 region = "region-9622";
117     String targetPool = "targetPool-115";
118     TargetPoolsAddHealthCheckRequest targetPoolsAddHealthCheckRequestResource =
119         TargetPoolsAddHealthCheckRequest.newBuilder().build();
120 
121     Operation actualResponse =
122         client
123             .addHealthCheckAsync(
124                 project, region, targetPool, targetPoolsAddHealthCheckRequestResource)
125             .get();
126     Assert.assertEquals(expectedResponse, actualResponse);
127 
128     List<String> actualRequests = mockService.getRequestPaths();
129     Assert.assertEquals(1, actualRequests.size());
130 
131     String apiClientHeaderKey =
132         mockService
133             .getRequestHeaders()
134             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
135             .iterator()
136             .next();
137     Assert.assertTrue(
138         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
139             .matcher(apiClientHeaderKey)
140             .matches());
141   }
142 
143   @Test
addHealthCheckExceptionTest()144   public void addHealthCheckExceptionTest() throws Exception {
145     ApiException exception =
146         ApiExceptionFactory.createException(
147             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
148     mockService.addException(exception);
149 
150     try {
151       String project = "project-6911";
152       String region = "region-9622";
153       String targetPool = "targetPool-115";
154       TargetPoolsAddHealthCheckRequest targetPoolsAddHealthCheckRequestResource =
155           TargetPoolsAddHealthCheckRequest.newBuilder().build();
156       client
157           .addHealthCheckAsync(
158               project, region, targetPool, targetPoolsAddHealthCheckRequestResource)
159           .get();
160       Assert.fail("No exception raised");
161     } catch (ExecutionException e) {
162     }
163   }
164 
165   @Test
addInstanceTest()166   public void addInstanceTest() throws Exception {
167     Operation expectedResponse =
168         Operation.newBuilder()
169             .setClientOperationId("clientOperationId-1230366697")
170             .setCreationTimestamp("creationTimestamp-370203401")
171             .setDescription("description-1724546052")
172             .setEndTime("endTime-1607243192")
173             .setError(Error.newBuilder().build())
174             .setHttpErrorMessage("httpErrorMessage1577303431")
175             .setHttpErrorStatusCode(0)
176             .setId(3355)
177             .setInsertTime("insertTime966165798")
178             .setKind("kind3292052")
179             .setName("name3373707")
180             .setOperationGroupId("operationGroupId1716161683")
181             .setOperationType("operationType91999553")
182             .setProgress(-1001078227)
183             .setRegion("region-934795532")
184             .setSelfLink("selfLink1191800166")
185             .setStartTime("startTime-2129294769")
186             .setStatus(Status.DONE)
187             .setStatusMessage("statusMessage-958704715")
188             .setTargetId(-815576439)
189             .setTargetLink("targetLink486368555")
190             .setUser("user3599307")
191             .addAllWarnings(new ArrayList<Warnings>())
192             .setZone("zone3744684")
193             .build();
194     mockService.addResponse(expectedResponse);
195 
196     String project = "project-6911";
197     String region = "region-9622";
198     String targetPool = "targetPool-115";
199     TargetPoolsAddInstanceRequest targetPoolsAddInstanceRequestResource =
200         TargetPoolsAddInstanceRequest.newBuilder().build();
201 
202     Operation actualResponse =
203         client
204             .addInstanceAsync(project, region, targetPool, targetPoolsAddInstanceRequestResource)
205             .get();
206     Assert.assertEquals(expectedResponse, actualResponse);
207 
208     List<String> actualRequests = mockService.getRequestPaths();
209     Assert.assertEquals(1, actualRequests.size());
210 
211     String apiClientHeaderKey =
212         mockService
213             .getRequestHeaders()
214             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
215             .iterator()
216             .next();
217     Assert.assertTrue(
218         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
219             .matcher(apiClientHeaderKey)
220             .matches());
221   }
222 
223   @Test
addInstanceExceptionTest()224   public void addInstanceExceptionTest() throws Exception {
225     ApiException exception =
226         ApiExceptionFactory.createException(
227             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
228     mockService.addException(exception);
229 
230     try {
231       String project = "project-6911";
232       String region = "region-9622";
233       String targetPool = "targetPool-115";
234       TargetPoolsAddInstanceRequest targetPoolsAddInstanceRequestResource =
235           TargetPoolsAddInstanceRequest.newBuilder().build();
236       client
237           .addInstanceAsync(project, region, targetPool, targetPoolsAddInstanceRequestResource)
238           .get();
239       Assert.fail("No exception raised");
240     } catch (ExecutionException e) {
241     }
242   }
243 
244   @Test
aggregatedListTest()245   public void aggregatedListTest() throws Exception {
246     TargetPoolsScopedList responsesElement = TargetPoolsScopedList.newBuilder().build();
247     TargetPoolAggregatedList expectedResponse =
248         TargetPoolAggregatedList.newBuilder()
249             .setNextPageToken("")
250             .putAllItems(Collections.singletonMap("items", responsesElement))
251             .build();
252     mockService.addResponse(expectedResponse);
253 
254     String project = "project-6911";
255 
256     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
257 
258     List<Map.Entry<String, TargetPoolsScopedList>> resources =
259         Lists.newArrayList(pagedListResponse.iterateAll());
260 
261     Assert.assertEquals(1, resources.size());
262     Assert.assertEquals(
263         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
264 
265     List<String> actualRequests = mockService.getRequestPaths();
266     Assert.assertEquals(1, actualRequests.size());
267 
268     String apiClientHeaderKey =
269         mockService
270             .getRequestHeaders()
271             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
272             .iterator()
273             .next();
274     Assert.assertTrue(
275         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
276             .matcher(apiClientHeaderKey)
277             .matches());
278   }
279 
280   @Test
aggregatedListExceptionTest()281   public void aggregatedListExceptionTest() throws Exception {
282     ApiException exception =
283         ApiExceptionFactory.createException(
284             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
285     mockService.addException(exception);
286 
287     try {
288       String project = "project-6911";
289       client.aggregatedList(project);
290       Assert.fail("No exception raised");
291     } catch (InvalidArgumentException e) {
292       // Expected exception.
293     }
294   }
295 
296   @Test
deleteTest()297   public void deleteTest() throws Exception {
298     Operation expectedResponse =
299         Operation.newBuilder()
300             .setClientOperationId("clientOperationId-1230366697")
301             .setCreationTimestamp("creationTimestamp-370203401")
302             .setDescription("description-1724546052")
303             .setEndTime("endTime-1607243192")
304             .setError(Error.newBuilder().build())
305             .setHttpErrorMessage("httpErrorMessage1577303431")
306             .setHttpErrorStatusCode(0)
307             .setId(3355)
308             .setInsertTime("insertTime966165798")
309             .setKind("kind3292052")
310             .setName("name3373707")
311             .setOperationGroupId("operationGroupId1716161683")
312             .setOperationType("operationType91999553")
313             .setProgress(-1001078227)
314             .setRegion("region-934795532")
315             .setSelfLink("selfLink1191800166")
316             .setStartTime("startTime-2129294769")
317             .setStatus(Status.DONE)
318             .setStatusMessage("statusMessage-958704715")
319             .setTargetId(-815576439)
320             .setTargetLink("targetLink486368555")
321             .setUser("user3599307")
322             .addAllWarnings(new ArrayList<Warnings>())
323             .setZone("zone3744684")
324             .build();
325     mockService.addResponse(expectedResponse);
326 
327     String project = "project-6911";
328     String region = "region-9622";
329     String targetPool = "targetPool-115";
330 
331     Operation actualResponse = client.deleteAsync(project, region, targetPool).get();
332     Assert.assertEquals(expectedResponse, actualResponse);
333 
334     List<String> actualRequests = mockService.getRequestPaths();
335     Assert.assertEquals(1, actualRequests.size());
336 
337     String apiClientHeaderKey =
338         mockService
339             .getRequestHeaders()
340             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
341             .iterator()
342             .next();
343     Assert.assertTrue(
344         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
345             .matcher(apiClientHeaderKey)
346             .matches());
347   }
348 
349   @Test
deleteExceptionTest()350   public void deleteExceptionTest() throws Exception {
351     ApiException exception =
352         ApiExceptionFactory.createException(
353             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
354     mockService.addException(exception);
355 
356     try {
357       String project = "project-6911";
358       String region = "region-9622";
359       String targetPool = "targetPool-115";
360       client.deleteAsync(project, region, targetPool).get();
361       Assert.fail("No exception raised");
362     } catch (ExecutionException e) {
363     }
364   }
365 
366   @Test
getTest()367   public void getTest() throws Exception {
368     TargetPool expectedResponse =
369         TargetPool.newBuilder()
370             .setBackupPool("backupPool-934162178")
371             .setCreationTimestamp("creationTimestamp-370203401")
372             .setDescription("description-1724546052")
373             .setFailoverRatio(-861074818)
374             .addAllHealthChecks(new ArrayList<String>())
375             .setId(3355)
376             .addAllInstances(new ArrayList<String>())
377             .setKind("kind3292052")
378             .setName("name3373707")
379             .setRegion("region-934795532")
380             .setSelfLink("selfLink1191800166")
381             .setSessionAffinity("sessionAffinity-289859106")
382             .build();
383     mockService.addResponse(expectedResponse);
384 
385     String project = "project-6911";
386     String region = "region-9622";
387     String targetPool = "targetPool-115";
388 
389     TargetPool actualResponse = client.get(project, region, targetPool);
390     Assert.assertEquals(expectedResponse, actualResponse);
391 
392     List<String> actualRequests = mockService.getRequestPaths();
393     Assert.assertEquals(1, actualRequests.size());
394 
395     String apiClientHeaderKey =
396         mockService
397             .getRequestHeaders()
398             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
399             .iterator()
400             .next();
401     Assert.assertTrue(
402         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
403             .matcher(apiClientHeaderKey)
404             .matches());
405   }
406 
407   @Test
getExceptionTest()408   public void getExceptionTest() throws Exception {
409     ApiException exception =
410         ApiExceptionFactory.createException(
411             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
412     mockService.addException(exception);
413 
414     try {
415       String project = "project-6911";
416       String region = "region-9622";
417       String targetPool = "targetPool-115";
418       client.get(project, region, targetPool);
419       Assert.fail("No exception raised");
420     } catch (InvalidArgumentException e) {
421       // Expected exception.
422     }
423   }
424 
425   @Test
getHealthTest()426   public void getHealthTest() throws Exception {
427     TargetPoolInstanceHealth expectedResponse =
428         TargetPoolInstanceHealth.newBuilder()
429             .addAllHealthStatus(new ArrayList<HealthStatus>())
430             .setKind("kind3292052")
431             .build();
432     mockService.addResponse(expectedResponse);
433 
434     String project = "project-6911";
435     String region = "region-9622";
436     String targetPool = "targetPool-115";
437     InstanceReference instanceReferenceResource = InstanceReference.newBuilder().build();
438 
439     TargetPoolInstanceHealth actualResponse =
440         client.getHealth(project, region, targetPool, instanceReferenceResource);
441     Assert.assertEquals(expectedResponse, actualResponse);
442 
443     List<String> actualRequests = mockService.getRequestPaths();
444     Assert.assertEquals(1, actualRequests.size());
445 
446     String apiClientHeaderKey =
447         mockService
448             .getRequestHeaders()
449             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
450             .iterator()
451             .next();
452     Assert.assertTrue(
453         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
454             .matcher(apiClientHeaderKey)
455             .matches());
456   }
457 
458   @Test
getHealthExceptionTest()459   public void getHealthExceptionTest() throws Exception {
460     ApiException exception =
461         ApiExceptionFactory.createException(
462             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
463     mockService.addException(exception);
464 
465     try {
466       String project = "project-6911";
467       String region = "region-9622";
468       String targetPool = "targetPool-115";
469       InstanceReference instanceReferenceResource = InstanceReference.newBuilder().build();
470       client.getHealth(project, region, targetPool, instanceReferenceResource);
471       Assert.fail("No exception raised");
472     } catch (InvalidArgumentException e) {
473       // Expected exception.
474     }
475   }
476 
477   @Test
insertTest()478   public void insertTest() throws Exception {
479     Operation expectedResponse =
480         Operation.newBuilder()
481             .setClientOperationId("clientOperationId-1230366697")
482             .setCreationTimestamp("creationTimestamp-370203401")
483             .setDescription("description-1724546052")
484             .setEndTime("endTime-1607243192")
485             .setError(Error.newBuilder().build())
486             .setHttpErrorMessage("httpErrorMessage1577303431")
487             .setHttpErrorStatusCode(0)
488             .setId(3355)
489             .setInsertTime("insertTime966165798")
490             .setKind("kind3292052")
491             .setName("name3373707")
492             .setOperationGroupId("operationGroupId1716161683")
493             .setOperationType("operationType91999553")
494             .setProgress(-1001078227)
495             .setRegion("region-934795532")
496             .setSelfLink("selfLink1191800166")
497             .setStartTime("startTime-2129294769")
498             .setStatus(Status.DONE)
499             .setStatusMessage("statusMessage-958704715")
500             .setTargetId(-815576439)
501             .setTargetLink("targetLink486368555")
502             .setUser("user3599307")
503             .addAllWarnings(new ArrayList<Warnings>())
504             .setZone("zone3744684")
505             .build();
506     mockService.addResponse(expectedResponse);
507 
508     String project = "project-6911";
509     String region = "region-9622";
510     TargetPool targetPoolResource = TargetPool.newBuilder().build();
511 
512     Operation actualResponse = client.insertAsync(project, region, targetPoolResource).get();
513     Assert.assertEquals(expectedResponse, actualResponse);
514 
515     List<String> actualRequests = mockService.getRequestPaths();
516     Assert.assertEquals(1, actualRequests.size());
517 
518     String apiClientHeaderKey =
519         mockService
520             .getRequestHeaders()
521             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
522             .iterator()
523             .next();
524     Assert.assertTrue(
525         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
526             .matcher(apiClientHeaderKey)
527             .matches());
528   }
529 
530   @Test
insertExceptionTest()531   public void insertExceptionTest() throws Exception {
532     ApiException exception =
533         ApiExceptionFactory.createException(
534             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
535     mockService.addException(exception);
536 
537     try {
538       String project = "project-6911";
539       String region = "region-9622";
540       TargetPool targetPoolResource = TargetPool.newBuilder().build();
541       client.insertAsync(project, region, targetPoolResource).get();
542       Assert.fail("No exception raised");
543     } catch (ExecutionException e) {
544     }
545   }
546 
547   @Test
listTest()548   public void listTest() throws Exception {
549     TargetPool responsesElement = TargetPool.newBuilder().build();
550     TargetPoolList expectedResponse =
551         TargetPoolList.newBuilder()
552             .setNextPageToken("")
553             .addAllItems(Arrays.asList(responsesElement))
554             .build();
555     mockService.addResponse(expectedResponse);
556 
557     String project = "project-6911";
558     String region = "region-9622";
559 
560     ListPagedResponse pagedListResponse = client.list(project, region);
561 
562     List<TargetPool> 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 region = "region-9622";
592       client.list(project, region);
593       Assert.fail("No exception raised");
594     } catch (InvalidArgumentException e) {
595       // Expected exception.
596     }
597   }
598 
599   @Test
removeHealthCheckTest()600   public void removeHealthCheckTest() throws Exception {
601     Operation expectedResponse =
602         Operation.newBuilder()
603             .setClientOperationId("clientOperationId-1230366697")
604             .setCreationTimestamp("creationTimestamp-370203401")
605             .setDescription("description-1724546052")
606             .setEndTime("endTime-1607243192")
607             .setError(Error.newBuilder().build())
608             .setHttpErrorMessage("httpErrorMessage1577303431")
609             .setHttpErrorStatusCode(0)
610             .setId(3355)
611             .setInsertTime("insertTime966165798")
612             .setKind("kind3292052")
613             .setName("name3373707")
614             .setOperationGroupId("operationGroupId1716161683")
615             .setOperationType("operationType91999553")
616             .setProgress(-1001078227)
617             .setRegion("region-934795532")
618             .setSelfLink("selfLink1191800166")
619             .setStartTime("startTime-2129294769")
620             .setStatus(Status.DONE)
621             .setStatusMessage("statusMessage-958704715")
622             .setTargetId(-815576439)
623             .setTargetLink("targetLink486368555")
624             .setUser("user3599307")
625             .addAllWarnings(new ArrayList<Warnings>())
626             .setZone("zone3744684")
627             .build();
628     mockService.addResponse(expectedResponse);
629 
630     String project = "project-6911";
631     String region = "region-9622";
632     String targetPool = "targetPool-115";
633     TargetPoolsRemoveHealthCheckRequest targetPoolsRemoveHealthCheckRequestResource =
634         TargetPoolsRemoveHealthCheckRequest.newBuilder().build();
635 
636     Operation actualResponse =
637         client
638             .removeHealthCheckAsync(
639                 project, region, targetPool, targetPoolsRemoveHealthCheckRequestResource)
640             .get();
641     Assert.assertEquals(expectedResponse, actualResponse);
642 
643     List<String> actualRequests = mockService.getRequestPaths();
644     Assert.assertEquals(1, actualRequests.size());
645 
646     String apiClientHeaderKey =
647         mockService
648             .getRequestHeaders()
649             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
650             .iterator()
651             .next();
652     Assert.assertTrue(
653         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
654             .matcher(apiClientHeaderKey)
655             .matches());
656   }
657 
658   @Test
removeHealthCheckExceptionTest()659   public void removeHealthCheckExceptionTest() throws Exception {
660     ApiException exception =
661         ApiExceptionFactory.createException(
662             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
663     mockService.addException(exception);
664 
665     try {
666       String project = "project-6911";
667       String region = "region-9622";
668       String targetPool = "targetPool-115";
669       TargetPoolsRemoveHealthCheckRequest targetPoolsRemoveHealthCheckRequestResource =
670           TargetPoolsRemoveHealthCheckRequest.newBuilder().build();
671       client
672           .removeHealthCheckAsync(
673               project, region, targetPool, targetPoolsRemoveHealthCheckRequestResource)
674           .get();
675       Assert.fail("No exception raised");
676     } catch (ExecutionException e) {
677     }
678   }
679 
680   @Test
removeInstanceTest()681   public void removeInstanceTest() throws Exception {
682     Operation expectedResponse =
683         Operation.newBuilder()
684             .setClientOperationId("clientOperationId-1230366697")
685             .setCreationTimestamp("creationTimestamp-370203401")
686             .setDescription("description-1724546052")
687             .setEndTime("endTime-1607243192")
688             .setError(Error.newBuilder().build())
689             .setHttpErrorMessage("httpErrorMessage1577303431")
690             .setHttpErrorStatusCode(0)
691             .setId(3355)
692             .setInsertTime("insertTime966165798")
693             .setKind("kind3292052")
694             .setName("name3373707")
695             .setOperationGroupId("operationGroupId1716161683")
696             .setOperationType("operationType91999553")
697             .setProgress(-1001078227)
698             .setRegion("region-934795532")
699             .setSelfLink("selfLink1191800166")
700             .setStartTime("startTime-2129294769")
701             .setStatus(Status.DONE)
702             .setStatusMessage("statusMessage-958704715")
703             .setTargetId(-815576439)
704             .setTargetLink("targetLink486368555")
705             .setUser("user3599307")
706             .addAllWarnings(new ArrayList<Warnings>())
707             .setZone("zone3744684")
708             .build();
709     mockService.addResponse(expectedResponse);
710 
711     String project = "project-6911";
712     String region = "region-9622";
713     String targetPool = "targetPool-115";
714     TargetPoolsRemoveInstanceRequest targetPoolsRemoveInstanceRequestResource =
715         TargetPoolsRemoveInstanceRequest.newBuilder().build();
716 
717     Operation actualResponse =
718         client
719             .removeInstanceAsync(
720                 project, region, targetPool, targetPoolsRemoveInstanceRequestResource)
721             .get();
722     Assert.assertEquals(expectedResponse, actualResponse);
723 
724     List<String> actualRequests = mockService.getRequestPaths();
725     Assert.assertEquals(1, actualRequests.size());
726 
727     String apiClientHeaderKey =
728         mockService
729             .getRequestHeaders()
730             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
731             .iterator()
732             .next();
733     Assert.assertTrue(
734         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
735             .matcher(apiClientHeaderKey)
736             .matches());
737   }
738 
739   @Test
removeInstanceExceptionTest()740   public void removeInstanceExceptionTest() throws Exception {
741     ApiException exception =
742         ApiExceptionFactory.createException(
743             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
744     mockService.addException(exception);
745 
746     try {
747       String project = "project-6911";
748       String region = "region-9622";
749       String targetPool = "targetPool-115";
750       TargetPoolsRemoveInstanceRequest targetPoolsRemoveInstanceRequestResource =
751           TargetPoolsRemoveInstanceRequest.newBuilder().build();
752       client
753           .removeInstanceAsync(
754               project, region, targetPool, targetPoolsRemoveInstanceRequestResource)
755           .get();
756       Assert.fail("No exception raised");
757     } catch (ExecutionException e) {
758     }
759   }
760 
761   @Test
setBackupTest()762   public void setBackupTest() throws Exception {
763     Operation expectedResponse =
764         Operation.newBuilder()
765             .setClientOperationId("clientOperationId-1230366697")
766             .setCreationTimestamp("creationTimestamp-370203401")
767             .setDescription("description-1724546052")
768             .setEndTime("endTime-1607243192")
769             .setError(Error.newBuilder().build())
770             .setHttpErrorMessage("httpErrorMessage1577303431")
771             .setHttpErrorStatusCode(0)
772             .setId(3355)
773             .setInsertTime("insertTime966165798")
774             .setKind("kind3292052")
775             .setName("name3373707")
776             .setOperationGroupId("operationGroupId1716161683")
777             .setOperationType("operationType91999553")
778             .setProgress(-1001078227)
779             .setRegion("region-934795532")
780             .setSelfLink("selfLink1191800166")
781             .setStartTime("startTime-2129294769")
782             .setStatus(Status.DONE)
783             .setStatusMessage("statusMessage-958704715")
784             .setTargetId(-815576439)
785             .setTargetLink("targetLink486368555")
786             .setUser("user3599307")
787             .addAllWarnings(new ArrayList<Warnings>())
788             .setZone("zone3744684")
789             .build();
790     mockService.addResponse(expectedResponse);
791 
792     String project = "project-6911";
793     String region = "region-9622";
794     String targetPool = "targetPool-115";
795     TargetReference targetReferenceResource = TargetReference.newBuilder().build();
796 
797     Operation actualResponse =
798         client.setBackupAsync(project, region, targetPool, targetReferenceResource).get();
799     Assert.assertEquals(expectedResponse, actualResponse);
800 
801     List<String> actualRequests = mockService.getRequestPaths();
802     Assert.assertEquals(1, actualRequests.size());
803 
804     String apiClientHeaderKey =
805         mockService
806             .getRequestHeaders()
807             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
808             .iterator()
809             .next();
810     Assert.assertTrue(
811         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
812             .matcher(apiClientHeaderKey)
813             .matches());
814   }
815 
816   @Test
setBackupExceptionTest()817   public void setBackupExceptionTest() throws Exception {
818     ApiException exception =
819         ApiExceptionFactory.createException(
820             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
821     mockService.addException(exception);
822 
823     try {
824       String project = "project-6911";
825       String region = "region-9622";
826       String targetPool = "targetPool-115";
827       TargetReference targetReferenceResource = TargetReference.newBuilder().build();
828       client.setBackupAsync(project, region, targetPool, targetReferenceResource).get();
829       Assert.fail("No exception raised");
830     } catch (ExecutionException e) {
831     }
832   }
833 }
834