• 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.alloydb.v1beta;
18 
19 import static com.google.cloud.alloydb.v1beta.AlloyDBAdminClient.ListBackupsPagedResponse;
20 import static com.google.cloud.alloydb.v1beta.AlloyDBAdminClient.ListClustersPagedResponse;
21 import static com.google.cloud.alloydb.v1beta.AlloyDBAdminClient.ListInstancesPagedResponse;
22 import static com.google.cloud.alloydb.v1beta.AlloyDBAdminClient.ListLocationsPagedResponse;
23 import static com.google.cloud.alloydb.v1beta.AlloyDBAdminClient.ListSupportedDatabaseFlagsPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
27 import com.google.api.gax.httpjson.testing.MockHttpService;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.ApiException;
30 import com.google.api.gax.rpc.ApiExceptionFactory;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.api.gax.rpc.StatusCode;
33 import com.google.api.gax.rpc.testing.FakeStatusCode;
34 import com.google.cloud.alloydb.v1beta.stub.HttpJsonAlloyDBAdminStub;
35 import com.google.cloud.location.GetLocationRequest;
36 import com.google.cloud.location.ListLocationsRequest;
37 import com.google.cloud.location.ListLocationsResponse;
38 import com.google.cloud.location.Location;
39 import com.google.common.collect.Lists;
40 import com.google.longrunning.Operation;
41 import com.google.protobuf.Any;
42 import com.google.protobuf.Empty;
43 import com.google.protobuf.FieldMask;
44 import com.google.protobuf.Timestamp;
45 import java.io.IOException;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.HashMap;
49 import java.util.List;
50 import java.util.concurrent.ExecutionException;
51 import javax.annotation.Generated;
52 import org.junit.After;
53 import org.junit.AfterClass;
54 import org.junit.Assert;
55 import org.junit.Before;
56 import org.junit.BeforeClass;
57 import org.junit.Test;
58 
59 @Generated("by gapic-generator-java")
60 public class AlloyDBAdminClientHttpJsonTest {
61   private static MockHttpService mockService;
62   private static AlloyDBAdminClient client;
63 
64   @BeforeClass
startStaticServer()65   public static void startStaticServer() throws IOException {
66     mockService =
67         new MockHttpService(
68             HttpJsonAlloyDBAdminStub.getMethodDescriptors(),
69             AlloyDBAdminSettings.getDefaultEndpoint());
70     AlloyDBAdminSettings settings =
71         AlloyDBAdminSettings.newHttpJsonBuilder()
72             .setTransportChannelProvider(
73                 AlloyDBAdminSettings.defaultHttpJsonTransportProviderBuilder()
74                     .setHttpTransport(mockService)
75                     .build())
76             .setCredentialsProvider(NoCredentialsProvider.create())
77             .build();
78     client = AlloyDBAdminClient.create(settings);
79   }
80 
81   @AfterClass
stopServer()82   public static void stopServer() {
83     client.close();
84   }
85 
86   @Before
setUp()87   public void setUp() {}
88 
89   @After
tearDown()90   public void tearDown() throws Exception {
91     mockService.reset();
92   }
93 
94   @Test
listClustersTest()95   public void listClustersTest() throws Exception {
96     Cluster responsesElement = Cluster.newBuilder().build();
97     ListClustersResponse expectedResponse =
98         ListClustersResponse.newBuilder()
99             .setNextPageToken("")
100             .addAllClusters(Arrays.asList(responsesElement))
101             .build();
102     mockService.addResponse(expectedResponse);
103 
104     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
105 
106     ListClustersPagedResponse pagedListResponse = client.listClusters(parent);
107 
108     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
109 
110     Assert.assertEquals(1, resources.size());
111     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
112 
113     List<String> actualRequests = mockService.getRequestPaths();
114     Assert.assertEquals(1, actualRequests.size());
115 
116     String apiClientHeaderKey =
117         mockService
118             .getRequestHeaders()
119             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
120             .iterator()
121             .next();
122     Assert.assertTrue(
123         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
124             .matcher(apiClientHeaderKey)
125             .matches());
126   }
127 
128   @Test
listClustersExceptionTest()129   public void listClustersExceptionTest() throws Exception {
130     ApiException exception =
131         ApiExceptionFactory.createException(
132             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
133     mockService.addException(exception);
134 
135     try {
136       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
137       client.listClusters(parent);
138       Assert.fail("No exception raised");
139     } catch (InvalidArgumentException e) {
140       // Expected exception.
141     }
142   }
143 
144   @Test
listClustersTest2()145   public void listClustersTest2() throws Exception {
146     Cluster responsesElement = Cluster.newBuilder().build();
147     ListClustersResponse expectedResponse =
148         ListClustersResponse.newBuilder()
149             .setNextPageToken("")
150             .addAllClusters(Arrays.asList(responsesElement))
151             .build();
152     mockService.addResponse(expectedResponse);
153 
154     String parent = "projects/project-5833/locations/location-5833";
155 
156     ListClustersPagedResponse pagedListResponse = client.listClusters(parent);
157 
158     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
159 
160     Assert.assertEquals(1, resources.size());
161     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
162 
163     List<String> actualRequests = mockService.getRequestPaths();
164     Assert.assertEquals(1, actualRequests.size());
165 
166     String apiClientHeaderKey =
167         mockService
168             .getRequestHeaders()
169             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
170             .iterator()
171             .next();
172     Assert.assertTrue(
173         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
174             .matcher(apiClientHeaderKey)
175             .matches());
176   }
177 
178   @Test
listClustersExceptionTest2()179   public void listClustersExceptionTest2() throws Exception {
180     ApiException exception =
181         ApiExceptionFactory.createException(
182             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
183     mockService.addException(exception);
184 
185     try {
186       String parent = "projects/project-5833/locations/location-5833";
187       client.listClusters(parent);
188       Assert.fail("No exception raised");
189     } catch (InvalidArgumentException e) {
190       // Expected exception.
191     }
192   }
193 
194   @Test
getClusterTest()195   public void getClusterTest() throws Exception {
196     Cluster expectedResponse =
197         Cluster.newBuilder()
198             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
199             .setDisplayName("displayName1714148973")
200             .setUid("uid115792")
201             .setCreateTime(Timestamp.newBuilder().build())
202             .setUpdateTime(Timestamp.newBuilder().build())
203             .setDeleteTime(Timestamp.newBuilder().build())
204             .putAllLabels(new HashMap<String, String>())
205             .setDatabaseVersion(DatabaseVersion.forNumber(0))
206             .setNetwork("network1843485230")
207             .setEtag("etag3123477")
208             .putAllAnnotations(new HashMap<String, String>())
209             .setReconciling(true)
210             .setInitialUser(UserPassword.newBuilder().build())
211             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
212             .setSslConfig(SslConfig.newBuilder().build())
213             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
214             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
215             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
216             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
217             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
218             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
219             .build();
220     mockService.addResponse(expectedResponse);
221 
222     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
223 
224     Cluster actualResponse = client.getCluster(name);
225     Assert.assertEquals(expectedResponse, actualResponse);
226 
227     List<String> actualRequests = mockService.getRequestPaths();
228     Assert.assertEquals(1, actualRequests.size());
229 
230     String apiClientHeaderKey =
231         mockService
232             .getRequestHeaders()
233             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
234             .iterator()
235             .next();
236     Assert.assertTrue(
237         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
238             .matcher(apiClientHeaderKey)
239             .matches());
240   }
241 
242   @Test
getClusterExceptionTest()243   public void getClusterExceptionTest() throws Exception {
244     ApiException exception =
245         ApiExceptionFactory.createException(
246             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
247     mockService.addException(exception);
248 
249     try {
250       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
251       client.getCluster(name);
252       Assert.fail("No exception raised");
253     } catch (InvalidArgumentException e) {
254       // Expected exception.
255     }
256   }
257 
258   @Test
getClusterTest2()259   public void getClusterTest2() throws Exception {
260     Cluster expectedResponse =
261         Cluster.newBuilder()
262             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
263             .setDisplayName("displayName1714148973")
264             .setUid("uid115792")
265             .setCreateTime(Timestamp.newBuilder().build())
266             .setUpdateTime(Timestamp.newBuilder().build())
267             .setDeleteTime(Timestamp.newBuilder().build())
268             .putAllLabels(new HashMap<String, String>())
269             .setDatabaseVersion(DatabaseVersion.forNumber(0))
270             .setNetwork("network1843485230")
271             .setEtag("etag3123477")
272             .putAllAnnotations(new HashMap<String, String>())
273             .setReconciling(true)
274             .setInitialUser(UserPassword.newBuilder().build())
275             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
276             .setSslConfig(SslConfig.newBuilder().build())
277             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
278             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
279             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
280             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
281             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
282             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
283             .build();
284     mockService.addResponse(expectedResponse);
285 
286     String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
287 
288     Cluster actualResponse = client.getCluster(name);
289     Assert.assertEquals(expectedResponse, actualResponse);
290 
291     List<String> actualRequests = mockService.getRequestPaths();
292     Assert.assertEquals(1, actualRequests.size());
293 
294     String apiClientHeaderKey =
295         mockService
296             .getRequestHeaders()
297             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
298             .iterator()
299             .next();
300     Assert.assertTrue(
301         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
302             .matcher(apiClientHeaderKey)
303             .matches());
304   }
305 
306   @Test
getClusterExceptionTest2()307   public void getClusterExceptionTest2() throws Exception {
308     ApiException exception =
309         ApiExceptionFactory.createException(
310             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
311     mockService.addException(exception);
312 
313     try {
314       String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
315       client.getCluster(name);
316       Assert.fail("No exception raised");
317     } catch (InvalidArgumentException e) {
318       // Expected exception.
319     }
320   }
321 
322   @Test
createClusterTest()323   public void createClusterTest() throws Exception {
324     Cluster expectedResponse =
325         Cluster.newBuilder()
326             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
327             .setDisplayName("displayName1714148973")
328             .setUid("uid115792")
329             .setCreateTime(Timestamp.newBuilder().build())
330             .setUpdateTime(Timestamp.newBuilder().build())
331             .setDeleteTime(Timestamp.newBuilder().build())
332             .putAllLabels(new HashMap<String, String>())
333             .setDatabaseVersion(DatabaseVersion.forNumber(0))
334             .setNetwork("network1843485230")
335             .setEtag("etag3123477")
336             .putAllAnnotations(new HashMap<String, String>())
337             .setReconciling(true)
338             .setInitialUser(UserPassword.newBuilder().build())
339             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
340             .setSslConfig(SslConfig.newBuilder().build())
341             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
342             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
343             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
344             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
345             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
346             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
347             .build();
348     Operation resultOperation =
349         Operation.newBuilder()
350             .setName("createClusterTest")
351             .setDone(true)
352             .setResponse(Any.pack(expectedResponse))
353             .build();
354     mockService.addResponse(resultOperation);
355 
356     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
357     Cluster cluster = Cluster.newBuilder().build();
358     String clusterId = "clusterId561939637";
359 
360     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
361     Assert.assertEquals(expectedResponse, actualResponse);
362 
363     List<String> actualRequests = mockService.getRequestPaths();
364     Assert.assertEquals(1, actualRequests.size());
365 
366     String apiClientHeaderKey =
367         mockService
368             .getRequestHeaders()
369             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
370             .iterator()
371             .next();
372     Assert.assertTrue(
373         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
374             .matcher(apiClientHeaderKey)
375             .matches());
376   }
377 
378   @Test
createClusterExceptionTest()379   public void createClusterExceptionTest() throws Exception {
380     ApiException exception =
381         ApiExceptionFactory.createException(
382             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
383     mockService.addException(exception);
384 
385     try {
386       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
387       Cluster cluster = Cluster.newBuilder().build();
388       String clusterId = "clusterId561939637";
389       client.createClusterAsync(parent, cluster, clusterId).get();
390       Assert.fail("No exception raised");
391     } catch (ExecutionException e) {
392     }
393   }
394 
395   @Test
createClusterTest2()396   public void createClusterTest2() throws Exception {
397     Cluster expectedResponse =
398         Cluster.newBuilder()
399             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
400             .setDisplayName("displayName1714148973")
401             .setUid("uid115792")
402             .setCreateTime(Timestamp.newBuilder().build())
403             .setUpdateTime(Timestamp.newBuilder().build())
404             .setDeleteTime(Timestamp.newBuilder().build())
405             .putAllLabels(new HashMap<String, String>())
406             .setDatabaseVersion(DatabaseVersion.forNumber(0))
407             .setNetwork("network1843485230")
408             .setEtag("etag3123477")
409             .putAllAnnotations(new HashMap<String, String>())
410             .setReconciling(true)
411             .setInitialUser(UserPassword.newBuilder().build())
412             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
413             .setSslConfig(SslConfig.newBuilder().build())
414             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
415             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
416             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
417             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
418             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
419             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
420             .build();
421     Operation resultOperation =
422         Operation.newBuilder()
423             .setName("createClusterTest")
424             .setDone(true)
425             .setResponse(Any.pack(expectedResponse))
426             .build();
427     mockService.addResponse(resultOperation);
428 
429     String parent = "projects/project-5833/locations/location-5833";
430     Cluster cluster = Cluster.newBuilder().build();
431     String clusterId = "clusterId561939637";
432 
433     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
434     Assert.assertEquals(expectedResponse, actualResponse);
435 
436     List<String> actualRequests = mockService.getRequestPaths();
437     Assert.assertEquals(1, actualRequests.size());
438 
439     String apiClientHeaderKey =
440         mockService
441             .getRequestHeaders()
442             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
443             .iterator()
444             .next();
445     Assert.assertTrue(
446         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
447             .matcher(apiClientHeaderKey)
448             .matches());
449   }
450 
451   @Test
createClusterExceptionTest2()452   public void createClusterExceptionTest2() throws Exception {
453     ApiException exception =
454         ApiExceptionFactory.createException(
455             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
456     mockService.addException(exception);
457 
458     try {
459       String parent = "projects/project-5833/locations/location-5833";
460       Cluster cluster = Cluster.newBuilder().build();
461       String clusterId = "clusterId561939637";
462       client.createClusterAsync(parent, cluster, clusterId).get();
463       Assert.fail("No exception raised");
464     } catch (ExecutionException e) {
465     }
466   }
467 
468   @Test
updateClusterTest()469   public void updateClusterTest() throws Exception {
470     Cluster expectedResponse =
471         Cluster.newBuilder()
472             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
473             .setDisplayName("displayName1714148973")
474             .setUid("uid115792")
475             .setCreateTime(Timestamp.newBuilder().build())
476             .setUpdateTime(Timestamp.newBuilder().build())
477             .setDeleteTime(Timestamp.newBuilder().build())
478             .putAllLabels(new HashMap<String, String>())
479             .setDatabaseVersion(DatabaseVersion.forNumber(0))
480             .setNetwork("network1843485230")
481             .setEtag("etag3123477")
482             .putAllAnnotations(new HashMap<String, String>())
483             .setReconciling(true)
484             .setInitialUser(UserPassword.newBuilder().build())
485             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
486             .setSslConfig(SslConfig.newBuilder().build())
487             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
488             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
489             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
490             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
491             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
492             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
493             .build();
494     Operation resultOperation =
495         Operation.newBuilder()
496             .setName("updateClusterTest")
497             .setDone(true)
498             .setResponse(Any.pack(expectedResponse))
499             .build();
500     mockService.addResponse(resultOperation);
501 
502     Cluster cluster =
503         Cluster.newBuilder()
504             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
505             .setDisplayName("displayName1714148973")
506             .setUid("uid115792")
507             .setCreateTime(Timestamp.newBuilder().build())
508             .setUpdateTime(Timestamp.newBuilder().build())
509             .setDeleteTime(Timestamp.newBuilder().build())
510             .putAllLabels(new HashMap<String, String>())
511             .setDatabaseVersion(DatabaseVersion.forNumber(0))
512             .setNetwork("network1843485230")
513             .setEtag("etag3123477")
514             .putAllAnnotations(new HashMap<String, String>())
515             .setReconciling(true)
516             .setInitialUser(UserPassword.newBuilder().build())
517             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
518             .setSslConfig(SslConfig.newBuilder().build())
519             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
520             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
521             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
522             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
523             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
524             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
525             .build();
526     FieldMask updateMask = FieldMask.newBuilder().build();
527 
528     Cluster actualResponse = client.updateClusterAsync(cluster, updateMask).get();
529     Assert.assertEquals(expectedResponse, actualResponse);
530 
531     List<String> actualRequests = mockService.getRequestPaths();
532     Assert.assertEquals(1, actualRequests.size());
533 
534     String apiClientHeaderKey =
535         mockService
536             .getRequestHeaders()
537             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
538             .iterator()
539             .next();
540     Assert.assertTrue(
541         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
542             .matcher(apiClientHeaderKey)
543             .matches());
544   }
545 
546   @Test
updateClusterExceptionTest()547   public void updateClusterExceptionTest() throws Exception {
548     ApiException exception =
549         ApiExceptionFactory.createException(
550             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
551     mockService.addException(exception);
552 
553     try {
554       Cluster cluster =
555           Cluster.newBuilder()
556               .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
557               .setDisplayName("displayName1714148973")
558               .setUid("uid115792")
559               .setCreateTime(Timestamp.newBuilder().build())
560               .setUpdateTime(Timestamp.newBuilder().build())
561               .setDeleteTime(Timestamp.newBuilder().build())
562               .putAllLabels(new HashMap<String, String>())
563               .setDatabaseVersion(DatabaseVersion.forNumber(0))
564               .setNetwork("network1843485230")
565               .setEtag("etag3123477")
566               .putAllAnnotations(new HashMap<String, String>())
567               .setReconciling(true)
568               .setInitialUser(UserPassword.newBuilder().build())
569               .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
570               .setSslConfig(SslConfig.newBuilder().build())
571               .setEncryptionConfig(EncryptionConfig.newBuilder().build())
572               .setEncryptionInfo(EncryptionInfo.newBuilder().build())
573               .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
574               .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
575               .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
576               .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
577               .build();
578       FieldMask updateMask = FieldMask.newBuilder().build();
579       client.updateClusterAsync(cluster, updateMask).get();
580       Assert.fail("No exception raised");
581     } catch (ExecutionException e) {
582     }
583   }
584 
585   @Test
deleteClusterTest()586   public void deleteClusterTest() throws Exception {
587     Empty expectedResponse = Empty.newBuilder().build();
588     Operation resultOperation =
589         Operation.newBuilder()
590             .setName("deleteClusterTest")
591             .setDone(true)
592             .setResponse(Any.pack(expectedResponse))
593             .build();
594     mockService.addResponse(resultOperation);
595 
596     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
597 
598     client.deleteClusterAsync(name).get();
599 
600     List<String> actualRequests = mockService.getRequestPaths();
601     Assert.assertEquals(1, actualRequests.size());
602 
603     String apiClientHeaderKey =
604         mockService
605             .getRequestHeaders()
606             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
607             .iterator()
608             .next();
609     Assert.assertTrue(
610         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
611             .matcher(apiClientHeaderKey)
612             .matches());
613   }
614 
615   @Test
deleteClusterExceptionTest()616   public void deleteClusterExceptionTest() throws Exception {
617     ApiException exception =
618         ApiExceptionFactory.createException(
619             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
620     mockService.addException(exception);
621 
622     try {
623       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
624       client.deleteClusterAsync(name).get();
625       Assert.fail("No exception raised");
626     } catch (ExecutionException e) {
627     }
628   }
629 
630   @Test
deleteClusterTest2()631   public void deleteClusterTest2() throws Exception {
632     Empty expectedResponse = Empty.newBuilder().build();
633     Operation resultOperation =
634         Operation.newBuilder()
635             .setName("deleteClusterTest")
636             .setDone(true)
637             .setResponse(Any.pack(expectedResponse))
638             .build();
639     mockService.addResponse(resultOperation);
640 
641     String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
642 
643     client.deleteClusterAsync(name).get();
644 
645     List<String> actualRequests = mockService.getRequestPaths();
646     Assert.assertEquals(1, actualRequests.size());
647 
648     String apiClientHeaderKey =
649         mockService
650             .getRequestHeaders()
651             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
652             .iterator()
653             .next();
654     Assert.assertTrue(
655         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
656             .matcher(apiClientHeaderKey)
657             .matches());
658   }
659 
660   @Test
deleteClusterExceptionTest2()661   public void deleteClusterExceptionTest2() throws Exception {
662     ApiException exception =
663         ApiExceptionFactory.createException(
664             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
665     mockService.addException(exception);
666 
667     try {
668       String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
669       client.deleteClusterAsync(name).get();
670       Assert.fail("No exception raised");
671     } catch (ExecutionException e) {
672     }
673   }
674 
675   @Test
promoteClusterTest()676   public void promoteClusterTest() throws Exception {
677     Cluster expectedResponse =
678         Cluster.newBuilder()
679             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
680             .setDisplayName("displayName1714148973")
681             .setUid("uid115792")
682             .setCreateTime(Timestamp.newBuilder().build())
683             .setUpdateTime(Timestamp.newBuilder().build())
684             .setDeleteTime(Timestamp.newBuilder().build())
685             .putAllLabels(new HashMap<String, String>())
686             .setDatabaseVersion(DatabaseVersion.forNumber(0))
687             .setNetwork("network1843485230")
688             .setEtag("etag3123477")
689             .putAllAnnotations(new HashMap<String, String>())
690             .setReconciling(true)
691             .setInitialUser(UserPassword.newBuilder().build())
692             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
693             .setSslConfig(SslConfig.newBuilder().build())
694             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
695             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
696             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
697             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
698             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
699             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
700             .build();
701     Operation resultOperation =
702         Operation.newBuilder()
703             .setName("promoteClusterTest")
704             .setDone(true)
705             .setResponse(Any.pack(expectedResponse))
706             .build();
707     mockService.addResponse(resultOperation);
708 
709     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
710 
711     Cluster actualResponse = client.promoteClusterAsync(name).get();
712     Assert.assertEquals(expectedResponse, actualResponse);
713 
714     List<String> actualRequests = mockService.getRequestPaths();
715     Assert.assertEquals(1, actualRequests.size());
716 
717     String apiClientHeaderKey =
718         mockService
719             .getRequestHeaders()
720             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
721             .iterator()
722             .next();
723     Assert.assertTrue(
724         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
725             .matcher(apiClientHeaderKey)
726             .matches());
727   }
728 
729   @Test
promoteClusterExceptionTest()730   public void promoteClusterExceptionTest() throws Exception {
731     ApiException exception =
732         ApiExceptionFactory.createException(
733             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
734     mockService.addException(exception);
735 
736     try {
737       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
738       client.promoteClusterAsync(name).get();
739       Assert.fail("No exception raised");
740     } catch (ExecutionException e) {
741     }
742   }
743 
744   @Test
promoteClusterTest2()745   public void promoteClusterTest2() throws Exception {
746     Cluster expectedResponse =
747         Cluster.newBuilder()
748             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
749             .setDisplayName("displayName1714148973")
750             .setUid("uid115792")
751             .setCreateTime(Timestamp.newBuilder().build())
752             .setUpdateTime(Timestamp.newBuilder().build())
753             .setDeleteTime(Timestamp.newBuilder().build())
754             .putAllLabels(new HashMap<String, String>())
755             .setDatabaseVersion(DatabaseVersion.forNumber(0))
756             .setNetwork("network1843485230")
757             .setEtag("etag3123477")
758             .putAllAnnotations(new HashMap<String, String>())
759             .setReconciling(true)
760             .setInitialUser(UserPassword.newBuilder().build())
761             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
762             .setSslConfig(SslConfig.newBuilder().build())
763             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
764             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
765             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
766             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
767             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
768             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
769             .build();
770     Operation resultOperation =
771         Operation.newBuilder()
772             .setName("promoteClusterTest")
773             .setDone(true)
774             .setResponse(Any.pack(expectedResponse))
775             .build();
776     mockService.addResponse(resultOperation);
777 
778     String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
779 
780     Cluster actualResponse = client.promoteClusterAsync(name).get();
781     Assert.assertEquals(expectedResponse, actualResponse);
782 
783     List<String> actualRequests = mockService.getRequestPaths();
784     Assert.assertEquals(1, actualRequests.size());
785 
786     String apiClientHeaderKey =
787         mockService
788             .getRequestHeaders()
789             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
790             .iterator()
791             .next();
792     Assert.assertTrue(
793         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
794             .matcher(apiClientHeaderKey)
795             .matches());
796   }
797 
798   @Test
promoteClusterExceptionTest2()799   public void promoteClusterExceptionTest2() throws Exception {
800     ApiException exception =
801         ApiExceptionFactory.createException(
802             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
803     mockService.addException(exception);
804 
805     try {
806       String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
807       client.promoteClusterAsync(name).get();
808       Assert.fail("No exception raised");
809     } catch (ExecutionException e) {
810     }
811   }
812 
813   @Test
restoreClusterTest()814   public void restoreClusterTest() throws Exception {
815     Cluster expectedResponse =
816         Cluster.newBuilder()
817             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
818             .setDisplayName("displayName1714148973")
819             .setUid("uid115792")
820             .setCreateTime(Timestamp.newBuilder().build())
821             .setUpdateTime(Timestamp.newBuilder().build())
822             .setDeleteTime(Timestamp.newBuilder().build())
823             .putAllLabels(new HashMap<String, String>())
824             .setDatabaseVersion(DatabaseVersion.forNumber(0))
825             .setNetwork("network1843485230")
826             .setEtag("etag3123477")
827             .putAllAnnotations(new HashMap<String, String>())
828             .setReconciling(true)
829             .setInitialUser(UserPassword.newBuilder().build())
830             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
831             .setSslConfig(SslConfig.newBuilder().build())
832             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
833             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
834             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
835             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
836             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
837             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
838             .build();
839     Operation resultOperation =
840         Operation.newBuilder()
841             .setName("restoreClusterTest")
842             .setDone(true)
843             .setResponse(Any.pack(expectedResponse))
844             .build();
845     mockService.addResponse(resultOperation);
846 
847     RestoreClusterRequest request =
848         RestoreClusterRequest.newBuilder()
849             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
850             .setClusterId("clusterId561939637")
851             .setCluster(Cluster.newBuilder().build())
852             .setRequestId("requestId693933066")
853             .setValidateOnly(true)
854             .build();
855 
856     Cluster actualResponse = client.restoreClusterAsync(request).get();
857     Assert.assertEquals(expectedResponse, actualResponse);
858 
859     List<String> actualRequests = mockService.getRequestPaths();
860     Assert.assertEquals(1, actualRequests.size());
861 
862     String apiClientHeaderKey =
863         mockService
864             .getRequestHeaders()
865             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
866             .iterator()
867             .next();
868     Assert.assertTrue(
869         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
870             .matcher(apiClientHeaderKey)
871             .matches());
872   }
873 
874   @Test
restoreClusterExceptionTest()875   public void restoreClusterExceptionTest() throws Exception {
876     ApiException exception =
877         ApiExceptionFactory.createException(
878             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
879     mockService.addException(exception);
880 
881     try {
882       RestoreClusterRequest request =
883           RestoreClusterRequest.newBuilder()
884               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
885               .setClusterId("clusterId561939637")
886               .setCluster(Cluster.newBuilder().build())
887               .setRequestId("requestId693933066")
888               .setValidateOnly(true)
889               .build();
890       client.restoreClusterAsync(request).get();
891       Assert.fail("No exception raised");
892     } catch (ExecutionException e) {
893     }
894   }
895 
896   @Test
createSecondaryClusterTest()897   public void createSecondaryClusterTest() throws Exception {
898     Cluster expectedResponse =
899         Cluster.newBuilder()
900             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
901             .setDisplayName("displayName1714148973")
902             .setUid("uid115792")
903             .setCreateTime(Timestamp.newBuilder().build())
904             .setUpdateTime(Timestamp.newBuilder().build())
905             .setDeleteTime(Timestamp.newBuilder().build())
906             .putAllLabels(new HashMap<String, String>())
907             .setDatabaseVersion(DatabaseVersion.forNumber(0))
908             .setNetwork("network1843485230")
909             .setEtag("etag3123477")
910             .putAllAnnotations(new HashMap<String, String>())
911             .setReconciling(true)
912             .setInitialUser(UserPassword.newBuilder().build())
913             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
914             .setSslConfig(SslConfig.newBuilder().build())
915             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
916             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
917             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
918             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
919             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
920             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
921             .build();
922     Operation resultOperation =
923         Operation.newBuilder()
924             .setName("createSecondaryClusterTest")
925             .setDone(true)
926             .setResponse(Any.pack(expectedResponse))
927             .build();
928     mockService.addResponse(resultOperation);
929 
930     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
931     Cluster cluster = Cluster.newBuilder().build();
932     String clusterId = "clusterId561939637";
933 
934     Cluster actualResponse = client.createSecondaryClusterAsync(parent, cluster, clusterId).get();
935     Assert.assertEquals(expectedResponse, actualResponse);
936 
937     List<String> actualRequests = mockService.getRequestPaths();
938     Assert.assertEquals(1, actualRequests.size());
939 
940     String apiClientHeaderKey =
941         mockService
942             .getRequestHeaders()
943             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
944             .iterator()
945             .next();
946     Assert.assertTrue(
947         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
948             .matcher(apiClientHeaderKey)
949             .matches());
950   }
951 
952   @Test
createSecondaryClusterExceptionTest()953   public void createSecondaryClusterExceptionTest() throws Exception {
954     ApiException exception =
955         ApiExceptionFactory.createException(
956             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
957     mockService.addException(exception);
958 
959     try {
960       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
961       Cluster cluster = Cluster.newBuilder().build();
962       String clusterId = "clusterId561939637";
963       client.createSecondaryClusterAsync(parent, cluster, clusterId).get();
964       Assert.fail("No exception raised");
965     } catch (ExecutionException e) {
966     }
967   }
968 
969   @Test
createSecondaryClusterTest2()970   public void createSecondaryClusterTest2() throws Exception {
971     Cluster expectedResponse =
972         Cluster.newBuilder()
973             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
974             .setDisplayName("displayName1714148973")
975             .setUid("uid115792")
976             .setCreateTime(Timestamp.newBuilder().build())
977             .setUpdateTime(Timestamp.newBuilder().build())
978             .setDeleteTime(Timestamp.newBuilder().build())
979             .putAllLabels(new HashMap<String, String>())
980             .setDatabaseVersion(DatabaseVersion.forNumber(0))
981             .setNetwork("network1843485230")
982             .setEtag("etag3123477")
983             .putAllAnnotations(new HashMap<String, String>())
984             .setReconciling(true)
985             .setInitialUser(UserPassword.newBuilder().build())
986             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
987             .setSslConfig(SslConfig.newBuilder().build())
988             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
989             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
990             .setContinuousBackupConfig(ContinuousBackupConfig.newBuilder().build())
991             .setContinuousBackupInfo(ContinuousBackupInfo.newBuilder().build())
992             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
993             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
994             .build();
995     Operation resultOperation =
996         Operation.newBuilder()
997             .setName("createSecondaryClusterTest")
998             .setDone(true)
999             .setResponse(Any.pack(expectedResponse))
1000             .build();
1001     mockService.addResponse(resultOperation);
1002 
1003     String parent = "projects/project-5833/locations/location-5833";
1004     Cluster cluster = Cluster.newBuilder().build();
1005     String clusterId = "clusterId561939637";
1006 
1007     Cluster actualResponse = client.createSecondaryClusterAsync(parent, cluster, clusterId).get();
1008     Assert.assertEquals(expectedResponse, actualResponse);
1009 
1010     List<String> actualRequests = mockService.getRequestPaths();
1011     Assert.assertEquals(1, actualRequests.size());
1012 
1013     String apiClientHeaderKey =
1014         mockService
1015             .getRequestHeaders()
1016             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1017             .iterator()
1018             .next();
1019     Assert.assertTrue(
1020         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1021             .matcher(apiClientHeaderKey)
1022             .matches());
1023   }
1024 
1025   @Test
createSecondaryClusterExceptionTest2()1026   public void createSecondaryClusterExceptionTest2() throws Exception {
1027     ApiException exception =
1028         ApiExceptionFactory.createException(
1029             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1030     mockService.addException(exception);
1031 
1032     try {
1033       String parent = "projects/project-5833/locations/location-5833";
1034       Cluster cluster = Cluster.newBuilder().build();
1035       String clusterId = "clusterId561939637";
1036       client.createSecondaryClusterAsync(parent, cluster, clusterId).get();
1037       Assert.fail("No exception raised");
1038     } catch (ExecutionException e) {
1039     }
1040   }
1041 
1042   @Test
listInstancesTest()1043   public void listInstancesTest() throws Exception {
1044     Instance responsesElement = Instance.newBuilder().build();
1045     ListInstancesResponse expectedResponse =
1046         ListInstancesResponse.newBuilder()
1047             .setNextPageToken("")
1048             .addAllInstances(Arrays.asList(responsesElement))
1049             .build();
1050     mockService.addResponse(expectedResponse);
1051 
1052     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1053 
1054     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
1055 
1056     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1057 
1058     Assert.assertEquals(1, resources.size());
1059     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
1060 
1061     List<String> actualRequests = mockService.getRequestPaths();
1062     Assert.assertEquals(1, actualRequests.size());
1063 
1064     String apiClientHeaderKey =
1065         mockService
1066             .getRequestHeaders()
1067             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1068             .iterator()
1069             .next();
1070     Assert.assertTrue(
1071         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1072             .matcher(apiClientHeaderKey)
1073             .matches());
1074   }
1075 
1076   @Test
listInstancesExceptionTest()1077   public void listInstancesExceptionTest() throws Exception {
1078     ApiException exception =
1079         ApiExceptionFactory.createException(
1080             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1081     mockService.addException(exception);
1082 
1083     try {
1084       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1085       client.listInstances(parent);
1086       Assert.fail("No exception raised");
1087     } catch (InvalidArgumentException e) {
1088       // Expected exception.
1089     }
1090   }
1091 
1092   @Test
listInstancesTest2()1093   public void listInstancesTest2() throws Exception {
1094     Instance responsesElement = Instance.newBuilder().build();
1095     ListInstancesResponse expectedResponse =
1096         ListInstancesResponse.newBuilder()
1097             .setNextPageToken("")
1098             .addAllInstances(Arrays.asList(responsesElement))
1099             .build();
1100     mockService.addResponse(expectedResponse);
1101 
1102     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1103 
1104     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
1105 
1106     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1107 
1108     Assert.assertEquals(1, resources.size());
1109     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
1110 
1111     List<String> actualRequests = mockService.getRequestPaths();
1112     Assert.assertEquals(1, actualRequests.size());
1113 
1114     String apiClientHeaderKey =
1115         mockService
1116             .getRequestHeaders()
1117             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1118             .iterator()
1119             .next();
1120     Assert.assertTrue(
1121         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1122             .matcher(apiClientHeaderKey)
1123             .matches());
1124   }
1125 
1126   @Test
listInstancesExceptionTest2()1127   public void listInstancesExceptionTest2() throws Exception {
1128     ApiException exception =
1129         ApiExceptionFactory.createException(
1130             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1131     mockService.addException(exception);
1132 
1133     try {
1134       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1135       client.listInstances(parent);
1136       Assert.fail("No exception raised");
1137     } catch (InvalidArgumentException e) {
1138       // Expected exception.
1139     }
1140   }
1141 
1142   @Test
getInstanceTest()1143   public void getInstanceTest() throws Exception {
1144     Instance expectedResponse =
1145         Instance.newBuilder()
1146             .setName(
1147                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1148             .setDisplayName("displayName1714148973")
1149             .setUid("uid115792")
1150             .setCreateTime(Timestamp.newBuilder().build())
1151             .setUpdateTime(Timestamp.newBuilder().build())
1152             .setDeleteTime(Timestamp.newBuilder().build())
1153             .putAllLabels(new HashMap<String, String>())
1154             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1155             .setGceZone("gceZone-146048427")
1156             .putAllDatabaseFlags(new HashMap<String, String>())
1157             .setWritableNode(Instance.Node.newBuilder().build())
1158             .addAllNodes(new ArrayList<Instance.Node>())
1159             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1160             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1161             .setIpAddress("ipAddress1634032845")
1162             .setReconciling(true)
1163             .setEtag("etag3123477")
1164             .putAllAnnotations(new HashMap<String, String>())
1165             .build();
1166     mockService.addResponse(expectedResponse);
1167 
1168     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1169 
1170     Instance actualResponse = client.getInstance(name);
1171     Assert.assertEquals(expectedResponse, actualResponse);
1172 
1173     List<String> actualRequests = mockService.getRequestPaths();
1174     Assert.assertEquals(1, actualRequests.size());
1175 
1176     String apiClientHeaderKey =
1177         mockService
1178             .getRequestHeaders()
1179             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1180             .iterator()
1181             .next();
1182     Assert.assertTrue(
1183         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1184             .matcher(apiClientHeaderKey)
1185             .matches());
1186   }
1187 
1188   @Test
getInstanceExceptionTest()1189   public void getInstanceExceptionTest() throws Exception {
1190     ApiException exception =
1191         ApiExceptionFactory.createException(
1192             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1193     mockService.addException(exception);
1194 
1195     try {
1196       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1197       client.getInstance(name);
1198       Assert.fail("No exception raised");
1199     } catch (InvalidArgumentException e) {
1200       // Expected exception.
1201     }
1202   }
1203 
1204   @Test
getInstanceTest2()1205   public void getInstanceTest2() throws Exception {
1206     Instance expectedResponse =
1207         Instance.newBuilder()
1208             .setName(
1209                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1210             .setDisplayName("displayName1714148973")
1211             .setUid("uid115792")
1212             .setCreateTime(Timestamp.newBuilder().build())
1213             .setUpdateTime(Timestamp.newBuilder().build())
1214             .setDeleteTime(Timestamp.newBuilder().build())
1215             .putAllLabels(new HashMap<String, String>())
1216             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1217             .setGceZone("gceZone-146048427")
1218             .putAllDatabaseFlags(new HashMap<String, String>())
1219             .setWritableNode(Instance.Node.newBuilder().build())
1220             .addAllNodes(new ArrayList<Instance.Node>())
1221             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1222             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1223             .setIpAddress("ipAddress1634032845")
1224             .setReconciling(true)
1225             .setEtag("etag3123477")
1226             .putAllAnnotations(new HashMap<String, String>())
1227             .build();
1228     mockService.addResponse(expectedResponse);
1229 
1230     String name =
1231         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1232 
1233     Instance actualResponse = client.getInstance(name);
1234     Assert.assertEquals(expectedResponse, actualResponse);
1235 
1236     List<String> actualRequests = mockService.getRequestPaths();
1237     Assert.assertEquals(1, actualRequests.size());
1238 
1239     String apiClientHeaderKey =
1240         mockService
1241             .getRequestHeaders()
1242             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1243             .iterator()
1244             .next();
1245     Assert.assertTrue(
1246         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1247             .matcher(apiClientHeaderKey)
1248             .matches());
1249   }
1250 
1251   @Test
getInstanceExceptionTest2()1252   public void getInstanceExceptionTest2() throws Exception {
1253     ApiException exception =
1254         ApiExceptionFactory.createException(
1255             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1256     mockService.addException(exception);
1257 
1258     try {
1259       String name =
1260           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1261       client.getInstance(name);
1262       Assert.fail("No exception raised");
1263     } catch (InvalidArgumentException e) {
1264       // Expected exception.
1265     }
1266   }
1267 
1268   @Test
createInstanceTest()1269   public void createInstanceTest() throws Exception {
1270     Instance expectedResponse =
1271         Instance.newBuilder()
1272             .setName(
1273                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1274             .setDisplayName("displayName1714148973")
1275             .setUid("uid115792")
1276             .setCreateTime(Timestamp.newBuilder().build())
1277             .setUpdateTime(Timestamp.newBuilder().build())
1278             .setDeleteTime(Timestamp.newBuilder().build())
1279             .putAllLabels(new HashMap<String, String>())
1280             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1281             .setGceZone("gceZone-146048427")
1282             .putAllDatabaseFlags(new HashMap<String, String>())
1283             .setWritableNode(Instance.Node.newBuilder().build())
1284             .addAllNodes(new ArrayList<Instance.Node>())
1285             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1286             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1287             .setIpAddress("ipAddress1634032845")
1288             .setReconciling(true)
1289             .setEtag("etag3123477")
1290             .putAllAnnotations(new HashMap<String, String>())
1291             .build();
1292     Operation resultOperation =
1293         Operation.newBuilder()
1294             .setName("createInstanceTest")
1295             .setDone(true)
1296             .setResponse(Any.pack(expectedResponse))
1297             .build();
1298     mockService.addResponse(resultOperation);
1299 
1300     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1301     Instance instance = Instance.newBuilder().build();
1302     String instanceId = "instanceId902024336";
1303 
1304     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
1305     Assert.assertEquals(expectedResponse, actualResponse);
1306 
1307     List<String> actualRequests = mockService.getRequestPaths();
1308     Assert.assertEquals(1, actualRequests.size());
1309 
1310     String apiClientHeaderKey =
1311         mockService
1312             .getRequestHeaders()
1313             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1314             .iterator()
1315             .next();
1316     Assert.assertTrue(
1317         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1318             .matcher(apiClientHeaderKey)
1319             .matches());
1320   }
1321 
1322   @Test
createInstanceExceptionTest()1323   public void createInstanceExceptionTest() throws Exception {
1324     ApiException exception =
1325         ApiExceptionFactory.createException(
1326             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1327     mockService.addException(exception);
1328 
1329     try {
1330       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1331       Instance instance = Instance.newBuilder().build();
1332       String instanceId = "instanceId902024336";
1333       client.createInstanceAsync(parent, instance, instanceId).get();
1334       Assert.fail("No exception raised");
1335     } catch (ExecutionException e) {
1336     }
1337   }
1338 
1339   @Test
createInstanceTest2()1340   public void createInstanceTest2() throws Exception {
1341     Instance expectedResponse =
1342         Instance.newBuilder()
1343             .setName(
1344                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1345             .setDisplayName("displayName1714148973")
1346             .setUid("uid115792")
1347             .setCreateTime(Timestamp.newBuilder().build())
1348             .setUpdateTime(Timestamp.newBuilder().build())
1349             .setDeleteTime(Timestamp.newBuilder().build())
1350             .putAllLabels(new HashMap<String, String>())
1351             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1352             .setGceZone("gceZone-146048427")
1353             .putAllDatabaseFlags(new HashMap<String, String>())
1354             .setWritableNode(Instance.Node.newBuilder().build())
1355             .addAllNodes(new ArrayList<Instance.Node>())
1356             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1357             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1358             .setIpAddress("ipAddress1634032845")
1359             .setReconciling(true)
1360             .setEtag("etag3123477")
1361             .putAllAnnotations(new HashMap<String, String>())
1362             .build();
1363     Operation resultOperation =
1364         Operation.newBuilder()
1365             .setName("createInstanceTest")
1366             .setDone(true)
1367             .setResponse(Any.pack(expectedResponse))
1368             .build();
1369     mockService.addResponse(resultOperation);
1370 
1371     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1372     Instance instance = Instance.newBuilder().build();
1373     String instanceId = "instanceId902024336";
1374 
1375     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
1376     Assert.assertEquals(expectedResponse, actualResponse);
1377 
1378     List<String> actualRequests = mockService.getRequestPaths();
1379     Assert.assertEquals(1, actualRequests.size());
1380 
1381     String apiClientHeaderKey =
1382         mockService
1383             .getRequestHeaders()
1384             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1385             .iterator()
1386             .next();
1387     Assert.assertTrue(
1388         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1389             .matcher(apiClientHeaderKey)
1390             .matches());
1391   }
1392 
1393   @Test
createInstanceExceptionTest2()1394   public void createInstanceExceptionTest2() throws Exception {
1395     ApiException exception =
1396         ApiExceptionFactory.createException(
1397             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1398     mockService.addException(exception);
1399 
1400     try {
1401       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1402       Instance instance = Instance.newBuilder().build();
1403       String instanceId = "instanceId902024336";
1404       client.createInstanceAsync(parent, instance, instanceId).get();
1405       Assert.fail("No exception raised");
1406     } catch (ExecutionException e) {
1407     }
1408   }
1409 
1410   @Test
createSecondaryInstanceTest()1411   public void createSecondaryInstanceTest() throws Exception {
1412     Instance expectedResponse =
1413         Instance.newBuilder()
1414             .setName(
1415                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1416             .setDisplayName("displayName1714148973")
1417             .setUid("uid115792")
1418             .setCreateTime(Timestamp.newBuilder().build())
1419             .setUpdateTime(Timestamp.newBuilder().build())
1420             .setDeleteTime(Timestamp.newBuilder().build())
1421             .putAllLabels(new HashMap<String, String>())
1422             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1423             .setGceZone("gceZone-146048427")
1424             .putAllDatabaseFlags(new HashMap<String, String>())
1425             .setWritableNode(Instance.Node.newBuilder().build())
1426             .addAllNodes(new ArrayList<Instance.Node>())
1427             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1428             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1429             .setIpAddress("ipAddress1634032845")
1430             .setReconciling(true)
1431             .setEtag("etag3123477")
1432             .putAllAnnotations(new HashMap<String, String>())
1433             .build();
1434     Operation resultOperation =
1435         Operation.newBuilder()
1436             .setName("createSecondaryInstanceTest")
1437             .setDone(true)
1438             .setResponse(Any.pack(expectedResponse))
1439             .build();
1440     mockService.addResponse(resultOperation);
1441 
1442     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1443     Instance instance = Instance.newBuilder().build();
1444     String instanceId = "instanceId902024336";
1445 
1446     Instance actualResponse =
1447         client.createSecondaryInstanceAsync(parent, instance, instanceId).get();
1448     Assert.assertEquals(expectedResponse, actualResponse);
1449 
1450     List<String> actualRequests = mockService.getRequestPaths();
1451     Assert.assertEquals(1, actualRequests.size());
1452 
1453     String apiClientHeaderKey =
1454         mockService
1455             .getRequestHeaders()
1456             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1457             .iterator()
1458             .next();
1459     Assert.assertTrue(
1460         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1461             .matcher(apiClientHeaderKey)
1462             .matches());
1463   }
1464 
1465   @Test
createSecondaryInstanceExceptionTest()1466   public void createSecondaryInstanceExceptionTest() throws Exception {
1467     ApiException exception =
1468         ApiExceptionFactory.createException(
1469             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1470     mockService.addException(exception);
1471 
1472     try {
1473       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1474       Instance instance = Instance.newBuilder().build();
1475       String instanceId = "instanceId902024336";
1476       client.createSecondaryInstanceAsync(parent, instance, instanceId).get();
1477       Assert.fail("No exception raised");
1478     } catch (ExecutionException e) {
1479     }
1480   }
1481 
1482   @Test
createSecondaryInstanceTest2()1483   public void createSecondaryInstanceTest2() throws Exception {
1484     Instance expectedResponse =
1485         Instance.newBuilder()
1486             .setName(
1487                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1488             .setDisplayName("displayName1714148973")
1489             .setUid("uid115792")
1490             .setCreateTime(Timestamp.newBuilder().build())
1491             .setUpdateTime(Timestamp.newBuilder().build())
1492             .setDeleteTime(Timestamp.newBuilder().build())
1493             .putAllLabels(new HashMap<String, String>())
1494             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1495             .setGceZone("gceZone-146048427")
1496             .putAllDatabaseFlags(new HashMap<String, String>())
1497             .setWritableNode(Instance.Node.newBuilder().build())
1498             .addAllNodes(new ArrayList<Instance.Node>())
1499             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1500             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1501             .setIpAddress("ipAddress1634032845")
1502             .setReconciling(true)
1503             .setEtag("etag3123477")
1504             .putAllAnnotations(new HashMap<String, String>())
1505             .build();
1506     Operation resultOperation =
1507         Operation.newBuilder()
1508             .setName("createSecondaryInstanceTest")
1509             .setDone(true)
1510             .setResponse(Any.pack(expectedResponse))
1511             .build();
1512     mockService.addResponse(resultOperation);
1513 
1514     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1515     Instance instance = Instance.newBuilder().build();
1516     String instanceId = "instanceId902024336";
1517 
1518     Instance actualResponse =
1519         client.createSecondaryInstanceAsync(parent, instance, instanceId).get();
1520     Assert.assertEquals(expectedResponse, actualResponse);
1521 
1522     List<String> actualRequests = mockService.getRequestPaths();
1523     Assert.assertEquals(1, actualRequests.size());
1524 
1525     String apiClientHeaderKey =
1526         mockService
1527             .getRequestHeaders()
1528             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1529             .iterator()
1530             .next();
1531     Assert.assertTrue(
1532         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1533             .matcher(apiClientHeaderKey)
1534             .matches());
1535   }
1536 
1537   @Test
createSecondaryInstanceExceptionTest2()1538   public void createSecondaryInstanceExceptionTest2() throws Exception {
1539     ApiException exception =
1540         ApiExceptionFactory.createException(
1541             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1542     mockService.addException(exception);
1543 
1544     try {
1545       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1546       Instance instance = Instance.newBuilder().build();
1547       String instanceId = "instanceId902024336";
1548       client.createSecondaryInstanceAsync(parent, instance, instanceId).get();
1549       Assert.fail("No exception raised");
1550     } catch (ExecutionException e) {
1551     }
1552   }
1553 
1554   @Test
batchCreateInstancesTest()1555   public void batchCreateInstancesTest() throws Exception {
1556     BatchCreateInstancesResponse expectedResponse =
1557         BatchCreateInstancesResponse.newBuilder()
1558             .addAllInstances(new ArrayList<Instance>())
1559             .build();
1560     Operation resultOperation =
1561         Operation.newBuilder()
1562             .setName("batchCreateInstancesTest")
1563             .setDone(true)
1564             .setResponse(Any.pack(expectedResponse))
1565             .build();
1566     mockService.addResponse(resultOperation);
1567 
1568     BatchCreateInstancesRequest request =
1569         BatchCreateInstancesRequest.newBuilder()
1570             .setParent(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1571             .setRequests(CreateInstanceRequests.newBuilder().build())
1572             .setRequestId("requestId693933066")
1573             .build();
1574 
1575     BatchCreateInstancesResponse actualResponse = client.batchCreateInstancesAsync(request).get();
1576     Assert.assertEquals(expectedResponse, actualResponse);
1577 
1578     List<String> actualRequests = mockService.getRequestPaths();
1579     Assert.assertEquals(1, actualRequests.size());
1580 
1581     String apiClientHeaderKey =
1582         mockService
1583             .getRequestHeaders()
1584             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1585             .iterator()
1586             .next();
1587     Assert.assertTrue(
1588         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1589             .matcher(apiClientHeaderKey)
1590             .matches());
1591   }
1592 
1593   @Test
batchCreateInstancesExceptionTest()1594   public void batchCreateInstancesExceptionTest() throws Exception {
1595     ApiException exception =
1596         ApiExceptionFactory.createException(
1597             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1598     mockService.addException(exception);
1599 
1600     try {
1601       BatchCreateInstancesRequest request =
1602           BatchCreateInstancesRequest.newBuilder()
1603               .setParent(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1604               .setRequests(CreateInstanceRequests.newBuilder().build())
1605               .setRequestId("requestId693933066")
1606               .build();
1607       client.batchCreateInstancesAsync(request).get();
1608       Assert.fail("No exception raised");
1609     } catch (ExecutionException e) {
1610     }
1611   }
1612 
1613   @Test
updateInstanceTest()1614   public void updateInstanceTest() throws Exception {
1615     Instance expectedResponse =
1616         Instance.newBuilder()
1617             .setName(
1618                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1619             .setDisplayName("displayName1714148973")
1620             .setUid("uid115792")
1621             .setCreateTime(Timestamp.newBuilder().build())
1622             .setUpdateTime(Timestamp.newBuilder().build())
1623             .setDeleteTime(Timestamp.newBuilder().build())
1624             .putAllLabels(new HashMap<String, String>())
1625             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1626             .setGceZone("gceZone-146048427")
1627             .putAllDatabaseFlags(new HashMap<String, String>())
1628             .setWritableNode(Instance.Node.newBuilder().build())
1629             .addAllNodes(new ArrayList<Instance.Node>())
1630             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1631             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1632             .setIpAddress("ipAddress1634032845")
1633             .setReconciling(true)
1634             .setEtag("etag3123477")
1635             .putAllAnnotations(new HashMap<String, String>())
1636             .build();
1637     Operation resultOperation =
1638         Operation.newBuilder()
1639             .setName("updateInstanceTest")
1640             .setDone(true)
1641             .setResponse(Any.pack(expectedResponse))
1642             .build();
1643     mockService.addResponse(resultOperation);
1644 
1645     Instance instance =
1646         Instance.newBuilder()
1647             .setName(
1648                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1649             .setDisplayName("displayName1714148973")
1650             .setUid("uid115792")
1651             .setCreateTime(Timestamp.newBuilder().build())
1652             .setUpdateTime(Timestamp.newBuilder().build())
1653             .setDeleteTime(Timestamp.newBuilder().build())
1654             .putAllLabels(new HashMap<String, String>())
1655             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1656             .setGceZone("gceZone-146048427")
1657             .putAllDatabaseFlags(new HashMap<String, String>())
1658             .setWritableNode(Instance.Node.newBuilder().build())
1659             .addAllNodes(new ArrayList<Instance.Node>())
1660             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1661             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1662             .setIpAddress("ipAddress1634032845")
1663             .setReconciling(true)
1664             .setEtag("etag3123477")
1665             .putAllAnnotations(new HashMap<String, String>())
1666             .build();
1667     FieldMask updateMask = FieldMask.newBuilder().build();
1668 
1669     Instance actualResponse = client.updateInstanceAsync(instance, updateMask).get();
1670     Assert.assertEquals(expectedResponse, actualResponse);
1671 
1672     List<String> actualRequests = mockService.getRequestPaths();
1673     Assert.assertEquals(1, actualRequests.size());
1674 
1675     String apiClientHeaderKey =
1676         mockService
1677             .getRequestHeaders()
1678             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1679             .iterator()
1680             .next();
1681     Assert.assertTrue(
1682         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1683             .matcher(apiClientHeaderKey)
1684             .matches());
1685   }
1686 
1687   @Test
updateInstanceExceptionTest()1688   public void updateInstanceExceptionTest() throws Exception {
1689     ApiException exception =
1690         ApiExceptionFactory.createException(
1691             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1692     mockService.addException(exception);
1693 
1694     try {
1695       Instance instance =
1696           Instance.newBuilder()
1697               .setName(
1698                   InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1699               .setDisplayName("displayName1714148973")
1700               .setUid("uid115792")
1701               .setCreateTime(Timestamp.newBuilder().build())
1702               .setUpdateTime(Timestamp.newBuilder().build())
1703               .setDeleteTime(Timestamp.newBuilder().build())
1704               .putAllLabels(new HashMap<String, String>())
1705               .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1706               .setGceZone("gceZone-146048427")
1707               .putAllDatabaseFlags(new HashMap<String, String>())
1708               .setWritableNode(Instance.Node.newBuilder().build())
1709               .addAllNodes(new ArrayList<Instance.Node>())
1710               .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1711               .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1712               .setIpAddress("ipAddress1634032845")
1713               .setReconciling(true)
1714               .setEtag("etag3123477")
1715               .putAllAnnotations(new HashMap<String, String>())
1716               .build();
1717       FieldMask updateMask = FieldMask.newBuilder().build();
1718       client.updateInstanceAsync(instance, updateMask).get();
1719       Assert.fail("No exception raised");
1720     } catch (ExecutionException e) {
1721     }
1722   }
1723 
1724   @Test
deleteInstanceTest()1725   public void deleteInstanceTest() throws Exception {
1726     Empty expectedResponse = Empty.newBuilder().build();
1727     Operation resultOperation =
1728         Operation.newBuilder()
1729             .setName("deleteInstanceTest")
1730             .setDone(true)
1731             .setResponse(Any.pack(expectedResponse))
1732             .build();
1733     mockService.addResponse(resultOperation);
1734 
1735     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1736 
1737     client.deleteInstanceAsync(name).get();
1738 
1739     List<String> actualRequests = mockService.getRequestPaths();
1740     Assert.assertEquals(1, actualRequests.size());
1741 
1742     String apiClientHeaderKey =
1743         mockService
1744             .getRequestHeaders()
1745             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1746             .iterator()
1747             .next();
1748     Assert.assertTrue(
1749         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1750             .matcher(apiClientHeaderKey)
1751             .matches());
1752   }
1753 
1754   @Test
deleteInstanceExceptionTest()1755   public void deleteInstanceExceptionTest() throws Exception {
1756     ApiException exception =
1757         ApiExceptionFactory.createException(
1758             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1759     mockService.addException(exception);
1760 
1761     try {
1762       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1763       client.deleteInstanceAsync(name).get();
1764       Assert.fail("No exception raised");
1765     } catch (ExecutionException e) {
1766     }
1767   }
1768 
1769   @Test
deleteInstanceTest2()1770   public void deleteInstanceTest2() throws Exception {
1771     Empty expectedResponse = Empty.newBuilder().build();
1772     Operation resultOperation =
1773         Operation.newBuilder()
1774             .setName("deleteInstanceTest")
1775             .setDone(true)
1776             .setResponse(Any.pack(expectedResponse))
1777             .build();
1778     mockService.addResponse(resultOperation);
1779 
1780     String name =
1781         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1782 
1783     client.deleteInstanceAsync(name).get();
1784 
1785     List<String> actualRequests = mockService.getRequestPaths();
1786     Assert.assertEquals(1, actualRequests.size());
1787 
1788     String apiClientHeaderKey =
1789         mockService
1790             .getRequestHeaders()
1791             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1792             .iterator()
1793             .next();
1794     Assert.assertTrue(
1795         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1796             .matcher(apiClientHeaderKey)
1797             .matches());
1798   }
1799 
1800   @Test
deleteInstanceExceptionTest2()1801   public void deleteInstanceExceptionTest2() throws Exception {
1802     ApiException exception =
1803         ApiExceptionFactory.createException(
1804             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1805     mockService.addException(exception);
1806 
1807     try {
1808       String name =
1809           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1810       client.deleteInstanceAsync(name).get();
1811       Assert.fail("No exception raised");
1812     } catch (ExecutionException e) {
1813     }
1814   }
1815 
1816   @Test
failoverInstanceTest()1817   public void failoverInstanceTest() throws Exception {
1818     Instance expectedResponse =
1819         Instance.newBuilder()
1820             .setName(
1821                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1822             .setDisplayName("displayName1714148973")
1823             .setUid("uid115792")
1824             .setCreateTime(Timestamp.newBuilder().build())
1825             .setUpdateTime(Timestamp.newBuilder().build())
1826             .setDeleteTime(Timestamp.newBuilder().build())
1827             .putAllLabels(new HashMap<String, String>())
1828             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1829             .setGceZone("gceZone-146048427")
1830             .putAllDatabaseFlags(new HashMap<String, String>())
1831             .setWritableNode(Instance.Node.newBuilder().build())
1832             .addAllNodes(new ArrayList<Instance.Node>())
1833             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1834             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1835             .setIpAddress("ipAddress1634032845")
1836             .setReconciling(true)
1837             .setEtag("etag3123477")
1838             .putAllAnnotations(new HashMap<String, String>())
1839             .build();
1840     Operation resultOperation =
1841         Operation.newBuilder()
1842             .setName("failoverInstanceTest")
1843             .setDone(true)
1844             .setResponse(Any.pack(expectedResponse))
1845             .build();
1846     mockService.addResponse(resultOperation);
1847 
1848     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1849 
1850     Instance actualResponse = client.failoverInstanceAsync(name).get();
1851     Assert.assertEquals(expectedResponse, actualResponse);
1852 
1853     List<String> actualRequests = mockService.getRequestPaths();
1854     Assert.assertEquals(1, actualRequests.size());
1855 
1856     String apiClientHeaderKey =
1857         mockService
1858             .getRequestHeaders()
1859             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1860             .iterator()
1861             .next();
1862     Assert.assertTrue(
1863         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1864             .matcher(apiClientHeaderKey)
1865             .matches());
1866   }
1867 
1868   @Test
failoverInstanceExceptionTest()1869   public void failoverInstanceExceptionTest() throws Exception {
1870     ApiException exception =
1871         ApiExceptionFactory.createException(
1872             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1873     mockService.addException(exception);
1874 
1875     try {
1876       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1877       client.failoverInstanceAsync(name).get();
1878       Assert.fail("No exception raised");
1879     } catch (ExecutionException e) {
1880     }
1881   }
1882 
1883   @Test
failoverInstanceTest2()1884   public void failoverInstanceTest2() throws Exception {
1885     Instance expectedResponse =
1886         Instance.newBuilder()
1887             .setName(
1888                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1889             .setDisplayName("displayName1714148973")
1890             .setUid("uid115792")
1891             .setCreateTime(Timestamp.newBuilder().build())
1892             .setUpdateTime(Timestamp.newBuilder().build())
1893             .setDeleteTime(Timestamp.newBuilder().build())
1894             .putAllLabels(new HashMap<String, String>())
1895             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1896             .setGceZone("gceZone-146048427")
1897             .putAllDatabaseFlags(new HashMap<String, String>())
1898             .setWritableNode(Instance.Node.newBuilder().build())
1899             .addAllNodes(new ArrayList<Instance.Node>())
1900             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1901             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1902             .setIpAddress("ipAddress1634032845")
1903             .setReconciling(true)
1904             .setEtag("etag3123477")
1905             .putAllAnnotations(new HashMap<String, String>())
1906             .build();
1907     Operation resultOperation =
1908         Operation.newBuilder()
1909             .setName("failoverInstanceTest")
1910             .setDone(true)
1911             .setResponse(Any.pack(expectedResponse))
1912             .build();
1913     mockService.addResponse(resultOperation);
1914 
1915     String name =
1916         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1917 
1918     Instance actualResponse = client.failoverInstanceAsync(name).get();
1919     Assert.assertEquals(expectedResponse, actualResponse);
1920 
1921     List<String> actualRequests = mockService.getRequestPaths();
1922     Assert.assertEquals(1, actualRequests.size());
1923 
1924     String apiClientHeaderKey =
1925         mockService
1926             .getRequestHeaders()
1927             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1928             .iterator()
1929             .next();
1930     Assert.assertTrue(
1931         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1932             .matcher(apiClientHeaderKey)
1933             .matches());
1934   }
1935 
1936   @Test
failoverInstanceExceptionTest2()1937   public void failoverInstanceExceptionTest2() throws Exception {
1938     ApiException exception =
1939         ApiExceptionFactory.createException(
1940             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1941     mockService.addException(exception);
1942 
1943     try {
1944       String name =
1945           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1946       client.failoverInstanceAsync(name).get();
1947       Assert.fail("No exception raised");
1948     } catch (ExecutionException e) {
1949     }
1950   }
1951 
1952   @Test
restartInstanceTest()1953   public void restartInstanceTest() throws Exception {
1954     Instance expectedResponse =
1955         Instance.newBuilder()
1956             .setName(
1957                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1958             .setDisplayName("displayName1714148973")
1959             .setUid("uid115792")
1960             .setCreateTime(Timestamp.newBuilder().build())
1961             .setUpdateTime(Timestamp.newBuilder().build())
1962             .setDeleteTime(Timestamp.newBuilder().build())
1963             .putAllLabels(new HashMap<String, String>())
1964             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1965             .setGceZone("gceZone-146048427")
1966             .putAllDatabaseFlags(new HashMap<String, String>())
1967             .setWritableNode(Instance.Node.newBuilder().build())
1968             .addAllNodes(new ArrayList<Instance.Node>())
1969             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1970             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1971             .setIpAddress("ipAddress1634032845")
1972             .setReconciling(true)
1973             .setEtag("etag3123477")
1974             .putAllAnnotations(new HashMap<String, String>())
1975             .build();
1976     Operation resultOperation =
1977         Operation.newBuilder()
1978             .setName("restartInstanceTest")
1979             .setDone(true)
1980             .setResponse(Any.pack(expectedResponse))
1981             .build();
1982     mockService.addResponse(resultOperation);
1983 
1984     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1985 
1986     Instance actualResponse = client.restartInstanceAsync(name).get();
1987     Assert.assertEquals(expectedResponse, actualResponse);
1988 
1989     List<String> actualRequests = mockService.getRequestPaths();
1990     Assert.assertEquals(1, actualRequests.size());
1991 
1992     String apiClientHeaderKey =
1993         mockService
1994             .getRequestHeaders()
1995             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1996             .iterator()
1997             .next();
1998     Assert.assertTrue(
1999         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2000             .matcher(apiClientHeaderKey)
2001             .matches());
2002   }
2003 
2004   @Test
restartInstanceExceptionTest()2005   public void restartInstanceExceptionTest() throws Exception {
2006     ApiException exception =
2007         ApiExceptionFactory.createException(
2008             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2009     mockService.addException(exception);
2010 
2011     try {
2012       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
2013       client.restartInstanceAsync(name).get();
2014       Assert.fail("No exception raised");
2015     } catch (ExecutionException e) {
2016     }
2017   }
2018 
2019   @Test
restartInstanceTest2()2020   public void restartInstanceTest2() throws Exception {
2021     Instance expectedResponse =
2022         Instance.newBuilder()
2023             .setName(
2024                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
2025             .setDisplayName("displayName1714148973")
2026             .setUid("uid115792")
2027             .setCreateTime(Timestamp.newBuilder().build())
2028             .setUpdateTime(Timestamp.newBuilder().build())
2029             .setDeleteTime(Timestamp.newBuilder().build())
2030             .putAllLabels(new HashMap<String, String>())
2031             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
2032             .setGceZone("gceZone-146048427")
2033             .putAllDatabaseFlags(new HashMap<String, String>())
2034             .setWritableNode(Instance.Node.newBuilder().build())
2035             .addAllNodes(new ArrayList<Instance.Node>())
2036             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
2037             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
2038             .setIpAddress("ipAddress1634032845")
2039             .setReconciling(true)
2040             .setEtag("etag3123477")
2041             .putAllAnnotations(new HashMap<String, String>())
2042             .build();
2043     Operation resultOperation =
2044         Operation.newBuilder()
2045             .setName("restartInstanceTest")
2046             .setDone(true)
2047             .setResponse(Any.pack(expectedResponse))
2048             .build();
2049     mockService.addResponse(resultOperation);
2050 
2051     String name =
2052         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
2053 
2054     Instance actualResponse = client.restartInstanceAsync(name).get();
2055     Assert.assertEquals(expectedResponse, actualResponse);
2056 
2057     List<String> actualRequests = mockService.getRequestPaths();
2058     Assert.assertEquals(1, actualRequests.size());
2059 
2060     String apiClientHeaderKey =
2061         mockService
2062             .getRequestHeaders()
2063             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2064             .iterator()
2065             .next();
2066     Assert.assertTrue(
2067         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2068             .matcher(apiClientHeaderKey)
2069             .matches());
2070   }
2071 
2072   @Test
restartInstanceExceptionTest2()2073   public void restartInstanceExceptionTest2() throws Exception {
2074     ApiException exception =
2075         ApiExceptionFactory.createException(
2076             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2077     mockService.addException(exception);
2078 
2079     try {
2080       String name =
2081           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
2082       client.restartInstanceAsync(name).get();
2083       Assert.fail("No exception raised");
2084     } catch (ExecutionException e) {
2085     }
2086   }
2087 
2088   @Test
listBackupsTest()2089   public void listBackupsTest() throws Exception {
2090     Backup responsesElement = Backup.newBuilder().build();
2091     ListBackupsResponse expectedResponse =
2092         ListBackupsResponse.newBuilder()
2093             .setNextPageToken("")
2094             .addAllBackups(Arrays.asList(responsesElement))
2095             .build();
2096     mockService.addResponse(expectedResponse);
2097 
2098     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2099 
2100     ListBackupsPagedResponse pagedListResponse = client.listBackups(parent);
2101 
2102     List<Backup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2103 
2104     Assert.assertEquals(1, resources.size());
2105     Assert.assertEquals(expectedResponse.getBackupsList().get(0), resources.get(0));
2106 
2107     List<String> actualRequests = mockService.getRequestPaths();
2108     Assert.assertEquals(1, actualRequests.size());
2109 
2110     String apiClientHeaderKey =
2111         mockService
2112             .getRequestHeaders()
2113             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2114             .iterator()
2115             .next();
2116     Assert.assertTrue(
2117         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2118             .matcher(apiClientHeaderKey)
2119             .matches());
2120   }
2121 
2122   @Test
listBackupsExceptionTest()2123   public void listBackupsExceptionTest() throws Exception {
2124     ApiException exception =
2125         ApiExceptionFactory.createException(
2126             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2127     mockService.addException(exception);
2128 
2129     try {
2130       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2131       client.listBackups(parent);
2132       Assert.fail("No exception raised");
2133     } catch (InvalidArgumentException e) {
2134       // Expected exception.
2135     }
2136   }
2137 
2138   @Test
listBackupsTest2()2139   public void listBackupsTest2() throws Exception {
2140     Backup responsesElement = Backup.newBuilder().build();
2141     ListBackupsResponse expectedResponse =
2142         ListBackupsResponse.newBuilder()
2143             .setNextPageToken("")
2144             .addAllBackups(Arrays.asList(responsesElement))
2145             .build();
2146     mockService.addResponse(expectedResponse);
2147 
2148     String parent = "projects/project-5833/locations/location-5833";
2149 
2150     ListBackupsPagedResponse pagedListResponse = client.listBackups(parent);
2151 
2152     List<Backup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2153 
2154     Assert.assertEquals(1, resources.size());
2155     Assert.assertEquals(expectedResponse.getBackupsList().get(0), resources.get(0));
2156 
2157     List<String> actualRequests = mockService.getRequestPaths();
2158     Assert.assertEquals(1, actualRequests.size());
2159 
2160     String apiClientHeaderKey =
2161         mockService
2162             .getRequestHeaders()
2163             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2164             .iterator()
2165             .next();
2166     Assert.assertTrue(
2167         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2168             .matcher(apiClientHeaderKey)
2169             .matches());
2170   }
2171 
2172   @Test
listBackupsExceptionTest2()2173   public void listBackupsExceptionTest2() throws Exception {
2174     ApiException exception =
2175         ApiExceptionFactory.createException(
2176             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2177     mockService.addException(exception);
2178 
2179     try {
2180       String parent = "projects/project-5833/locations/location-5833";
2181       client.listBackups(parent);
2182       Assert.fail("No exception raised");
2183     } catch (InvalidArgumentException e) {
2184       // Expected exception.
2185     }
2186   }
2187 
2188   @Test
getBackupTest()2189   public void getBackupTest() throws Exception {
2190     Backup expectedResponse =
2191         Backup.newBuilder()
2192             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2193             .setDisplayName("displayName1714148973")
2194             .setUid("uid115792")
2195             .setCreateTime(Timestamp.newBuilder().build())
2196             .setUpdateTime(Timestamp.newBuilder().build())
2197             .setDeleteTime(Timestamp.newBuilder().build())
2198             .putAllLabels(new HashMap<String, String>())
2199             .setDescription("description-1724546052")
2200             .setClusterUid("clusterUid240271350")
2201             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2202             .setReconciling(true)
2203             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2204             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2205             .setEtag("etag3123477")
2206             .putAllAnnotations(new HashMap<String, String>())
2207             .setSizeBytes(-1796325715)
2208             .setExpiryTime(Timestamp.newBuilder().build())
2209             .build();
2210     mockService.addResponse(expectedResponse);
2211 
2212     BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2213 
2214     Backup actualResponse = client.getBackup(name);
2215     Assert.assertEquals(expectedResponse, actualResponse);
2216 
2217     List<String> actualRequests = mockService.getRequestPaths();
2218     Assert.assertEquals(1, actualRequests.size());
2219 
2220     String apiClientHeaderKey =
2221         mockService
2222             .getRequestHeaders()
2223             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2224             .iterator()
2225             .next();
2226     Assert.assertTrue(
2227         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2228             .matcher(apiClientHeaderKey)
2229             .matches());
2230   }
2231 
2232   @Test
getBackupExceptionTest()2233   public void getBackupExceptionTest() throws Exception {
2234     ApiException exception =
2235         ApiExceptionFactory.createException(
2236             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2237     mockService.addException(exception);
2238 
2239     try {
2240       BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2241       client.getBackup(name);
2242       Assert.fail("No exception raised");
2243     } catch (InvalidArgumentException e) {
2244       // Expected exception.
2245     }
2246   }
2247 
2248   @Test
getBackupTest2()2249   public void getBackupTest2() throws Exception {
2250     Backup expectedResponse =
2251         Backup.newBuilder()
2252             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2253             .setDisplayName("displayName1714148973")
2254             .setUid("uid115792")
2255             .setCreateTime(Timestamp.newBuilder().build())
2256             .setUpdateTime(Timestamp.newBuilder().build())
2257             .setDeleteTime(Timestamp.newBuilder().build())
2258             .putAllLabels(new HashMap<String, String>())
2259             .setDescription("description-1724546052")
2260             .setClusterUid("clusterUid240271350")
2261             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2262             .setReconciling(true)
2263             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2264             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2265             .setEtag("etag3123477")
2266             .putAllAnnotations(new HashMap<String, String>())
2267             .setSizeBytes(-1796325715)
2268             .setExpiryTime(Timestamp.newBuilder().build())
2269             .build();
2270     mockService.addResponse(expectedResponse);
2271 
2272     String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2273 
2274     Backup actualResponse = client.getBackup(name);
2275     Assert.assertEquals(expectedResponse, actualResponse);
2276 
2277     List<String> actualRequests = mockService.getRequestPaths();
2278     Assert.assertEquals(1, actualRequests.size());
2279 
2280     String apiClientHeaderKey =
2281         mockService
2282             .getRequestHeaders()
2283             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2284             .iterator()
2285             .next();
2286     Assert.assertTrue(
2287         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2288             .matcher(apiClientHeaderKey)
2289             .matches());
2290   }
2291 
2292   @Test
getBackupExceptionTest2()2293   public void getBackupExceptionTest2() throws Exception {
2294     ApiException exception =
2295         ApiExceptionFactory.createException(
2296             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2297     mockService.addException(exception);
2298 
2299     try {
2300       String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2301       client.getBackup(name);
2302       Assert.fail("No exception raised");
2303     } catch (InvalidArgumentException e) {
2304       // Expected exception.
2305     }
2306   }
2307 
2308   @Test
createBackupTest()2309   public void createBackupTest() throws Exception {
2310     Backup expectedResponse =
2311         Backup.newBuilder()
2312             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2313             .setDisplayName("displayName1714148973")
2314             .setUid("uid115792")
2315             .setCreateTime(Timestamp.newBuilder().build())
2316             .setUpdateTime(Timestamp.newBuilder().build())
2317             .setDeleteTime(Timestamp.newBuilder().build())
2318             .putAllLabels(new HashMap<String, String>())
2319             .setDescription("description-1724546052")
2320             .setClusterUid("clusterUid240271350")
2321             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2322             .setReconciling(true)
2323             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2324             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2325             .setEtag("etag3123477")
2326             .putAllAnnotations(new HashMap<String, String>())
2327             .setSizeBytes(-1796325715)
2328             .setExpiryTime(Timestamp.newBuilder().build())
2329             .build();
2330     Operation resultOperation =
2331         Operation.newBuilder()
2332             .setName("createBackupTest")
2333             .setDone(true)
2334             .setResponse(Any.pack(expectedResponse))
2335             .build();
2336     mockService.addResponse(resultOperation);
2337 
2338     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2339     Backup backup = Backup.newBuilder().build();
2340     String backupId = "backupId2121930365";
2341 
2342     Backup actualResponse = client.createBackupAsync(parent, backup, backupId).get();
2343     Assert.assertEquals(expectedResponse, actualResponse);
2344 
2345     List<String> actualRequests = mockService.getRequestPaths();
2346     Assert.assertEquals(1, actualRequests.size());
2347 
2348     String apiClientHeaderKey =
2349         mockService
2350             .getRequestHeaders()
2351             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2352             .iterator()
2353             .next();
2354     Assert.assertTrue(
2355         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2356             .matcher(apiClientHeaderKey)
2357             .matches());
2358   }
2359 
2360   @Test
createBackupExceptionTest()2361   public void createBackupExceptionTest() throws Exception {
2362     ApiException exception =
2363         ApiExceptionFactory.createException(
2364             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2365     mockService.addException(exception);
2366 
2367     try {
2368       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2369       Backup backup = Backup.newBuilder().build();
2370       String backupId = "backupId2121930365";
2371       client.createBackupAsync(parent, backup, backupId).get();
2372       Assert.fail("No exception raised");
2373     } catch (ExecutionException e) {
2374     }
2375   }
2376 
2377   @Test
createBackupTest2()2378   public void createBackupTest2() throws Exception {
2379     Backup expectedResponse =
2380         Backup.newBuilder()
2381             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2382             .setDisplayName("displayName1714148973")
2383             .setUid("uid115792")
2384             .setCreateTime(Timestamp.newBuilder().build())
2385             .setUpdateTime(Timestamp.newBuilder().build())
2386             .setDeleteTime(Timestamp.newBuilder().build())
2387             .putAllLabels(new HashMap<String, String>())
2388             .setDescription("description-1724546052")
2389             .setClusterUid("clusterUid240271350")
2390             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2391             .setReconciling(true)
2392             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2393             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2394             .setEtag("etag3123477")
2395             .putAllAnnotations(new HashMap<String, String>())
2396             .setSizeBytes(-1796325715)
2397             .setExpiryTime(Timestamp.newBuilder().build())
2398             .build();
2399     Operation resultOperation =
2400         Operation.newBuilder()
2401             .setName("createBackupTest")
2402             .setDone(true)
2403             .setResponse(Any.pack(expectedResponse))
2404             .build();
2405     mockService.addResponse(resultOperation);
2406 
2407     String parent = "projects/project-5833/locations/location-5833";
2408     Backup backup = Backup.newBuilder().build();
2409     String backupId = "backupId2121930365";
2410 
2411     Backup actualResponse = client.createBackupAsync(parent, backup, backupId).get();
2412     Assert.assertEquals(expectedResponse, actualResponse);
2413 
2414     List<String> actualRequests = mockService.getRequestPaths();
2415     Assert.assertEquals(1, actualRequests.size());
2416 
2417     String apiClientHeaderKey =
2418         mockService
2419             .getRequestHeaders()
2420             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2421             .iterator()
2422             .next();
2423     Assert.assertTrue(
2424         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2425             .matcher(apiClientHeaderKey)
2426             .matches());
2427   }
2428 
2429   @Test
createBackupExceptionTest2()2430   public void createBackupExceptionTest2() throws Exception {
2431     ApiException exception =
2432         ApiExceptionFactory.createException(
2433             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2434     mockService.addException(exception);
2435 
2436     try {
2437       String parent = "projects/project-5833/locations/location-5833";
2438       Backup backup = Backup.newBuilder().build();
2439       String backupId = "backupId2121930365";
2440       client.createBackupAsync(parent, backup, backupId).get();
2441       Assert.fail("No exception raised");
2442     } catch (ExecutionException e) {
2443     }
2444   }
2445 
2446   @Test
updateBackupTest()2447   public void updateBackupTest() throws Exception {
2448     Backup expectedResponse =
2449         Backup.newBuilder()
2450             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2451             .setDisplayName("displayName1714148973")
2452             .setUid("uid115792")
2453             .setCreateTime(Timestamp.newBuilder().build())
2454             .setUpdateTime(Timestamp.newBuilder().build())
2455             .setDeleteTime(Timestamp.newBuilder().build())
2456             .putAllLabels(new HashMap<String, String>())
2457             .setDescription("description-1724546052")
2458             .setClusterUid("clusterUid240271350")
2459             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2460             .setReconciling(true)
2461             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2462             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2463             .setEtag("etag3123477")
2464             .putAllAnnotations(new HashMap<String, String>())
2465             .setSizeBytes(-1796325715)
2466             .setExpiryTime(Timestamp.newBuilder().build())
2467             .build();
2468     Operation resultOperation =
2469         Operation.newBuilder()
2470             .setName("updateBackupTest")
2471             .setDone(true)
2472             .setResponse(Any.pack(expectedResponse))
2473             .build();
2474     mockService.addResponse(resultOperation);
2475 
2476     Backup backup =
2477         Backup.newBuilder()
2478             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2479             .setDisplayName("displayName1714148973")
2480             .setUid("uid115792")
2481             .setCreateTime(Timestamp.newBuilder().build())
2482             .setUpdateTime(Timestamp.newBuilder().build())
2483             .setDeleteTime(Timestamp.newBuilder().build())
2484             .putAllLabels(new HashMap<String, String>())
2485             .setDescription("description-1724546052")
2486             .setClusterUid("clusterUid240271350")
2487             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2488             .setReconciling(true)
2489             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2490             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2491             .setEtag("etag3123477")
2492             .putAllAnnotations(new HashMap<String, String>())
2493             .setSizeBytes(-1796325715)
2494             .setExpiryTime(Timestamp.newBuilder().build())
2495             .build();
2496     FieldMask updateMask = FieldMask.newBuilder().build();
2497 
2498     Backup actualResponse = client.updateBackupAsync(backup, updateMask).get();
2499     Assert.assertEquals(expectedResponse, actualResponse);
2500 
2501     List<String> actualRequests = mockService.getRequestPaths();
2502     Assert.assertEquals(1, actualRequests.size());
2503 
2504     String apiClientHeaderKey =
2505         mockService
2506             .getRequestHeaders()
2507             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2508             .iterator()
2509             .next();
2510     Assert.assertTrue(
2511         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2512             .matcher(apiClientHeaderKey)
2513             .matches());
2514   }
2515 
2516   @Test
updateBackupExceptionTest()2517   public void updateBackupExceptionTest() throws Exception {
2518     ApiException exception =
2519         ApiExceptionFactory.createException(
2520             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2521     mockService.addException(exception);
2522 
2523     try {
2524       Backup backup =
2525           Backup.newBuilder()
2526               .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2527               .setDisplayName("displayName1714148973")
2528               .setUid("uid115792")
2529               .setCreateTime(Timestamp.newBuilder().build())
2530               .setUpdateTime(Timestamp.newBuilder().build())
2531               .setDeleteTime(Timestamp.newBuilder().build())
2532               .putAllLabels(new HashMap<String, String>())
2533               .setDescription("description-1724546052")
2534               .setClusterUid("clusterUid240271350")
2535               .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2536               .setReconciling(true)
2537               .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2538               .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2539               .setEtag("etag3123477")
2540               .putAllAnnotations(new HashMap<String, String>())
2541               .setSizeBytes(-1796325715)
2542               .setExpiryTime(Timestamp.newBuilder().build())
2543               .build();
2544       FieldMask updateMask = FieldMask.newBuilder().build();
2545       client.updateBackupAsync(backup, updateMask).get();
2546       Assert.fail("No exception raised");
2547     } catch (ExecutionException e) {
2548     }
2549   }
2550 
2551   @Test
deleteBackupTest()2552   public void deleteBackupTest() throws Exception {
2553     Empty expectedResponse = Empty.newBuilder().build();
2554     Operation resultOperation =
2555         Operation.newBuilder()
2556             .setName("deleteBackupTest")
2557             .setDone(true)
2558             .setResponse(Any.pack(expectedResponse))
2559             .build();
2560     mockService.addResponse(resultOperation);
2561 
2562     BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2563 
2564     client.deleteBackupAsync(name).get();
2565 
2566     List<String> actualRequests = mockService.getRequestPaths();
2567     Assert.assertEquals(1, actualRequests.size());
2568 
2569     String apiClientHeaderKey =
2570         mockService
2571             .getRequestHeaders()
2572             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2573             .iterator()
2574             .next();
2575     Assert.assertTrue(
2576         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2577             .matcher(apiClientHeaderKey)
2578             .matches());
2579   }
2580 
2581   @Test
deleteBackupExceptionTest()2582   public void deleteBackupExceptionTest() throws Exception {
2583     ApiException exception =
2584         ApiExceptionFactory.createException(
2585             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2586     mockService.addException(exception);
2587 
2588     try {
2589       BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2590       client.deleteBackupAsync(name).get();
2591       Assert.fail("No exception raised");
2592     } catch (ExecutionException e) {
2593     }
2594   }
2595 
2596   @Test
deleteBackupTest2()2597   public void deleteBackupTest2() throws Exception {
2598     Empty expectedResponse = Empty.newBuilder().build();
2599     Operation resultOperation =
2600         Operation.newBuilder()
2601             .setName("deleteBackupTest")
2602             .setDone(true)
2603             .setResponse(Any.pack(expectedResponse))
2604             .build();
2605     mockService.addResponse(resultOperation);
2606 
2607     String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2608 
2609     client.deleteBackupAsync(name).get();
2610 
2611     List<String> actualRequests = mockService.getRequestPaths();
2612     Assert.assertEquals(1, actualRequests.size());
2613 
2614     String apiClientHeaderKey =
2615         mockService
2616             .getRequestHeaders()
2617             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2618             .iterator()
2619             .next();
2620     Assert.assertTrue(
2621         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2622             .matcher(apiClientHeaderKey)
2623             .matches());
2624   }
2625 
2626   @Test
deleteBackupExceptionTest2()2627   public void deleteBackupExceptionTest2() throws Exception {
2628     ApiException exception =
2629         ApiExceptionFactory.createException(
2630             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2631     mockService.addException(exception);
2632 
2633     try {
2634       String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2635       client.deleteBackupAsync(name).get();
2636       Assert.fail("No exception raised");
2637     } catch (ExecutionException e) {
2638     }
2639   }
2640 
2641   @Test
listSupportedDatabaseFlagsTest()2642   public void listSupportedDatabaseFlagsTest() throws Exception {
2643     SupportedDatabaseFlag responsesElement = SupportedDatabaseFlag.newBuilder().build();
2644     ListSupportedDatabaseFlagsResponse expectedResponse =
2645         ListSupportedDatabaseFlagsResponse.newBuilder()
2646             .setNextPageToken("")
2647             .addAllSupportedDatabaseFlags(Arrays.asList(responsesElement))
2648             .build();
2649     mockService.addResponse(expectedResponse);
2650 
2651     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2652 
2653     ListSupportedDatabaseFlagsPagedResponse pagedListResponse =
2654         client.listSupportedDatabaseFlags(parent);
2655 
2656     List<SupportedDatabaseFlag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2657 
2658     Assert.assertEquals(1, resources.size());
2659     Assert.assertEquals(expectedResponse.getSupportedDatabaseFlagsList().get(0), resources.get(0));
2660 
2661     List<String> actualRequests = mockService.getRequestPaths();
2662     Assert.assertEquals(1, actualRequests.size());
2663 
2664     String apiClientHeaderKey =
2665         mockService
2666             .getRequestHeaders()
2667             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2668             .iterator()
2669             .next();
2670     Assert.assertTrue(
2671         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2672             .matcher(apiClientHeaderKey)
2673             .matches());
2674   }
2675 
2676   @Test
listSupportedDatabaseFlagsExceptionTest()2677   public void listSupportedDatabaseFlagsExceptionTest() throws Exception {
2678     ApiException exception =
2679         ApiExceptionFactory.createException(
2680             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2681     mockService.addException(exception);
2682 
2683     try {
2684       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2685       client.listSupportedDatabaseFlags(parent);
2686       Assert.fail("No exception raised");
2687     } catch (InvalidArgumentException e) {
2688       // Expected exception.
2689     }
2690   }
2691 
2692   @Test
listSupportedDatabaseFlagsTest2()2693   public void listSupportedDatabaseFlagsTest2() throws Exception {
2694     SupportedDatabaseFlag responsesElement = SupportedDatabaseFlag.newBuilder().build();
2695     ListSupportedDatabaseFlagsResponse expectedResponse =
2696         ListSupportedDatabaseFlagsResponse.newBuilder()
2697             .setNextPageToken("")
2698             .addAllSupportedDatabaseFlags(Arrays.asList(responsesElement))
2699             .build();
2700     mockService.addResponse(expectedResponse);
2701 
2702     String parent = "projects/project-5833/locations/location-5833";
2703 
2704     ListSupportedDatabaseFlagsPagedResponse pagedListResponse =
2705         client.listSupportedDatabaseFlags(parent);
2706 
2707     List<SupportedDatabaseFlag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2708 
2709     Assert.assertEquals(1, resources.size());
2710     Assert.assertEquals(expectedResponse.getSupportedDatabaseFlagsList().get(0), resources.get(0));
2711 
2712     List<String> actualRequests = mockService.getRequestPaths();
2713     Assert.assertEquals(1, actualRequests.size());
2714 
2715     String apiClientHeaderKey =
2716         mockService
2717             .getRequestHeaders()
2718             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2719             .iterator()
2720             .next();
2721     Assert.assertTrue(
2722         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2723             .matcher(apiClientHeaderKey)
2724             .matches());
2725   }
2726 
2727   @Test
listSupportedDatabaseFlagsExceptionTest2()2728   public void listSupportedDatabaseFlagsExceptionTest2() throws Exception {
2729     ApiException exception =
2730         ApiExceptionFactory.createException(
2731             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2732     mockService.addException(exception);
2733 
2734     try {
2735       String parent = "projects/project-5833/locations/location-5833";
2736       client.listSupportedDatabaseFlags(parent);
2737       Assert.fail("No exception raised");
2738     } catch (InvalidArgumentException e) {
2739       // Expected exception.
2740     }
2741   }
2742 
2743   @Test
generateClientCertificateTest()2744   public void generateClientCertificateTest() throws Exception {
2745     GenerateClientCertificateResponse expectedResponse =
2746         GenerateClientCertificateResponse.newBuilder()
2747             .setPemCertificate("pemCertificate153491807")
2748             .addAllPemCertificateChain(new ArrayList<String>())
2749             .build();
2750     mockService.addResponse(expectedResponse);
2751 
2752     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
2753 
2754     GenerateClientCertificateResponse actualResponse = client.generateClientCertificate(parent);
2755     Assert.assertEquals(expectedResponse, actualResponse);
2756 
2757     List<String> actualRequests = mockService.getRequestPaths();
2758     Assert.assertEquals(1, actualRequests.size());
2759 
2760     String apiClientHeaderKey =
2761         mockService
2762             .getRequestHeaders()
2763             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2764             .iterator()
2765             .next();
2766     Assert.assertTrue(
2767         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2768             .matcher(apiClientHeaderKey)
2769             .matches());
2770   }
2771 
2772   @Test
generateClientCertificateExceptionTest()2773   public void generateClientCertificateExceptionTest() throws Exception {
2774     ApiException exception =
2775         ApiExceptionFactory.createException(
2776             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2777     mockService.addException(exception);
2778 
2779     try {
2780       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
2781       client.generateClientCertificate(parent);
2782       Assert.fail("No exception raised");
2783     } catch (InvalidArgumentException e) {
2784       // Expected exception.
2785     }
2786   }
2787 
2788   @Test
generateClientCertificateTest2()2789   public void generateClientCertificateTest2() throws Exception {
2790     GenerateClientCertificateResponse expectedResponse =
2791         GenerateClientCertificateResponse.newBuilder()
2792             .setPemCertificate("pemCertificate153491807")
2793             .addAllPemCertificateChain(new ArrayList<String>())
2794             .build();
2795     mockService.addResponse(expectedResponse);
2796 
2797     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
2798 
2799     GenerateClientCertificateResponse actualResponse = client.generateClientCertificate(parent);
2800     Assert.assertEquals(expectedResponse, actualResponse);
2801 
2802     List<String> actualRequests = mockService.getRequestPaths();
2803     Assert.assertEquals(1, actualRequests.size());
2804 
2805     String apiClientHeaderKey =
2806         mockService
2807             .getRequestHeaders()
2808             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2809             .iterator()
2810             .next();
2811     Assert.assertTrue(
2812         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2813             .matcher(apiClientHeaderKey)
2814             .matches());
2815   }
2816 
2817   @Test
generateClientCertificateExceptionTest2()2818   public void generateClientCertificateExceptionTest2() throws Exception {
2819     ApiException exception =
2820         ApiExceptionFactory.createException(
2821             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2822     mockService.addException(exception);
2823 
2824     try {
2825       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
2826       client.generateClientCertificate(parent);
2827       Assert.fail("No exception raised");
2828     } catch (InvalidArgumentException e) {
2829       // Expected exception.
2830     }
2831   }
2832 
2833   @Test
getConnectionInfoTest()2834   public void getConnectionInfoTest() throws Exception {
2835     ConnectionInfo expectedResponse =
2836         ConnectionInfo.newBuilder()
2837             .setName("name3373707")
2838             .setIpAddress("ipAddress1634032845")
2839             .addAllPemCertificateChain(new ArrayList<String>())
2840             .setInstanceUid("instanceUid-2102004869")
2841             .build();
2842     mockService.addResponse(expectedResponse);
2843 
2844     InstanceName parent = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
2845 
2846     ConnectionInfo actualResponse = client.getConnectionInfo(parent);
2847     Assert.assertEquals(expectedResponse, actualResponse);
2848 
2849     List<String> actualRequests = mockService.getRequestPaths();
2850     Assert.assertEquals(1, actualRequests.size());
2851 
2852     String apiClientHeaderKey =
2853         mockService
2854             .getRequestHeaders()
2855             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2856             .iterator()
2857             .next();
2858     Assert.assertTrue(
2859         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2860             .matcher(apiClientHeaderKey)
2861             .matches());
2862   }
2863 
2864   @Test
getConnectionInfoExceptionTest()2865   public void getConnectionInfoExceptionTest() throws Exception {
2866     ApiException exception =
2867         ApiExceptionFactory.createException(
2868             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2869     mockService.addException(exception);
2870 
2871     try {
2872       InstanceName parent = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
2873       client.getConnectionInfo(parent);
2874       Assert.fail("No exception raised");
2875     } catch (InvalidArgumentException e) {
2876       // Expected exception.
2877     }
2878   }
2879 
2880   @Test
getConnectionInfoTest2()2881   public void getConnectionInfoTest2() throws Exception {
2882     ConnectionInfo expectedResponse =
2883         ConnectionInfo.newBuilder()
2884             .setName("name3373707")
2885             .setIpAddress("ipAddress1634032845")
2886             .addAllPemCertificateChain(new ArrayList<String>())
2887             .setInstanceUid("instanceUid-2102004869")
2888             .build();
2889     mockService.addResponse(expectedResponse);
2890 
2891     String parent =
2892         "projects/project-9084/locations/location-9084/clusters/cluster-9084/instances/instance-9084";
2893 
2894     ConnectionInfo actualResponse = client.getConnectionInfo(parent);
2895     Assert.assertEquals(expectedResponse, actualResponse);
2896 
2897     List<String> actualRequests = mockService.getRequestPaths();
2898     Assert.assertEquals(1, actualRequests.size());
2899 
2900     String apiClientHeaderKey =
2901         mockService
2902             .getRequestHeaders()
2903             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2904             .iterator()
2905             .next();
2906     Assert.assertTrue(
2907         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2908             .matcher(apiClientHeaderKey)
2909             .matches());
2910   }
2911 
2912   @Test
getConnectionInfoExceptionTest2()2913   public void getConnectionInfoExceptionTest2() throws Exception {
2914     ApiException exception =
2915         ApiExceptionFactory.createException(
2916             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2917     mockService.addException(exception);
2918 
2919     try {
2920       String parent =
2921           "projects/project-9084/locations/location-9084/clusters/cluster-9084/instances/instance-9084";
2922       client.getConnectionInfo(parent);
2923       Assert.fail("No exception raised");
2924     } catch (InvalidArgumentException e) {
2925       // Expected exception.
2926     }
2927   }
2928 
2929   @Test
listLocationsTest()2930   public void listLocationsTest() throws Exception {
2931     Location responsesElement = Location.newBuilder().build();
2932     ListLocationsResponse expectedResponse =
2933         ListLocationsResponse.newBuilder()
2934             .setNextPageToken("")
2935             .addAllLocations(Arrays.asList(responsesElement))
2936             .build();
2937     mockService.addResponse(expectedResponse);
2938 
2939     ListLocationsRequest request =
2940         ListLocationsRequest.newBuilder()
2941             .setName("projects/project-3664")
2942             .setFilter("filter-1274492040")
2943             .setPageSize(883849137)
2944             .setPageToken("pageToken873572522")
2945             .build();
2946 
2947     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2948 
2949     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2950 
2951     Assert.assertEquals(1, resources.size());
2952     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2953 
2954     List<String> actualRequests = mockService.getRequestPaths();
2955     Assert.assertEquals(1, actualRequests.size());
2956 
2957     String apiClientHeaderKey =
2958         mockService
2959             .getRequestHeaders()
2960             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2961             .iterator()
2962             .next();
2963     Assert.assertTrue(
2964         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2965             .matcher(apiClientHeaderKey)
2966             .matches());
2967   }
2968 
2969   @Test
listLocationsExceptionTest()2970   public void listLocationsExceptionTest() throws Exception {
2971     ApiException exception =
2972         ApiExceptionFactory.createException(
2973             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2974     mockService.addException(exception);
2975 
2976     try {
2977       ListLocationsRequest request =
2978           ListLocationsRequest.newBuilder()
2979               .setName("projects/project-3664")
2980               .setFilter("filter-1274492040")
2981               .setPageSize(883849137)
2982               .setPageToken("pageToken873572522")
2983               .build();
2984       client.listLocations(request);
2985       Assert.fail("No exception raised");
2986     } catch (InvalidArgumentException e) {
2987       // Expected exception.
2988     }
2989   }
2990 
2991   @Test
getLocationTest()2992   public void getLocationTest() throws Exception {
2993     Location expectedResponse =
2994         Location.newBuilder()
2995             .setName("name3373707")
2996             .setLocationId("locationId1541836720")
2997             .setDisplayName("displayName1714148973")
2998             .putAllLabels(new HashMap<String, String>())
2999             .setMetadata(Any.newBuilder().build())
3000             .build();
3001     mockService.addResponse(expectedResponse);
3002 
3003     GetLocationRequest request =
3004         GetLocationRequest.newBuilder()
3005             .setName("projects/project-9062/locations/location-9062")
3006             .build();
3007 
3008     Location actualResponse = client.getLocation(request);
3009     Assert.assertEquals(expectedResponse, actualResponse);
3010 
3011     List<String> actualRequests = mockService.getRequestPaths();
3012     Assert.assertEquals(1, actualRequests.size());
3013 
3014     String apiClientHeaderKey =
3015         mockService
3016             .getRequestHeaders()
3017             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3018             .iterator()
3019             .next();
3020     Assert.assertTrue(
3021         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3022             .matcher(apiClientHeaderKey)
3023             .matches());
3024   }
3025 
3026   @Test
getLocationExceptionTest()3027   public void getLocationExceptionTest() throws Exception {
3028     ApiException exception =
3029         ApiExceptionFactory.createException(
3030             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3031     mockService.addException(exception);
3032 
3033     try {
3034       GetLocationRequest request =
3035           GetLocationRequest.newBuilder()
3036               .setName("projects/project-9062/locations/location-9062")
3037               .build();
3038       client.getLocation(request);
3039       Assert.fail("No exception raised");
3040     } catch (InvalidArgumentException e) {
3041       // Expected exception.
3042     }
3043   }
3044 }
3045