• 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.gkemulticloud.v1;
18 
19 import static com.google.cloud.gkemulticloud.v1.AwsClustersClient.ListAwsClustersPagedResponse;
20 import static com.google.cloud.gkemulticloud.v1.AwsClustersClient.ListAwsNodePoolsPagedResponse;
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.gkemulticloud.v1.stub.HttpJsonAwsClustersStub;
32 import com.google.common.collect.Lists;
33 import com.google.longrunning.Operation;
34 import com.google.protobuf.Any;
35 import com.google.protobuf.Empty;
36 import com.google.protobuf.FieldMask;
37 import com.google.protobuf.Timestamp;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.List;
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 AwsClustersClientHttpJsonTest {
54   private static MockHttpService mockService;
55   private static AwsClustersClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() throws IOException {
59     mockService =
60         new MockHttpService(
61             HttpJsonAwsClustersStub.getMethodDescriptors(),
62             AwsClustersSettings.getDefaultEndpoint());
63     AwsClustersSettings settings =
64         AwsClustersSettings.newHttpJsonBuilder()
65             .setTransportChannelProvider(
66                 AwsClustersSettings.defaultHttpJsonTransportProviderBuilder()
67                     .setHttpTransport(mockService)
68                     .build())
69             .setCredentialsProvider(NoCredentialsProvider.create())
70             .build();
71     client = AwsClustersClient.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
createAwsClusterTest()88   public void createAwsClusterTest() throws Exception {
89     AwsCluster expectedResponse =
90         AwsCluster.newBuilder()
91             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
92             .setDescription("description-1724546052")
93             .setNetworking(AwsClusterNetworking.newBuilder().build())
94             .setAwsRegion("awsRegion-860644271")
95             .setControlPlane(AwsControlPlane.newBuilder().build())
96             .setAuthorization(AwsAuthorization.newBuilder().build())
97             .setEndpoint("endpoint1741102485")
98             .setUid("uid115792")
99             .setReconciling(true)
100             .setCreateTime(Timestamp.newBuilder().build())
101             .setUpdateTime(Timestamp.newBuilder().build())
102             .setEtag("etag3123477")
103             .putAllAnnotations(new HashMap<String, String>())
104             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
105             .setClusterCaCertificate("clusterCaCertificate-683492737")
106             .setFleet(Fleet.newBuilder().build())
107             .setLoggingConfig(LoggingConfig.newBuilder().build())
108             .addAllErrors(new ArrayList<AwsClusterError>())
109             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
110             .build();
111     Operation resultOperation =
112         Operation.newBuilder()
113             .setName("createAwsClusterTest")
114             .setDone(true)
115             .setResponse(Any.pack(expectedResponse))
116             .build();
117     mockService.addResponse(resultOperation);
118 
119     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
120     AwsCluster awsCluster = AwsCluster.newBuilder().build();
121     String awsClusterId = "awsClusterId1988965944";
122 
123     AwsCluster actualResponse =
124         client.createAwsClusterAsync(parent, awsCluster, awsClusterId).get();
125     Assert.assertEquals(expectedResponse, actualResponse);
126 
127     List<String> actualRequests = mockService.getRequestPaths();
128     Assert.assertEquals(1, actualRequests.size());
129 
130     String apiClientHeaderKey =
131         mockService
132             .getRequestHeaders()
133             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
134             .iterator()
135             .next();
136     Assert.assertTrue(
137         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
138             .matcher(apiClientHeaderKey)
139             .matches());
140   }
141 
142   @Test
createAwsClusterExceptionTest()143   public void createAwsClusterExceptionTest() throws Exception {
144     ApiException exception =
145         ApiExceptionFactory.createException(
146             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
147     mockService.addException(exception);
148 
149     try {
150       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
151       AwsCluster awsCluster = AwsCluster.newBuilder().build();
152       String awsClusterId = "awsClusterId1988965944";
153       client.createAwsClusterAsync(parent, awsCluster, awsClusterId).get();
154       Assert.fail("No exception raised");
155     } catch (ExecutionException e) {
156     }
157   }
158 
159   @Test
createAwsClusterTest2()160   public void createAwsClusterTest2() throws Exception {
161     AwsCluster expectedResponse =
162         AwsCluster.newBuilder()
163             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
164             .setDescription("description-1724546052")
165             .setNetworking(AwsClusterNetworking.newBuilder().build())
166             .setAwsRegion("awsRegion-860644271")
167             .setControlPlane(AwsControlPlane.newBuilder().build())
168             .setAuthorization(AwsAuthorization.newBuilder().build())
169             .setEndpoint("endpoint1741102485")
170             .setUid("uid115792")
171             .setReconciling(true)
172             .setCreateTime(Timestamp.newBuilder().build())
173             .setUpdateTime(Timestamp.newBuilder().build())
174             .setEtag("etag3123477")
175             .putAllAnnotations(new HashMap<String, String>())
176             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
177             .setClusterCaCertificate("clusterCaCertificate-683492737")
178             .setFleet(Fleet.newBuilder().build())
179             .setLoggingConfig(LoggingConfig.newBuilder().build())
180             .addAllErrors(new ArrayList<AwsClusterError>())
181             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
182             .build();
183     Operation resultOperation =
184         Operation.newBuilder()
185             .setName("createAwsClusterTest")
186             .setDone(true)
187             .setResponse(Any.pack(expectedResponse))
188             .build();
189     mockService.addResponse(resultOperation);
190 
191     String parent = "projects/project-5833/locations/location-5833";
192     AwsCluster awsCluster = AwsCluster.newBuilder().build();
193     String awsClusterId = "awsClusterId1988965944";
194 
195     AwsCluster actualResponse =
196         client.createAwsClusterAsync(parent, awsCluster, awsClusterId).get();
197     Assert.assertEquals(expectedResponse, actualResponse);
198 
199     List<String> actualRequests = mockService.getRequestPaths();
200     Assert.assertEquals(1, actualRequests.size());
201 
202     String apiClientHeaderKey =
203         mockService
204             .getRequestHeaders()
205             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
206             .iterator()
207             .next();
208     Assert.assertTrue(
209         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
210             .matcher(apiClientHeaderKey)
211             .matches());
212   }
213 
214   @Test
createAwsClusterExceptionTest2()215   public void createAwsClusterExceptionTest2() throws Exception {
216     ApiException exception =
217         ApiExceptionFactory.createException(
218             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
219     mockService.addException(exception);
220 
221     try {
222       String parent = "projects/project-5833/locations/location-5833";
223       AwsCluster awsCluster = AwsCluster.newBuilder().build();
224       String awsClusterId = "awsClusterId1988965944";
225       client.createAwsClusterAsync(parent, awsCluster, awsClusterId).get();
226       Assert.fail("No exception raised");
227     } catch (ExecutionException e) {
228     }
229   }
230 
231   @Test
updateAwsClusterTest()232   public void updateAwsClusterTest() throws Exception {
233     AwsCluster expectedResponse =
234         AwsCluster.newBuilder()
235             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
236             .setDescription("description-1724546052")
237             .setNetworking(AwsClusterNetworking.newBuilder().build())
238             .setAwsRegion("awsRegion-860644271")
239             .setControlPlane(AwsControlPlane.newBuilder().build())
240             .setAuthorization(AwsAuthorization.newBuilder().build())
241             .setEndpoint("endpoint1741102485")
242             .setUid("uid115792")
243             .setReconciling(true)
244             .setCreateTime(Timestamp.newBuilder().build())
245             .setUpdateTime(Timestamp.newBuilder().build())
246             .setEtag("etag3123477")
247             .putAllAnnotations(new HashMap<String, String>())
248             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
249             .setClusterCaCertificate("clusterCaCertificate-683492737")
250             .setFleet(Fleet.newBuilder().build())
251             .setLoggingConfig(LoggingConfig.newBuilder().build())
252             .addAllErrors(new ArrayList<AwsClusterError>())
253             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
254             .build();
255     Operation resultOperation =
256         Operation.newBuilder()
257             .setName("updateAwsClusterTest")
258             .setDone(true)
259             .setResponse(Any.pack(expectedResponse))
260             .build();
261     mockService.addResponse(resultOperation);
262 
263     AwsCluster awsCluster =
264         AwsCluster.newBuilder()
265             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
266             .setDescription("description-1724546052")
267             .setNetworking(AwsClusterNetworking.newBuilder().build())
268             .setAwsRegion("awsRegion-860644271")
269             .setControlPlane(AwsControlPlane.newBuilder().build())
270             .setAuthorization(AwsAuthorization.newBuilder().build())
271             .setEndpoint("endpoint1741102485")
272             .setUid("uid115792")
273             .setReconciling(true)
274             .setCreateTime(Timestamp.newBuilder().build())
275             .setUpdateTime(Timestamp.newBuilder().build())
276             .setEtag("etag3123477")
277             .putAllAnnotations(new HashMap<String, String>())
278             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
279             .setClusterCaCertificate("clusterCaCertificate-683492737")
280             .setFleet(Fleet.newBuilder().build())
281             .setLoggingConfig(LoggingConfig.newBuilder().build())
282             .addAllErrors(new ArrayList<AwsClusterError>())
283             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
284             .build();
285     FieldMask updateMask = FieldMask.newBuilder().build();
286 
287     AwsCluster actualResponse = client.updateAwsClusterAsync(awsCluster, updateMask).get();
288     Assert.assertEquals(expectedResponse, actualResponse);
289 
290     List<String> actualRequests = mockService.getRequestPaths();
291     Assert.assertEquals(1, actualRequests.size());
292 
293     String apiClientHeaderKey =
294         mockService
295             .getRequestHeaders()
296             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
297             .iterator()
298             .next();
299     Assert.assertTrue(
300         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
301             .matcher(apiClientHeaderKey)
302             .matches());
303   }
304 
305   @Test
updateAwsClusterExceptionTest()306   public void updateAwsClusterExceptionTest() throws Exception {
307     ApiException exception =
308         ApiExceptionFactory.createException(
309             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
310     mockService.addException(exception);
311 
312     try {
313       AwsCluster awsCluster =
314           AwsCluster.newBuilder()
315               .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
316               .setDescription("description-1724546052")
317               .setNetworking(AwsClusterNetworking.newBuilder().build())
318               .setAwsRegion("awsRegion-860644271")
319               .setControlPlane(AwsControlPlane.newBuilder().build())
320               .setAuthorization(AwsAuthorization.newBuilder().build())
321               .setEndpoint("endpoint1741102485")
322               .setUid("uid115792")
323               .setReconciling(true)
324               .setCreateTime(Timestamp.newBuilder().build())
325               .setUpdateTime(Timestamp.newBuilder().build())
326               .setEtag("etag3123477")
327               .putAllAnnotations(new HashMap<String, String>())
328               .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
329               .setClusterCaCertificate("clusterCaCertificate-683492737")
330               .setFleet(Fleet.newBuilder().build())
331               .setLoggingConfig(LoggingConfig.newBuilder().build())
332               .addAllErrors(new ArrayList<AwsClusterError>())
333               .setMonitoringConfig(MonitoringConfig.newBuilder().build())
334               .build();
335       FieldMask updateMask = FieldMask.newBuilder().build();
336       client.updateAwsClusterAsync(awsCluster, updateMask).get();
337       Assert.fail("No exception raised");
338     } catch (ExecutionException e) {
339     }
340   }
341 
342   @Test
getAwsClusterTest()343   public void getAwsClusterTest() throws Exception {
344     AwsCluster expectedResponse =
345         AwsCluster.newBuilder()
346             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
347             .setDescription("description-1724546052")
348             .setNetworking(AwsClusterNetworking.newBuilder().build())
349             .setAwsRegion("awsRegion-860644271")
350             .setControlPlane(AwsControlPlane.newBuilder().build())
351             .setAuthorization(AwsAuthorization.newBuilder().build())
352             .setEndpoint("endpoint1741102485")
353             .setUid("uid115792")
354             .setReconciling(true)
355             .setCreateTime(Timestamp.newBuilder().build())
356             .setUpdateTime(Timestamp.newBuilder().build())
357             .setEtag("etag3123477")
358             .putAllAnnotations(new HashMap<String, String>())
359             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
360             .setClusterCaCertificate("clusterCaCertificate-683492737")
361             .setFleet(Fleet.newBuilder().build())
362             .setLoggingConfig(LoggingConfig.newBuilder().build())
363             .addAllErrors(new ArrayList<AwsClusterError>())
364             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
365             .build();
366     mockService.addResponse(expectedResponse);
367 
368     AwsClusterName name = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
369 
370     AwsCluster actualResponse = client.getAwsCluster(name);
371     Assert.assertEquals(expectedResponse, actualResponse);
372 
373     List<String> actualRequests = mockService.getRequestPaths();
374     Assert.assertEquals(1, actualRequests.size());
375 
376     String apiClientHeaderKey =
377         mockService
378             .getRequestHeaders()
379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
380             .iterator()
381             .next();
382     Assert.assertTrue(
383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
384             .matcher(apiClientHeaderKey)
385             .matches());
386   }
387 
388   @Test
getAwsClusterExceptionTest()389   public void getAwsClusterExceptionTest() throws Exception {
390     ApiException exception =
391         ApiExceptionFactory.createException(
392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
393     mockService.addException(exception);
394 
395     try {
396       AwsClusterName name = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
397       client.getAwsCluster(name);
398       Assert.fail("No exception raised");
399     } catch (InvalidArgumentException e) {
400       // Expected exception.
401     }
402   }
403 
404   @Test
getAwsClusterTest2()405   public void getAwsClusterTest2() throws Exception {
406     AwsCluster expectedResponse =
407         AwsCluster.newBuilder()
408             .setName(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
409             .setDescription("description-1724546052")
410             .setNetworking(AwsClusterNetworking.newBuilder().build())
411             .setAwsRegion("awsRegion-860644271")
412             .setControlPlane(AwsControlPlane.newBuilder().build())
413             .setAuthorization(AwsAuthorization.newBuilder().build())
414             .setEndpoint("endpoint1741102485")
415             .setUid("uid115792")
416             .setReconciling(true)
417             .setCreateTime(Timestamp.newBuilder().build())
418             .setUpdateTime(Timestamp.newBuilder().build())
419             .setEtag("etag3123477")
420             .putAllAnnotations(new HashMap<String, String>())
421             .setWorkloadIdentityConfig(WorkloadIdentityConfig.newBuilder().build())
422             .setClusterCaCertificate("clusterCaCertificate-683492737")
423             .setFleet(Fleet.newBuilder().build())
424             .setLoggingConfig(LoggingConfig.newBuilder().build())
425             .addAllErrors(new ArrayList<AwsClusterError>())
426             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
427             .build();
428     mockService.addResponse(expectedResponse);
429 
430     String name = "projects/project-1220/locations/location-1220/awsClusters/awsCluster-1220";
431 
432     AwsCluster actualResponse = client.getAwsCluster(name);
433     Assert.assertEquals(expectedResponse, actualResponse);
434 
435     List<String> actualRequests = mockService.getRequestPaths();
436     Assert.assertEquals(1, actualRequests.size());
437 
438     String apiClientHeaderKey =
439         mockService
440             .getRequestHeaders()
441             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
442             .iterator()
443             .next();
444     Assert.assertTrue(
445         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
446             .matcher(apiClientHeaderKey)
447             .matches());
448   }
449 
450   @Test
getAwsClusterExceptionTest2()451   public void getAwsClusterExceptionTest2() throws Exception {
452     ApiException exception =
453         ApiExceptionFactory.createException(
454             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
455     mockService.addException(exception);
456 
457     try {
458       String name = "projects/project-1220/locations/location-1220/awsClusters/awsCluster-1220";
459       client.getAwsCluster(name);
460       Assert.fail("No exception raised");
461     } catch (InvalidArgumentException e) {
462       // Expected exception.
463     }
464   }
465 
466   @Test
listAwsClustersTest()467   public void listAwsClustersTest() throws Exception {
468     AwsCluster responsesElement = AwsCluster.newBuilder().build();
469     ListAwsClustersResponse expectedResponse =
470         ListAwsClustersResponse.newBuilder()
471             .setNextPageToken("")
472             .addAllAwsClusters(Arrays.asList(responsesElement))
473             .build();
474     mockService.addResponse(expectedResponse);
475 
476     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
477 
478     ListAwsClustersPagedResponse pagedListResponse = client.listAwsClusters(parent);
479 
480     List<AwsCluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
481 
482     Assert.assertEquals(1, resources.size());
483     Assert.assertEquals(expectedResponse.getAwsClustersList().get(0), resources.get(0));
484 
485     List<String> actualRequests = mockService.getRequestPaths();
486     Assert.assertEquals(1, actualRequests.size());
487 
488     String apiClientHeaderKey =
489         mockService
490             .getRequestHeaders()
491             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
492             .iterator()
493             .next();
494     Assert.assertTrue(
495         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
496             .matcher(apiClientHeaderKey)
497             .matches());
498   }
499 
500   @Test
listAwsClustersExceptionTest()501   public void listAwsClustersExceptionTest() throws Exception {
502     ApiException exception =
503         ApiExceptionFactory.createException(
504             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
505     mockService.addException(exception);
506 
507     try {
508       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
509       client.listAwsClusters(parent);
510       Assert.fail("No exception raised");
511     } catch (InvalidArgumentException e) {
512       // Expected exception.
513     }
514   }
515 
516   @Test
listAwsClustersTest2()517   public void listAwsClustersTest2() throws Exception {
518     AwsCluster responsesElement = AwsCluster.newBuilder().build();
519     ListAwsClustersResponse expectedResponse =
520         ListAwsClustersResponse.newBuilder()
521             .setNextPageToken("")
522             .addAllAwsClusters(Arrays.asList(responsesElement))
523             .build();
524     mockService.addResponse(expectedResponse);
525 
526     String parent = "projects/project-5833/locations/location-5833";
527 
528     ListAwsClustersPagedResponse pagedListResponse = client.listAwsClusters(parent);
529 
530     List<AwsCluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
531 
532     Assert.assertEquals(1, resources.size());
533     Assert.assertEquals(expectedResponse.getAwsClustersList().get(0), resources.get(0));
534 
535     List<String> actualRequests = mockService.getRequestPaths();
536     Assert.assertEquals(1, actualRequests.size());
537 
538     String apiClientHeaderKey =
539         mockService
540             .getRequestHeaders()
541             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
542             .iterator()
543             .next();
544     Assert.assertTrue(
545         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
546             .matcher(apiClientHeaderKey)
547             .matches());
548   }
549 
550   @Test
listAwsClustersExceptionTest2()551   public void listAwsClustersExceptionTest2() throws Exception {
552     ApiException exception =
553         ApiExceptionFactory.createException(
554             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
555     mockService.addException(exception);
556 
557     try {
558       String parent = "projects/project-5833/locations/location-5833";
559       client.listAwsClusters(parent);
560       Assert.fail("No exception raised");
561     } catch (InvalidArgumentException e) {
562       // Expected exception.
563     }
564   }
565 
566   @Test
deleteAwsClusterTest()567   public void deleteAwsClusterTest() throws Exception {
568     Empty expectedResponse = Empty.newBuilder().build();
569     Operation resultOperation =
570         Operation.newBuilder()
571             .setName("deleteAwsClusterTest")
572             .setDone(true)
573             .setResponse(Any.pack(expectedResponse))
574             .build();
575     mockService.addResponse(resultOperation);
576 
577     AwsClusterName name = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
578 
579     client.deleteAwsClusterAsync(name).get();
580 
581     List<String> actualRequests = mockService.getRequestPaths();
582     Assert.assertEquals(1, actualRequests.size());
583 
584     String apiClientHeaderKey =
585         mockService
586             .getRequestHeaders()
587             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
588             .iterator()
589             .next();
590     Assert.assertTrue(
591         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
592             .matcher(apiClientHeaderKey)
593             .matches());
594   }
595 
596   @Test
deleteAwsClusterExceptionTest()597   public void deleteAwsClusterExceptionTest() throws Exception {
598     ApiException exception =
599         ApiExceptionFactory.createException(
600             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
601     mockService.addException(exception);
602 
603     try {
604       AwsClusterName name = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
605       client.deleteAwsClusterAsync(name).get();
606       Assert.fail("No exception raised");
607     } catch (ExecutionException e) {
608     }
609   }
610 
611   @Test
deleteAwsClusterTest2()612   public void deleteAwsClusterTest2() throws Exception {
613     Empty expectedResponse = Empty.newBuilder().build();
614     Operation resultOperation =
615         Operation.newBuilder()
616             .setName("deleteAwsClusterTest")
617             .setDone(true)
618             .setResponse(Any.pack(expectedResponse))
619             .build();
620     mockService.addResponse(resultOperation);
621 
622     String name = "projects/project-1220/locations/location-1220/awsClusters/awsCluster-1220";
623 
624     client.deleteAwsClusterAsync(name).get();
625 
626     List<String> actualRequests = mockService.getRequestPaths();
627     Assert.assertEquals(1, actualRequests.size());
628 
629     String apiClientHeaderKey =
630         mockService
631             .getRequestHeaders()
632             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
633             .iterator()
634             .next();
635     Assert.assertTrue(
636         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
637             .matcher(apiClientHeaderKey)
638             .matches());
639   }
640 
641   @Test
deleteAwsClusterExceptionTest2()642   public void deleteAwsClusterExceptionTest2() throws Exception {
643     ApiException exception =
644         ApiExceptionFactory.createException(
645             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
646     mockService.addException(exception);
647 
648     try {
649       String name = "projects/project-1220/locations/location-1220/awsClusters/awsCluster-1220";
650       client.deleteAwsClusterAsync(name).get();
651       Assert.fail("No exception raised");
652     } catch (ExecutionException e) {
653     }
654   }
655 
656   @Test
generateAwsAccessTokenTest()657   public void generateAwsAccessTokenTest() throws Exception {
658     GenerateAwsAccessTokenResponse expectedResponse =
659         GenerateAwsAccessTokenResponse.newBuilder()
660             .setAccessToken("accessToken-1042689291")
661             .setExpirationTime(Timestamp.newBuilder().build())
662             .build();
663     mockService.addResponse(expectedResponse);
664 
665     GenerateAwsAccessTokenRequest request =
666         GenerateAwsAccessTokenRequest.newBuilder()
667             .setAwsCluster(AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
668             .build();
669 
670     GenerateAwsAccessTokenResponse actualResponse = client.generateAwsAccessToken(request);
671     Assert.assertEquals(expectedResponse, actualResponse);
672 
673     List<String> actualRequests = mockService.getRequestPaths();
674     Assert.assertEquals(1, actualRequests.size());
675 
676     String apiClientHeaderKey =
677         mockService
678             .getRequestHeaders()
679             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
680             .iterator()
681             .next();
682     Assert.assertTrue(
683         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
684             .matcher(apiClientHeaderKey)
685             .matches());
686   }
687 
688   @Test
generateAwsAccessTokenExceptionTest()689   public void generateAwsAccessTokenExceptionTest() throws Exception {
690     ApiException exception =
691         ApiExceptionFactory.createException(
692             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
693     mockService.addException(exception);
694 
695     try {
696       GenerateAwsAccessTokenRequest request =
697           GenerateAwsAccessTokenRequest.newBuilder()
698               .setAwsCluster(
699                   AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]").toString())
700               .build();
701       client.generateAwsAccessToken(request);
702       Assert.fail("No exception raised");
703     } catch (InvalidArgumentException e) {
704       // Expected exception.
705     }
706   }
707 
708   @Test
createAwsNodePoolTest()709   public void createAwsNodePoolTest() throws Exception {
710     AwsNodePool expectedResponse =
711         AwsNodePool.newBuilder()
712             .setName(
713                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
714                     .toString())
715             .setVersion("version351608024")
716             .setConfig(AwsNodeConfig.newBuilder().build())
717             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
718             .setSubnetId("subnetId-2066159272")
719             .setUid("uid115792")
720             .setReconciling(true)
721             .setCreateTime(Timestamp.newBuilder().build())
722             .setUpdateTime(Timestamp.newBuilder().build())
723             .setEtag("etag3123477")
724             .putAllAnnotations(new HashMap<String, String>())
725             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
726             .addAllErrors(new ArrayList<AwsNodePoolError>())
727             .build();
728     Operation resultOperation =
729         Operation.newBuilder()
730             .setName("createAwsNodePoolTest")
731             .setDone(true)
732             .setResponse(Any.pack(expectedResponse))
733             .build();
734     mockService.addResponse(resultOperation);
735 
736     AwsClusterName parent = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
737     AwsNodePool awsNodePool = AwsNodePool.newBuilder().build();
738     String awsNodePoolId = "awsNodePoolId-1885267498";
739 
740     AwsNodePool actualResponse =
741         client.createAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId).get();
742     Assert.assertEquals(expectedResponse, actualResponse);
743 
744     List<String> actualRequests = mockService.getRequestPaths();
745     Assert.assertEquals(1, actualRequests.size());
746 
747     String apiClientHeaderKey =
748         mockService
749             .getRequestHeaders()
750             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
751             .iterator()
752             .next();
753     Assert.assertTrue(
754         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
755             .matcher(apiClientHeaderKey)
756             .matches());
757   }
758 
759   @Test
createAwsNodePoolExceptionTest()760   public void createAwsNodePoolExceptionTest() throws Exception {
761     ApiException exception =
762         ApiExceptionFactory.createException(
763             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
764     mockService.addException(exception);
765 
766     try {
767       AwsClusterName parent = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
768       AwsNodePool awsNodePool = AwsNodePool.newBuilder().build();
769       String awsNodePoolId = "awsNodePoolId-1885267498";
770       client.createAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId).get();
771       Assert.fail("No exception raised");
772     } catch (ExecutionException e) {
773     }
774   }
775 
776   @Test
createAwsNodePoolTest2()777   public void createAwsNodePoolTest2() throws Exception {
778     AwsNodePool expectedResponse =
779         AwsNodePool.newBuilder()
780             .setName(
781                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
782                     .toString())
783             .setVersion("version351608024")
784             .setConfig(AwsNodeConfig.newBuilder().build())
785             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
786             .setSubnetId("subnetId-2066159272")
787             .setUid("uid115792")
788             .setReconciling(true)
789             .setCreateTime(Timestamp.newBuilder().build())
790             .setUpdateTime(Timestamp.newBuilder().build())
791             .setEtag("etag3123477")
792             .putAllAnnotations(new HashMap<String, String>())
793             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
794             .addAllErrors(new ArrayList<AwsNodePoolError>())
795             .build();
796     Operation resultOperation =
797         Operation.newBuilder()
798             .setName("createAwsNodePoolTest")
799             .setDone(true)
800             .setResponse(Any.pack(expectedResponse))
801             .build();
802     mockService.addResponse(resultOperation);
803 
804     String parent = "projects/project-2069/locations/location-2069/awsClusters/awsCluster-2069";
805     AwsNodePool awsNodePool = AwsNodePool.newBuilder().build();
806     String awsNodePoolId = "awsNodePoolId-1885267498";
807 
808     AwsNodePool actualResponse =
809         client.createAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId).get();
810     Assert.assertEquals(expectedResponse, actualResponse);
811 
812     List<String> actualRequests = mockService.getRequestPaths();
813     Assert.assertEquals(1, actualRequests.size());
814 
815     String apiClientHeaderKey =
816         mockService
817             .getRequestHeaders()
818             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
819             .iterator()
820             .next();
821     Assert.assertTrue(
822         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
823             .matcher(apiClientHeaderKey)
824             .matches());
825   }
826 
827   @Test
createAwsNodePoolExceptionTest2()828   public void createAwsNodePoolExceptionTest2() throws Exception {
829     ApiException exception =
830         ApiExceptionFactory.createException(
831             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
832     mockService.addException(exception);
833 
834     try {
835       String parent = "projects/project-2069/locations/location-2069/awsClusters/awsCluster-2069";
836       AwsNodePool awsNodePool = AwsNodePool.newBuilder().build();
837       String awsNodePoolId = "awsNodePoolId-1885267498";
838       client.createAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId).get();
839       Assert.fail("No exception raised");
840     } catch (ExecutionException e) {
841     }
842   }
843 
844   @Test
updateAwsNodePoolTest()845   public void updateAwsNodePoolTest() throws Exception {
846     AwsNodePool expectedResponse =
847         AwsNodePool.newBuilder()
848             .setName(
849                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
850                     .toString())
851             .setVersion("version351608024")
852             .setConfig(AwsNodeConfig.newBuilder().build())
853             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
854             .setSubnetId("subnetId-2066159272")
855             .setUid("uid115792")
856             .setReconciling(true)
857             .setCreateTime(Timestamp.newBuilder().build())
858             .setUpdateTime(Timestamp.newBuilder().build())
859             .setEtag("etag3123477")
860             .putAllAnnotations(new HashMap<String, String>())
861             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
862             .addAllErrors(new ArrayList<AwsNodePoolError>())
863             .build();
864     Operation resultOperation =
865         Operation.newBuilder()
866             .setName("updateAwsNodePoolTest")
867             .setDone(true)
868             .setResponse(Any.pack(expectedResponse))
869             .build();
870     mockService.addResponse(resultOperation);
871 
872     AwsNodePool awsNodePool =
873         AwsNodePool.newBuilder()
874             .setName(
875                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
876                     .toString())
877             .setVersion("version351608024")
878             .setConfig(AwsNodeConfig.newBuilder().build())
879             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
880             .setSubnetId("subnetId-2066159272")
881             .setUid("uid115792")
882             .setReconciling(true)
883             .setCreateTime(Timestamp.newBuilder().build())
884             .setUpdateTime(Timestamp.newBuilder().build())
885             .setEtag("etag3123477")
886             .putAllAnnotations(new HashMap<String, String>())
887             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
888             .addAllErrors(new ArrayList<AwsNodePoolError>())
889             .build();
890     FieldMask updateMask = FieldMask.newBuilder().build();
891 
892     AwsNodePool actualResponse = client.updateAwsNodePoolAsync(awsNodePool, updateMask).get();
893     Assert.assertEquals(expectedResponse, actualResponse);
894 
895     List<String> actualRequests = mockService.getRequestPaths();
896     Assert.assertEquals(1, actualRequests.size());
897 
898     String apiClientHeaderKey =
899         mockService
900             .getRequestHeaders()
901             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
902             .iterator()
903             .next();
904     Assert.assertTrue(
905         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
906             .matcher(apiClientHeaderKey)
907             .matches());
908   }
909 
910   @Test
updateAwsNodePoolExceptionTest()911   public void updateAwsNodePoolExceptionTest() throws Exception {
912     ApiException exception =
913         ApiExceptionFactory.createException(
914             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
915     mockService.addException(exception);
916 
917     try {
918       AwsNodePool awsNodePool =
919           AwsNodePool.newBuilder()
920               .setName(
921                   AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
922                       .toString())
923               .setVersion("version351608024")
924               .setConfig(AwsNodeConfig.newBuilder().build())
925               .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
926               .setSubnetId("subnetId-2066159272")
927               .setUid("uid115792")
928               .setReconciling(true)
929               .setCreateTime(Timestamp.newBuilder().build())
930               .setUpdateTime(Timestamp.newBuilder().build())
931               .setEtag("etag3123477")
932               .putAllAnnotations(new HashMap<String, String>())
933               .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
934               .addAllErrors(new ArrayList<AwsNodePoolError>())
935               .build();
936       FieldMask updateMask = FieldMask.newBuilder().build();
937       client.updateAwsNodePoolAsync(awsNodePool, updateMask).get();
938       Assert.fail("No exception raised");
939     } catch (ExecutionException e) {
940     }
941   }
942 
943   @Test
getAwsNodePoolTest()944   public void getAwsNodePoolTest() throws Exception {
945     AwsNodePool expectedResponse =
946         AwsNodePool.newBuilder()
947             .setName(
948                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
949                     .toString())
950             .setVersion("version351608024")
951             .setConfig(AwsNodeConfig.newBuilder().build())
952             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
953             .setSubnetId("subnetId-2066159272")
954             .setUid("uid115792")
955             .setReconciling(true)
956             .setCreateTime(Timestamp.newBuilder().build())
957             .setUpdateTime(Timestamp.newBuilder().build())
958             .setEtag("etag3123477")
959             .putAllAnnotations(new HashMap<String, String>())
960             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
961             .addAllErrors(new ArrayList<AwsNodePoolError>())
962             .build();
963     mockService.addResponse(expectedResponse);
964 
965     AwsNodePoolName name =
966         AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
967 
968     AwsNodePool actualResponse = client.getAwsNodePool(name);
969     Assert.assertEquals(expectedResponse, actualResponse);
970 
971     List<String> actualRequests = mockService.getRequestPaths();
972     Assert.assertEquals(1, actualRequests.size());
973 
974     String apiClientHeaderKey =
975         mockService
976             .getRequestHeaders()
977             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
978             .iterator()
979             .next();
980     Assert.assertTrue(
981         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
982             .matcher(apiClientHeaderKey)
983             .matches());
984   }
985 
986   @Test
getAwsNodePoolExceptionTest()987   public void getAwsNodePoolExceptionTest() throws Exception {
988     ApiException exception =
989         ApiExceptionFactory.createException(
990             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
991     mockService.addException(exception);
992 
993     try {
994       AwsNodePoolName name =
995           AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
996       client.getAwsNodePool(name);
997       Assert.fail("No exception raised");
998     } catch (InvalidArgumentException e) {
999       // Expected exception.
1000     }
1001   }
1002 
1003   @Test
getAwsNodePoolTest2()1004   public void getAwsNodePoolTest2() throws Exception {
1005     AwsNodePool expectedResponse =
1006         AwsNodePool.newBuilder()
1007             .setName(
1008                 AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]")
1009                     .toString())
1010             .setVersion("version351608024")
1011             .setConfig(AwsNodeConfig.newBuilder().build())
1012             .setAutoscaling(AwsNodePoolAutoscaling.newBuilder().build())
1013             .setSubnetId("subnetId-2066159272")
1014             .setUid("uid115792")
1015             .setReconciling(true)
1016             .setCreateTime(Timestamp.newBuilder().build())
1017             .setUpdateTime(Timestamp.newBuilder().build())
1018             .setEtag("etag3123477")
1019             .putAllAnnotations(new HashMap<String, String>())
1020             .setMaxPodsConstraint(MaxPodsConstraint.newBuilder().build())
1021             .addAllErrors(new ArrayList<AwsNodePoolError>())
1022             .build();
1023     mockService.addResponse(expectedResponse);
1024 
1025     String name =
1026         "projects/project-9334/locations/location-9334/awsClusters/awsCluster-9334/awsNodePools/awsNodePool-9334";
1027 
1028     AwsNodePool actualResponse = client.getAwsNodePool(name);
1029     Assert.assertEquals(expectedResponse, actualResponse);
1030 
1031     List<String> actualRequests = mockService.getRequestPaths();
1032     Assert.assertEquals(1, actualRequests.size());
1033 
1034     String apiClientHeaderKey =
1035         mockService
1036             .getRequestHeaders()
1037             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1038             .iterator()
1039             .next();
1040     Assert.assertTrue(
1041         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1042             .matcher(apiClientHeaderKey)
1043             .matches());
1044   }
1045 
1046   @Test
getAwsNodePoolExceptionTest2()1047   public void getAwsNodePoolExceptionTest2() throws Exception {
1048     ApiException exception =
1049         ApiExceptionFactory.createException(
1050             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1051     mockService.addException(exception);
1052 
1053     try {
1054       String name =
1055           "projects/project-9334/locations/location-9334/awsClusters/awsCluster-9334/awsNodePools/awsNodePool-9334";
1056       client.getAwsNodePool(name);
1057       Assert.fail("No exception raised");
1058     } catch (InvalidArgumentException e) {
1059       // Expected exception.
1060     }
1061   }
1062 
1063   @Test
listAwsNodePoolsTest()1064   public void listAwsNodePoolsTest() throws Exception {
1065     AwsNodePool responsesElement = AwsNodePool.newBuilder().build();
1066     ListAwsNodePoolsResponse expectedResponse =
1067         ListAwsNodePoolsResponse.newBuilder()
1068             .setNextPageToken("")
1069             .addAllAwsNodePools(Arrays.asList(responsesElement))
1070             .build();
1071     mockService.addResponse(expectedResponse);
1072 
1073     AwsClusterName parent = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
1074 
1075     ListAwsNodePoolsPagedResponse pagedListResponse = client.listAwsNodePools(parent);
1076 
1077     List<AwsNodePool> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1078 
1079     Assert.assertEquals(1, resources.size());
1080     Assert.assertEquals(expectedResponse.getAwsNodePoolsList().get(0), resources.get(0));
1081 
1082     List<String> actualRequests = mockService.getRequestPaths();
1083     Assert.assertEquals(1, actualRequests.size());
1084 
1085     String apiClientHeaderKey =
1086         mockService
1087             .getRequestHeaders()
1088             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1089             .iterator()
1090             .next();
1091     Assert.assertTrue(
1092         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1093             .matcher(apiClientHeaderKey)
1094             .matches());
1095   }
1096 
1097   @Test
listAwsNodePoolsExceptionTest()1098   public void listAwsNodePoolsExceptionTest() throws Exception {
1099     ApiException exception =
1100         ApiExceptionFactory.createException(
1101             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1102     mockService.addException(exception);
1103 
1104     try {
1105       AwsClusterName parent = AwsClusterName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
1106       client.listAwsNodePools(parent);
1107       Assert.fail("No exception raised");
1108     } catch (InvalidArgumentException e) {
1109       // Expected exception.
1110     }
1111   }
1112 
1113   @Test
listAwsNodePoolsTest2()1114   public void listAwsNodePoolsTest2() throws Exception {
1115     AwsNodePool responsesElement = AwsNodePool.newBuilder().build();
1116     ListAwsNodePoolsResponse expectedResponse =
1117         ListAwsNodePoolsResponse.newBuilder()
1118             .setNextPageToken("")
1119             .addAllAwsNodePools(Arrays.asList(responsesElement))
1120             .build();
1121     mockService.addResponse(expectedResponse);
1122 
1123     String parent = "projects/project-2069/locations/location-2069/awsClusters/awsCluster-2069";
1124 
1125     ListAwsNodePoolsPagedResponse pagedListResponse = client.listAwsNodePools(parent);
1126 
1127     List<AwsNodePool> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1128 
1129     Assert.assertEquals(1, resources.size());
1130     Assert.assertEquals(expectedResponse.getAwsNodePoolsList().get(0), resources.get(0));
1131 
1132     List<String> actualRequests = mockService.getRequestPaths();
1133     Assert.assertEquals(1, actualRequests.size());
1134 
1135     String apiClientHeaderKey =
1136         mockService
1137             .getRequestHeaders()
1138             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1139             .iterator()
1140             .next();
1141     Assert.assertTrue(
1142         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1143             .matcher(apiClientHeaderKey)
1144             .matches());
1145   }
1146 
1147   @Test
listAwsNodePoolsExceptionTest2()1148   public void listAwsNodePoolsExceptionTest2() throws Exception {
1149     ApiException exception =
1150         ApiExceptionFactory.createException(
1151             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1152     mockService.addException(exception);
1153 
1154     try {
1155       String parent = "projects/project-2069/locations/location-2069/awsClusters/awsCluster-2069";
1156       client.listAwsNodePools(parent);
1157       Assert.fail("No exception raised");
1158     } catch (InvalidArgumentException e) {
1159       // Expected exception.
1160     }
1161   }
1162 
1163   @Test
deleteAwsNodePoolTest()1164   public void deleteAwsNodePoolTest() throws Exception {
1165     Empty expectedResponse = Empty.newBuilder().build();
1166     Operation resultOperation =
1167         Operation.newBuilder()
1168             .setName("deleteAwsNodePoolTest")
1169             .setDone(true)
1170             .setResponse(Any.pack(expectedResponse))
1171             .build();
1172     mockService.addResponse(resultOperation);
1173 
1174     AwsNodePoolName name =
1175         AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
1176 
1177     client.deleteAwsNodePoolAsync(name).get();
1178 
1179     List<String> actualRequests = mockService.getRequestPaths();
1180     Assert.assertEquals(1, actualRequests.size());
1181 
1182     String apiClientHeaderKey =
1183         mockService
1184             .getRequestHeaders()
1185             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1186             .iterator()
1187             .next();
1188     Assert.assertTrue(
1189         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1190             .matcher(apiClientHeaderKey)
1191             .matches());
1192   }
1193 
1194   @Test
deleteAwsNodePoolExceptionTest()1195   public void deleteAwsNodePoolExceptionTest() throws Exception {
1196     ApiException exception =
1197         ApiExceptionFactory.createException(
1198             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1199     mockService.addException(exception);
1200 
1201     try {
1202       AwsNodePoolName name =
1203           AwsNodePoolName.of("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
1204       client.deleteAwsNodePoolAsync(name).get();
1205       Assert.fail("No exception raised");
1206     } catch (ExecutionException e) {
1207     }
1208   }
1209 
1210   @Test
deleteAwsNodePoolTest2()1211   public void deleteAwsNodePoolTest2() throws Exception {
1212     Empty expectedResponse = Empty.newBuilder().build();
1213     Operation resultOperation =
1214         Operation.newBuilder()
1215             .setName("deleteAwsNodePoolTest")
1216             .setDone(true)
1217             .setResponse(Any.pack(expectedResponse))
1218             .build();
1219     mockService.addResponse(resultOperation);
1220 
1221     String name =
1222         "projects/project-9334/locations/location-9334/awsClusters/awsCluster-9334/awsNodePools/awsNodePool-9334";
1223 
1224     client.deleteAwsNodePoolAsync(name).get();
1225 
1226     List<String> actualRequests = mockService.getRequestPaths();
1227     Assert.assertEquals(1, actualRequests.size());
1228 
1229     String apiClientHeaderKey =
1230         mockService
1231             .getRequestHeaders()
1232             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1233             .iterator()
1234             .next();
1235     Assert.assertTrue(
1236         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1237             .matcher(apiClientHeaderKey)
1238             .matches());
1239   }
1240 
1241   @Test
deleteAwsNodePoolExceptionTest2()1242   public void deleteAwsNodePoolExceptionTest2() throws Exception {
1243     ApiException exception =
1244         ApiExceptionFactory.createException(
1245             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1246     mockService.addException(exception);
1247 
1248     try {
1249       String name =
1250           "projects/project-9334/locations/location-9334/awsClusters/awsCluster-9334/awsNodePools/awsNodePool-9334";
1251       client.deleteAwsNodePoolAsync(name).get();
1252       Assert.fail("No exception raised");
1253     } catch (ExecutionException e) {
1254     }
1255   }
1256 
1257   @Test
getAwsServerConfigTest()1258   public void getAwsServerConfigTest() throws Exception {
1259     AwsServerConfig expectedResponse =
1260         AwsServerConfig.newBuilder()
1261             .setName(AwsServerConfigName.of("[PROJECT]", "[LOCATION]").toString())
1262             .addAllValidVersions(new ArrayList<AwsK8sVersionInfo>())
1263             .addAllSupportedAwsRegions(new ArrayList<String>())
1264             .build();
1265     mockService.addResponse(expectedResponse);
1266 
1267     AwsServerConfigName name = AwsServerConfigName.of("[PROJECT]", "[LOCATION]");
1268 
1269     AwsServerConfig actualResponse = client.getAwsServerConfig(name);
1270     Assert.assertEquals(expectedResponse, actualResponse);
1271 
1272     List<String> actualRequests = mockService.getRequestPaths();
1273     Assert.assertEquals(1, actualRequests.size());
1274 
1275     String apiClientHeaderKey =
1276         mockService
1277             .getRequestHeaders()
1278             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1279             .iterator()
1280             .next();
1281     Assert.assertTrue(
1282         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1283             .matcher(apiClientHeaderKey)
1284             .matches());
1285   }
1286 
1287   @Test
getAwsServerConfigExceptionTest()1288   public void getAwsServerConfigExceptionTest() throws Exception {
1289     ApiException exception =
1290         ApiExceptionFactory.createException(
1291             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1292     mockService.addException(exception);
1293 
1294     try {
1295       AwsServerConfigName name = AwsServerConfigName.of("[PROJECT]", "[LOCATION]");
1296       client.getAwsServerConfig(name);
1297       Assert.fail("No exception raised");
1298     } catch (InvalidArgumentException e) {
1299       // Expected exception.
1300     }
1301   }
1302 
1303   @Test
getAwsServerConfigTest2()1304   public void getAwsServerConfigTest2() throws Exception {
1305     AwsServerConfig expectedResponse =
1306         AwsServerConfig.newBuilder()
1307             .setName(AwsServerConfigName.of("[PROJECT]", "[LOCATION]").toString())
1308             .addAllValidVersions(new ArrayList<AwsK8sVersionInfo>())
1309             .addAllSupportedAwsRegions(new ArrayList<String>())
1310             .build();
1311     mockService.addResponse(expectedResponse);
1312 
1313     String name = "projects/project-5245/locations/location-5245/awsServerConfig";
1314 
1315     AwsServerConfig actualResponse = client.getAwsServerConfig(name);
1316     Assert.assertEquals(expectedResponse, actualResponse);
1317 
1318     List<String> actualRequests = mockService.getRequestPaths();
1319     Assert.assertEquals(1, actualRequests.size());
1320 
1321     String apiClientHeaderKey =
1322         mockService
1323             .getRequestHeaders()
1324             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1325             .iterator()
1326             .next();
1327     Assert.assertTrue(
1328         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1329             .matcher(apiClientHeaderKey)
1330             .matches());
1331   }
1332 
1333   @Test
getAwsServerConfigExceptionTest2()1334   public void getAwsServerConfigExceptionTest2() throws Exception {
1335     ApiException exception =
1336         ApiExceptionFactory.createException(
1337             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1338     mockService.addException(exception);
1339 
1340     try {
1341       String name = "projects/project-5245/locations/location-5245/awsServerConfig";
1342       client.getAwsServerConfig(name);
1343       Assert.fail("No exception raised");
1344     } catch (InvalidArgumentException e) {
1345       // Expected exception.
1346     }
1347   }
1348 }
1349