• 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.v1;
18 
19 import static com.google.cloud.alloydb.v1.AlloyDBAdminClient.ListBackupsPagedResponse;
20 import static com.google.cloud.alloydb.v1.AlloyDBAdminClient.ListClustersPagedResponse;
21 import static com.google.cloud.alloydb.v1.AlloyDBAdminClient.ListInstancesPagedResponse;
22 import static com.google.cloud.alloydb.v1.AlloyDBAdminClient.ListLocationsPagedResponse;
23 import static com.google.cloud.alloydb.v1.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.v1.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             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
216             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
217             .build();
218     mockService.addResponse(expectedResponse);
219 
220     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
221 
222     Cluster actualResponse = client.getCluster(name);
223     Assert.assertEquals(expectedResponse, actualResponse);
224 
225     List<String> actualRequests = mockService.getRequestPaths();
226     Assert.assertEquals(1, actualRequests.size());
227 
228     String apiClientHeaderKey =
229         mockService
230             .getRequestHeaders()
231             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
232             .iterator()
233             .next();
234     Assert.assertTrue(
235         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
236             .matcher(apiClientHeaderKey)
237             .matches());
238   }
239 
240   @Test
getClusterExceptionTest()241   public void getClusterExceptionTest() throws Exception {
242     ApiException exception =
243         ApiExceptionFactory.createException(
244             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
245     mockService.addException(exception);
246 
247     try {
248       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
249       client.getCluster(name);
250       Assert.fail("No exception raised");
251     } catch (InvalidArgumentException e) {
252       // Expected exception.
253     }
254   }
255 
256   @Test
getClusterTest2()257   public void getClusterTest2() throws Exception {
258     Cluster expectedResponse =
259         Cluster.newBuilder()
260             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
261             .setDisplayName("displayName1714148973")
262             .setUid("uid115792")
263             .setCreateTime(Timestamp.newBuilder().build())
264             .setUpdateTime(Timestamp.newBuilder().build())
265             .setDeleteTime(Timestamp.newBuilder().build())
266             .putAllLabels(new HashMap<String, String>())
267             .setDatabaseVersion(DatabaseVersion.forNumber(0))
268             .setNetwork("network1843485230")
269             .setEtag("etag3123477")
270             .putAllAnnotations(new HashMap<String, String>())
271             .setReconciling(true)
272             .setInitialUser(UserPassword.newBuilder().build())
273             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
274             .setSslConfig(SslConfig.newBuilder().build())
275             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
276             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
277             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
278             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
279             .build();
280     mockService.addResponse(expectedResponse);
281 
282     String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
283 
284     Cluster actualResponse = client.getCluster(name);
285     Assert.assertEquals(expectedResponse, actualResponse);
286 
287     List<String> actualRequests = mockService.getRequestPaths();
288     Assert.assertEquals(1, actualRequests.size());
289 
290     String apiClientHeaderKey =
291         mockService
292             .getRequestHeaders()
293             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
294             .iterator()
295             .next();
296     Assert.assertTrue(
297         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
298             .matcher(apiClientHeaderKey)
299             .matches());
300   }
301 
302   @Test
getClusterExceptionTest2()303   public void getClusterExceptionTest2() throws Exception {
304     ApiException exception =
305         ApiExceptionFactory.createException(
306             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
307     mockService.addException(exception);
308 
309     try {
310       String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
311       client.getCluster(name);
312       Assert.fail("No exception raised");
313     } catch (InvalidArgumentException e) {
314       // Expected exception.
315     }
316   }
317 
318   @Test
createClusterTest()319   public void createClusterTest() throws Exception {
320     Cluster expectedResponse =
321         Cluster.newBuilder()
322             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
323             .setDisplayName("displayName1714148973")
324             .setUid("uid115792")
325             .setCreateTime(Timestamp.newBuilder().build())
326             .setUpdateTime(Timestamp.newBuilder().build())
327             .setDeleteTime(Timestamp.newBuilder().build())
328             .putAllLabels(new HashMap<String, String>())
329             .setDatabaseVersion(DatabaseVersion.forNumber(0))
330             .setNetwork("network1843485230")
331             .setEtag("etag3123477")
332             .putAllAnnotations(new HashMap<String, String>())
333             .setReconciling(true)
334             .setInitialUser(UserPassword.newBuilder().build())
335             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
336             .setSslConfig(SslConfig.newBuilder().build())
337             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
338             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
339             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
340             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
341             .build();
342     Operation resultOperation =
343         Operation.newBuilder()
344             .setName("createClusterTest")
345             .setDone(true)
346             .setResponse(Any.pack(expectedResponse))
347             .build();
348     mockService.addResponse(resultOperation);
349 
350     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
351     Cluster cluster = Cluster.newBuilder().build();
352     String clusterId = "clusterId561939637";
353 
354     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
355     Assert.assertEquals(expectedResponse, actualResponse);
356 
357     List<String> actualRequests = mockService.getRequestPaths();
358     Assert.assertEquals(1, actualRequests.size());
359 
360     String apiClientHeaderKey =
361         mockService
362             .getRequestHeaders()
363             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
364             .iterator()
365             .next();
366     Assert.assertTrue(
367         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
368             .matcher(apiClientHeaderKey)
369             .matches());
370   }
371 
372   @Test
createClusterExceptionTest()373   public void createClusterExceptionTest() throws Exception {
374     ApiException exception =
375         ApiExceptionFactory.createException(
376             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
377     mockService.addException(exception);
378 
379     try {
380       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
381       Cluster cluster = Cluster.newBuilder().build();
382       String clusterId = "clusterId561939637";
383       client.createClusterAsync(parent, cluster, clusterId).get();
384       Assert.fail("No exception raised");
385     } catch (ExecutionException e) {
386     }
387   }
388 
389   @Test
createClusterTest2()390   public void createClusterTest2() throws Exception {
391     Cluster expectedResponse =
392         Cluster.newBuilder()
393             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
394             .setDisplayName("displayName1714148973")
395             .setUid("uid115792")
396             .setCreateTime(Timestamp.newBuilder().build())
397             .setUpdateTime(Timestamp.newBuilder().build())
398             .setDeleteTime(Timestamp.newBuilder().build())
399             .putAllLabels(new HashMap<String, String>())
400             .setDatabaseVersion(DatabaseVersion.forNumber(0))
401             .setNetwork("network1843485230")
402             .setEtag("etag3123477")
403             .putAllAnnotations(new HashMap<String, String>())
404             .setReconciling(true)
405             .setInitialUser(UserPassword.newBuilder().build())
406             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
407             .setSslConfig(SslConfig.newBuilder().build())
408             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
409             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
410             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
411             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
412             .build();
413     Operation resultOperation =
414         Operation.newBuilder()
415             .setName("createClusterTest")
416             .setDone(true)
417             .setResponse(Any.pack(expectedResponse))
418             .build();
419     mockService.addResponse(resultOperation);
420 
421     String parent = "projects/project-5833/locations/location-5833";
422     Cluster cluster = Cluster.newBuilder().build();
423     String clusterId = "clusterId561939637";
424 
425     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<String> actualRequests = mockService.getRequestPaths();
429     Assert.assertEquals(1, actualRequests.size());
430 
431     String apiClientHeaderKey =
432         mockService
433             .getRequestHeaders()
434             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
435             .iterator()
436             .next();
437     Assert.assertTrue(
438         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
439             .matcher(apiClientHeaderKey)
440             .matches());
441   }
442 
443   @Test
createClusterExceptionTest2()444   public void createClusterExceptionTest2() throws Exception {
445     ApiException exception =
446         ApiExceptionFactory.createException(
447             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
448     mockService.addException(exception);
449 
450     try {
451       String parent = "projects/project-5833/locations/location-5833";
452       Cluster cluster = Cluster.newBuilder().build();
453       String clusterId = "clusterId561939637";
454       client.createClusterAsync(parent, cluster, clusterId).get();
455       Assert.fail("No exception raised");
456     } catch (ExecutionException e) {
457     }
458   }
459 
460   @Test
updateClusterTest()461   public void updateClusterTest() throws Exception {
462     Cluster expectedResponse =
463         Cluster.newBuilder()
464             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
465             .setDisplayName("displayName1714148973")
466             .setUid("uid115792")
467             .setCreateTime(Timestamp.newBuilder().build())
468             .setUpdateTime(Timestamp.newBuilder().build())
469             .setDeleteTime(Timestamp.newBuilder().build())
470             .putAllLabels(new HashMap<String, String>())
471             .setDatabaseVersion(DatabaseVersion.forNumber(0))
472             .setNetwork("network1843485230")
473             .setEtag("etag3123477")
474             .putAllAnnotations(new HashMap<String, String>())
475             .setReconciling(true)
476             .setInitialUser(UserPassword.newBuilder().build())
477             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
478             .setSslConfig(SslConfig.newBuilder().build())
479             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
480             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
481             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
482             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
483             .build();
484     Operation resultOperation =
485         Operation.newBuilder()
486             .setName("updateClusterTest")
487             .setDone(true)
488             .setResponse(Any.pack(expectedResponse))
489             .build();
490     mockService.addResponse(resultOperation);
491 
492     Cluster cluster =
493         Cluster.newBuilder()
494             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
495             .setDisplayName("displayName1714148973")
496             .setUid("uid115792")
497             .setCreateTime(Timestamp.newBuilder().build())
498             .setUpdateTime(Timestamp.newBuilder().build())
499             .setDeleteTime(Timestamp.newBuilder().build())
500             .putAllLabels(new HashMap<String, String>())
501             .setDatabaseVersion(DatabaseVersion.forNumber(0))
502             .setNetwork("network1843485230")
503             .setEtag("etag3123477")
504             .putAllAnnotations(new HashMap<String, String>())
505             .setReconciling(true)
506             .setInitialUser(UserPassword.newBuilder().build())
507             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
508             .setSslConfig(SslConfig.newBuilder().build())
509             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
510             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
511             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
512             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
513             .build();
514     FieldMask updateMask = FieldMask.newBuilder().build();
515 
516     Cluster actualResponse = client.updateClusterAsync(cluster, updateMask).get();
517     Assert.assertEquals(expectedResponse, actualResponse);
518 
519     List<String> actualRequests = mockService.getRequestPaths();
520     Assert.assertEquals(1, actualRequests.size());
521 
522     String apiClientHeaderKey =
523         mockService
524             .getRequestHeaders()
525             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
526             .iterator()
527             .next();
528     Assert.assertTrue(
529         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
530             .matcher(apiClientHeaderKey)
531             .matches());
532   }
533 
534   @Test
updateClusterExceptionTest()535   public void updateClusterExceptionTest() throws Exception {
536     ApiException exception =
537         ApiExceptionFactory.createException(
538             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
539     mockService.addException(exception);
540 
541     try {
542       Cluster cluster =
543           Cluster.newBuilder()
544               .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
545               .setDisplayName("displayName1714148973")
546               .setUid("uid115792")
547               .setCreateTime(Timestamp.newBuilder().build())
548               .setUpdateTime(Timestamp.newBuilder().build())
549               .setDeleteTime(Timestamp.newBuilder().build())
550               .putAllLabels(new HashMap<String, String>())
551               .setDatabaseVersion(DatabaseVersion.forNumber(0))
552               .setNetwork("network1843485230")
553               .setEtag("etag3123477")
554               .putAllAnnotations(new HashMap<String, String>())
555               .setReconciling(true)
556               .setInitialUser(UserPassword.newBuilder().build())
557               .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
558               .setSslConfig(SslConfig.newBuilder().build())
559               .setEncryptionConfig(EncryptionConfig.newBuilder().build())
560               .setEncryptionInfo(EncryptionInfo.newBuilder().build())
561               .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
562               .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
563               .build();
564       FieldMask updateMask = FieldMask.newBuilder().build();
565       client.updateClusterAsync(cluster, updateMask).get();
566       Assert.fail("No exception raised");
567     } catch (ExecutionException e) {
568     }
569   }
570 
571   @Test
deleteClusterTest()572   public void deleteClusterTest() throws Exception {
573     Empty expectedResponse = Empty.newBuilder().build();
574     Operation resultOperation =
575         Operation.newBuilder()
576             .setName("deleteClusterTest")
577             .setDone(true)
578             .setResponse(Any.pack(expectedResponse))
579             .build();
580     mockService.addResponse(resultOperation);
581 
582     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
583 
584     client.deleteClusterAsync(name).get();
585 
586     List<String> actualRequests = mockService.getRequestPaths();
587     Assert.assertEquals(1, actualRequests.size());
588 
589     String apiClientHeaderKey =
590         mockService
591             .getRequestHeaders()
592             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
593             .iterator()
594             .next();
595     Assert.assertTrue(
596         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
597             .matcher(apiClientHeaderKey)
598             .matches());
599   }
600 
601   @Test
deleteClusterExceptionTest()602   public void deleteClusterExceptionTest() throws Exception {
603     ApiException exception =
604         ApiExceptionFactory.createException(
605             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
606     mockService.addException(exception);
607 
608     try {
609       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
610       client.deleteClusterAsync(name).get();
611       Assert.fail("No exception raised");
612     } catch (ExecutionException e) {
613     }
614   }
615 
616   @Test
deleteClusterTest2()617   public void deleteClusterTest2() throws Exception {
618     Empty expectedResponse = Empty.newBuilder().build();
619     Operation resultOperation =
620         Operation.newBuilder()
621             .setName("deleteClusterTest")
622             .setDone(true)
623             .setResponse(Any.pack(expectedResponse))
624             .build();
625     mockService.addResponse(resultOperation);
626 
627     String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
628 
629     client.deleteClusterAsync(name).get();
630 
631     List<String> actualRequests = mockService.getRequestPaths();
632     Assert.assertEquals(1, actualRequests.size());
633 
634     String apiClientHeaderKey =
635         mockService
636             .getRequestHeaders()
637             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
638             .iterator()
639             .next();
640     Assert.assertTrue(
641         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
642             .matcher(apiClientHeaderKey)
643             .matches());
644   }
645 
646   @Test
deleteClusterExceptionTest2()647   public void deleteClusterExceptionTest2() throws Exception {
648     ApiException exception =
649         ApiExceptionFactory.createException(
650             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
651     mockService.addException(exception);
652 
653     try {
654       String name = "projects/project-6537/locations/location-6537/clusters/cluster-6537";
655       client.deleteClusterAsync(name).get();
656       Assert.fail("No exception raised");
657     } catch (ExecutionException e) {
658     }
659   }
660 
661   @Test
restoreClusterTest()662   public void restoreClusterTest() throws Exception {
663     Cluster expectedResponse =
664         Cluster.newBuilder()
665             .setName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
666             .setDisplayName("displayName1714148973")
667             .setUid("uid115792")
668             .setCreateTime(Timestamp.newBuilder().build())
669             .setUpdateTime(Timestamp.newBuilder().build())
670             .setDeleteTime(Timestamp.newBuilder().build())
671             .putAllLabels(new HashMap<String, String>())
672             .setDatabaseVersion(DatabaseVersion.forNumber(0))
673             .setNetwork("network1843485230")
674             .setEtag("etag3123477")
675             .putAllAnnotations(new HashMap<String, String>())
676             .setReconciling(true)
677             .setInitialUser(UserPassword.newBuilder().build())
678             .setAutomatedBackupPolicy(AutomatedBackupPolicy.newBuilder().build())
679             .setSslConfig(SslConfig.newBuilder().build())
680             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
681             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
682             .setSecondaryConfig(Cluster.SecondaryConfig.newBuilder().build())
683             .setPrimaryConfig(Cluster.PrimaryConfig.newBuilder().build())
684             .build();
685     Operation resultOperation =
686         Operation.newBuilder()
687             .setName("restoreClusterTest")
688             .setDone(true)
689             .setResponse(Any.pack(expectedResponse))
690             .build();
691     mockService.addResponse(resultOperation);
692 
693     RestoreClusterRequest request =
694         RestoreClusterRequest.newBuilder()
695             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
696             .setClusterId("clusterId561939637")
697             .setCluster(Cluster.newBuilder().build())
698             .setRequestId("requestId693933066")
699             .setValidateOnly(true)
700             .build();
701 
702     Cluster actualResponse = client.restoreClusterAsync(request).get();
703     Assert.assertEquals(expectedResponse, actualResponse);
704 
705     List<String> actualRequests = mockService.getRequestPaths();
706     Assert.assertEquals(1, actualRequests.size());
707 
708     String apiClientHeaderKey =
709         mockService
710             .getRequestHeaders()
711             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
712             .iterator()
713             .next();
714     Assert.assertTrue(
715         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
716             .matcher(apiClientHeaderKey)
717             .matches());
718   }
719 
720   @Test
restoreClusterExceptionTest()721   public void restoreClusterExceptionTest() throws Exception {
722     ApiException exception =
723         ApiExceptionFactory.createException(
724             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
725     mockService.addException(exception);
726 
727     try {
728       RestoreClusterRequest request =
729           RestoreClusterRequest.newBuilder()
730               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
731               .setClusterId("clusterId561939637")
732               .setCluster(Cluster.newBuilder().build())
733               .setRequestId("requestId693933066")
734               .setValidateOnly(true)
735               .build();
736       client.restoreClusterAsync(request).get();
737       Assert.fail("No exception raised");
738     } catch (ExecutionException e) {
739     }
740   }
741 
742   @Test
listInstancesTest()743   public void listInstancesTest() throws Exception {
744     Instance responsesElement = Instance.newBuilder().build();
745     ListInstancesResponse expectedResponse =
746         ListInstancesResponse.newBuilder()
747             .setNextPageToken("")
748             .addAllInstances(Arrays.asList(responsesElement))
749             .build();
750     mockService.addResponse(expectedResponse);
751 
752     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
753 
754     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
755 
756     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
757 
758     Assert.assertEquals(1, resources.size());
759     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
760 
761     List<String> actualRequests = mockService.getRequestPaths();
762     Assert.assertEquals(1, actualRequests.size());
763 
764     String apiClientHeaderKey =
765         mockService
766             .getRequestHeaders()
767             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
768             .iterator()
769             .next();
770     Assert.assertTrue(
771         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
772             .matcher(apiClientHeaderKey)
773             .matches());
774   }
775 
776   @Test
listInstancesExceptionTest()777   public void listInstancesExceptionTest() throws Exception {
778     ApiException exception =
779         ApiExceptionFactory.createException(
780             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
781     mockService.addException(exception);
782 
783     try {
784       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
785       client.listInstances(parent);
786       Assert.fail("No exception raised");
787     } catch (InvalidArgumentException e) {
788       // Expected exception.
789     }
790   }
791 
792   @Test
listInstancesTest2()793   public void listInstancesTest2() throws Exception {
794     Instance responsesElement = Instance.newBuilder().build();
795     ListInstancesResponse expectedResponse =
796         ListInstancesResponse.newBuilder()
797             .setNextPageToken("")
798             .addAllInstances(Arrays.asList(responsesElement))
799             .build();
800     mockService.addResponse(expectedResponse);
801 
802     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
803 
804     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
805 
806     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
807 
808     Assert.assertEquals(1, resources.size());
809     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
810 
811     List<String> actualRequests = mockService.getRequestPaths();
812     Assert.assertEquals(1, actualRequests.size());
813 
814     String apiClientHeaderKey =
815         mockService
816             .getRequestHeaders()
817             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
818             .iterator()
819             .next();
820     Assert.assertTrue(
821         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
822             .matcher(apiClientHeaderKey)
823             .matches());
824   }
825 
826   @Test
listInstancesExceptionTest2()827   public void listInstancesExceptionTest2() throws Exception {
828     ApiException exception =
829         ApiExceptionFactory.createException(
830             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
831     mockService.addException(exception);
832 
833     try {
834       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
835       client.listInstances(parent);
836       Assert.fail("No exception raised");
837     } catch (InvalidArgumentException e) {
838       // Expected exception.
839     }
840   }
841 
842   @Test
getInstanceTest()843   public void getInstanceTest() throws Exception {
844     Instance expectedResponse =
845         Instance.newBuilder()
846             .setName(
847                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
848             .setDisplayName("displayName1714148973")
849             .setUid("uid115792")
850             .setCreateTime(Timestamp.newBuilder().build())
851             .setUpdateTime(Timestamp.newBuilder().build())
852             .setDeleteTime(Timestamp.newBuilder().build())
853             .putAllLabels(new HashMap<String, String>())
854             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
855             .setGceZone("gceZone-146048427")
856             .putAllDatabaseFlags(new HashMap<String, String>())
857             .setWritableNode(Instance.Node.newBuilder().build())
858             .addAllNodes(new ArrayList<Instance.Node>())
859             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
860             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
861             .setIpAddress("ipAddress1634032845")
862             .setReconciling(true)
863             .setEtag("etag3123477")
864             .putAllAnnotations(new HashMap<String, String>())
865             .build();
866     mockService.addResponse(expectedResponse);
867 
868     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
869 
870     Instance actualResponse = client.getInstance(name);
871     Assert.assertEquals(expectedResponse, actualResponse);
872 
873     List<String> actualRequests = mockService.getRequestPaths();
874     Assert.assertEquals(1, actualRequests.size());
875 
876     String apiClientHeaderKey =
877         mockService
878             .getRequestHeaders()
879             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
880             .iterator()
881             .next();
882     Assert.assertTrue(
883         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
884             .matcher(apiClientHeaderKey)
885             .matches());
886   }
887 
888   @Test
getInstanceExceptionTest()889   public void getInstanceExceptionTest() throws Exception {
890     ApiException exception =
891         ApiExceptionFactory.createException(
892             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
893     mockService.addException(exception);
894 
895     try {
896       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
897       client.getInstance(name);
898       Assert.fail("No exception raised");
899     } catch (InvalidArgumentException e) {
900       // Expected exception.
901     }
902   }
903 
904   @Test
getInstanceTest2()905   public void getInstanceTest2() throws Exception {
906     Instance expectedResponse =
907         Instance.newBuilder()
908             .setName(
909                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
910             .setDisplayName("displayName1714148973")
911             .setUid("uid115792")
912             .setCreateTime(Timestamp.newBuilder().build())
913             .setUpdateTime(Timestamp.newBuilder().build())
914             .setDeleteTime(Timestamp.newBuilder().build())
915             .putAllLabels(new HashMap<String, String>())
916             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
917             .setGceZone("gceZone-146048427")
918             .putAllDatabaseFlags(new HashMap<String, String>())
919             .setWritableNode(Instance.Node.newBuilder().build())
920             .addAllNodes(new ArrayList<Instance.Node>())
921             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
922             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
923             .setIpAddress("ipAddress1634032845")
924             .setReconciling(true)
925             .setEtag("etag3123477")
926             .putAllAnnotations(new HashMap<String, String>())
927             .build();
928     mockService.addResponse(expectedResponse);
929 
930     String name =
931         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
932 
933     Instance actualResponse = client.getInstance(name);
934     Assert.assertEquals(expectedResponse, actualResponse);
935 
936     List<String> actualRequests = mockService.getRequestPaths();
937     Assert.assertEquals(1, actualRequests.size());
938 
939     String apiClientHeaderKey =
940         mockService
941             .getRequestHeaders()
942             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
943             .iterator()
944             .next();
945     Assert.assertTrue(
946         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
947             .matcher(apiClientHeaderKey)
948             .matches());
949   }
950 
951   @Test
getInstanceExceptionTest2()952   public void getInstanceExceptionTest2() throws Exception {
953     ApiException exception =
954         ApiExceptionFactory.createException(
955             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
956     mockService.addException(exception);
957 
958     try {
959       String name =
960           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
961       client.getInstance(name);
962       Assert.fail("No exception raised");
963     } catch (InvalidArgumentException e) {
964       // Expected exception.
965     }
966   }
967 
968   @Test
createInstanceTest()969   public void createInstanceTest() throws Exception {
970     Instance expectedResponse =
971         Instance.newBuilder()
972             .setName(
973                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").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             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
981             .setGceZone("gceZone-146048427")
982             .putAllDatabaseFlags(new HashMap<String, String>())
983             .setWritableNode(Instance.Node.newBuilder().build())
984             .addAllNodes(new ArrayList<Instance.Node>())
985             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
986             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
987             .setIpAddress("ipAddress1634032845")
988             .setReconciling(true)
989             .setEtag("etag3123477")
990             .putAllAnnotations(new HashMap<String, String>())
991             .build();
992     Operation resultOperation =
993         Operation.newBuilder()
994             .setName("createInstanceTest")
995             .setDone(true)
996             .setResponse(Any.pack(expectedResponse))
997             .build();
998     mockService.addResponse(resultOperation);
999 
1000     ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1001     Instance instance = Instance.newBuilder().build();
1002     String instanceId = "instanceId902024336";
1003 
1004     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
1005     Assert.assertEquals(expectedResponse, actualResponse);
1006 
1007     List<String> actualRequests = mockService.getRequestPaths();
1008     Assert.assertEquals(1, actualRequests.size());
1009 
1010     String apiClientHeaderKey =
1011         mockService
1012             .getRequestHeaders()
1013             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1014             .iterator()
1015             .next();
1016     Assert.assertTrue(
1017         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1018             .matcher(apiClientHeaderKey)
1019             .matches());
1020   }
1021 
1022   @Test
createInstanceExceptionTest()1023   public void createInstanceExceptionTest() throws Exception {
1024     ApiException exception =
1025         ApiExceptionFactory.createException(
1026             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1027     mockService.addException(exception);
1028 
1029     try {
1030       ClusterName parent = ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]");
1031       Instance instance = Instance.newBuilder().build();
1032       String instanceId = "instanceId902024336";
1033       client.createInstanceAsync(parent, instance, instanceId).get();
1034       Assert.fail("No exception raised");
1035     } catch (ExecutionException e) {
1036     }
1037   }
1038 
1039   @Test
createInstanceTest2()1040   public void createInstanceTest2() throws Exception {
1041     Instance expectedResponse =
1042         Instance.newBuilder()
1043             .setName(
1044                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1045             .setDisplayName("displayName1714148973")
1046             .setUid("uid115792")
1047             .setCreateTime(Timestamp.newBuilder().build())
1048             .setUpdateTime(Timestamp.newBuilder().build())
1049             .setDeleteTime(Timestamp.newBuilder().build())
1050             .putAllLabels(new HashMap<String, String>())
1051             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1052             .setGceZone("gceZone-146048427")
1053             .putAllDatabaseFlags(new HashMap<String, String>())
1054             .setWritableNode(Instance.Node.newBuilder().build())
1055             .addAllNodes(new ArrayList<Instance.Node>())
1056             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1057             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1058             .setIpAddress("ipAddress1634032845")
1059             .setReconciling(true)
1060             .setEtag("etag3123477")
1061             .putAllAnnotations(new HashMap<String, String>())
1062             .build();
1063     Operation resultOperation =
1064         Operation.newBuilder()
1065             .setName("createInstanceTest")
1066             .setDone(true)
1067             .setResponse(Any.pack(expectedResponse))
1068             .build();
1069     mockService.addResponse(resultOperation);
1070 
1071     String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1072     Instance instance = Instance.newBuilder().build();
1073     String instanceId = "instanceId902024336";
1074 
1075     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
1076     Assert.assertEquals(expectedResponse, actualResponse);
1077 
1078     List<String> actualRequests = mockService.getRequestPaths();
1079     Assert.assertEquals(1, actualRequests.size());
1080 
1081     String apiClientHeaderKey =
1082         mockService
1083             .getRequestHeaders()
1084             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1085             .iterator()
1086             .next();
1087     Assert.assertTrue(
1088         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1089             .matcher(apiClientHeaderKey)
1090             .matches());
1091   }
1092 
1093   @Test
createInstanceExceptionTest2()1094   public void createInstanceExceptionTest2() throws Exception {
1095     ApiException exception =
1096         ApiExceptionFactory.createException(
1097             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1098     mockService.addException(exception);
1099 
1100     try {
1101       String parent = "projects/project-9466/locations/location-9466/clusters/cluster-9466";
1102       Instance instance = Instance.newBuilder().build();
1103       String instanceId = "instanceId902024336";
1104       client.createInstanceAsync(parent, instance, instanceId).get();
1105       Assert.fail("No exception raised");
1106     } catch (ExecutionException e) {
1107     }
1108   }
1109 
1110   @Test
batchCreateInstancesTest()1111   public void batchCreateInstancesTest() throws Exception {
1112     BatchCreateInstancesResponse expectedResponse =
1113         BatchCreateInstancesResponse.newBuilder()
1114             .addAllInstances(new ArrayList<Instance>())
1115             .build();
1116     Operation resultOperation =
1117         Operation.newBuilder()
1118             .setName("batchCreateInstancesTest")
1119             .setDone(true)
1120             .setResponse(Any.pack(expectedResponse))
1121             .build();
1122     mockService.addResponse(resultOperation);
1123 
1124     BatchCreateInstancesRequest request =
1125         BatchCreateInstancesRequest.newBuilder()
1126             .setParent(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1127             .setRequests(CreateInstanceRequests.newBuilder().build())
1128             .setRequestId("requestId693933066")
1129             .build();
1130 
1131     BatchCreateInstancesResponse actualResponse = client.batchCreateInstancesAsync(request).get();
1132     Assert.assertEquals(expectedResponse, actualResponse);
1133 
1134     List<String> actualRequests = mockService.getRequestPaths();
1135     Assert.assertEquals(1, actualRequests.size());
1136 
1137     String apiClientHeaderKey =
1138         mockService
1139             .getRequestHeaders()
1140             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1141             .iterator()
1142             .next();
1143     Assert.assertTrue(
1144         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1145             .matcher(apiClientHeaderKey)
1146             .matches());
1147   }
1148 
1149   @Test
batchCreateInstancesExceptionTest()1150   public void batchCreateInstancesExceptionTest() throws Exception {
1151     ApiException exception =
1152         ApiExceptionFactory.createException(
1153             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1154     mockService.addException(exception);
1155 
1156     try {
1157       BatchCreateInstancesRequest request =
1158           BatchCreateInstancesRequest.newBuilder()
1159               .setParent(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1160               .setRequests(CreateInstanceRequests.newBuilder().build())
1161               .setRequestId("requestId693933066")
1162               .build();
1163       client.batchCreateInstancesAsync(request).get();
1164       Assert.fail("No exception raised");
1165     } catch (ExecutionException e) {
1166     }
1167   }
1168 
1169   @Test
updateInstanceTest()1170   public void updateInstanceTest() throws Exception {
1171     Instance expectedResponse =
1172         Instance.newBuilder()
1173             .setName(
1174                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1175             .setDisplayName("displayName1714148973")
1176             .setUid("uid115792")
1177             .setCreateTime(Timestamp.newBuilder().build())
1178             .setUpdateTime(Timestamp.newBuilder().build())
1179             .setDeleteTime(Timestamp.newBuilder().build())
1180             .putAllLabels(new HashMap<String, String>())
1181             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1182             .setGceZone("gceZone-146048427")
1183             .putAllDatabaseFlags(new HashMap<String, String>())
1184             .setWritableNode(Instance.Node.newBuilder().build())
1185             .addAllNodes(new ArrayList<Instance.Node>())
1186             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1187             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1188             .setIpAddress("ipAddress1634032845")
1189             .setReconciling(true)
1190             .setEtag("etag3123477")
1191             .putAllAnnotations(new HashMap<String, String>())
1192             .build();
1193     Operation resultOperation =
1194         Operation.newBuilder()
1195             .setName("updateInstanceTest")
1196             .setDone(true)
1197             .setResponse(Any.pack(expectedResponse))
1198             .build();
1199     mockService.addResponse(resultOperation);
1200 
1201     Instance instance =
1202         Instance.newBuilder()
1203             .setName(
1204                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1205             .setDisplayName("displayName1714148973")
1206             .setUid("uid115792")
1207             .setCreateTime(Timestamp.newBuilder().build())
1208             .setUpdateTime(Timestamp.newBuilder().build())
1209             .setDeleteTime(Timestamp.newBuilder().build())
1210             .putAllLabels(new HashMap<String, String>())
1211             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1212             .setGceZone("gceZone-146048427")
1213             .putAllDatabaseFlags(new HashMap<String, String>())
1214             .setWritableNode(Instance.Node.newBuilder().build())
1215             .addAllNodes(new ArrayList<Instance.Node>())
1216             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1217             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1218             .setIpAddress("ipAddress1634032845")
1219             .setReconciling(true)
1220             .setEtag("etag3123477")
1221             .putAllAnnotations(new HashMap<String, String>())
1222             .build();
1223     FieldMask updateMask = FieldMask.newBuilder().build();
1224 
1225     Instance actualResponse = client.updateInstanceAsync(instance, updateMask).get();
1226     Assert.assertEquals(expectedResponse, actualResponse);
1227 
1228     List<String> actualRequests = mockService.getRequestPaths();
1229     Assert.assertEquals(1, actualRequests.size());
1230 
1231     String apiClientHeaderKey =
1232         mockService
1233             .getRequestHeaders()
1234             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1235             .iterator()
1236             .next();
1237     Assert.assertTrue(
1238         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1239             .matcher(apiClientHeaderKey)
1240             .matches());
1241   }
1242 
1243   @Test
updateInstanceExceptionTest()1244   public void updateInstanceExceptionTest() throws Exception {
1245     ApiException exception =
1246         ApiExceptionFactory.createException(
1247             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1248     mockService.addException(exception);
1249 
1250     try {
1251       Instance instance =
1252           Instance.newBuilder()
1253               .setName(
1254                   InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1255               .setDisplayName("displayName1714148973")
1256               .setUid("uid115792")
1257               .setCreateTime(Timestamp.newBuilder().build())
1258               .setUpdateTime(Timestamp.newBuilder().build())
1259               .setDeleteTime(Timestamp.newBuilder().build())
1260               .putAllLabels(new HashMap<String, String>())
1261               .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1262               .setGceZone("gceZone-146048427")
1263               .putAllDatabaseFlags(new HashMap<String, String>())
1264               .setWritableNode(Instance.Node.newBuilder().build())
1265               .addAllNodes(new ArrayList<Instance.Node>())
1266               .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1267               .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1268               .setIpAddress("ipAddress1634032845")
1269               .setReconciling(true)
1270               .setEtag("etag3123477")
1271               .putAllAnnotations(new HashMap<String, String>())
1272               .build();
1273       FieldMask updateMask = FieldMask.newBuilder().build();
1274       client.updateInstanceAsync(instance, updateMask).get();
1275       Assert.fail("No exception raised");
1276     } catch (ExecutionException e) {
1277     }
1278   }
1279 
1280   @Test
deleteInstanceTest()1281   public void deleteInstanceTest() throws Exception {
1282     Empty expectedResponse = Empty.newBuilder().build();
1283     Operation resultOperation =
1284         Operation.newBuilder()
1285             .setName("deleteInstanceTest")
1286             .setDone(true)
1287             .setResponse(Any.pack(expectedResponse))
1288             .build();
1289     mockService.addResponse(resultOperation);
1290 
1291     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1292 
1293     client.deleteInstanceAsync(name).get();
1294 
1295     List<String> actualRequests = mockService.getRequestPaths();
1296     Assert.assertEquals(1, actualRequests.size());
1297 
1298     String apiClientHeaderKey =
1299         mockService
1300             .getRequestHeaders()
1301             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1302             .iterator()
1303             .next();
1304     Assert.assertTrue(
1305         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1306             .matcher(apiClientHeaderKey)
1307             .matches());
1308   }
1309 
1310   @Test
deleteInstanceExceptionTest()1311   public void deleteInstanceExceptionTest() throws Exception {
1312     ApiException exception =
1313         ApiExceptionFactory.createException(
1314             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1315     mockService.addException(exception);
1316 
1317     try {
1318       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1319       client.deleteInstanceAsync(name).get();
1320       Assert.fail("No exception raised");
1321     } catch (ExecutionException e) {
1322     }
1323   }
1324 
1325   @Test
deleteInstanceTest2()1326   public void deleteInstanceTest2() throws Exception {
1327     Empty expectedResponse = Empty.newBuilder().build();
1328     Operation resultOperation =
1329         Operation.newBuilder()
1330             .setName("deleteInstanceTest")
1331             .setDone(true)
1332             .setResponse(Any.pack(expectedResponse))
1333             .build();
1334     mockService.addResponse(resultOperation);
1335 
1336     String name =
1337         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1338 
1339     client.deleteInstanceAsync(name).get();
1340 
1341     List<String> actualRequests = mockService.getRequestPaths();
1342     Assert.assertEquals(1, actualRequests.size());
1343 
1344     String apiClientHeaderKey =
1345         mockService
1346             .getRequestHeaders()
1347             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1348             .iterator()
1349             .next();
1350     Assert.assertTrue(
1351         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1352             .matcher(apiClientHeaderKey)
1353             .matches());
1354   }
1355 
1356   @Test
deleteInstanceExceptionTest2()1357   public void deleteInstanceExceptionTest2() throws Exception {
1358     ApiException exception =
1359         ApiExceptionFactory.createException(
1360             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1361     mockService.addException(exception);
1362 
1363     try {
1364       String name =
1365           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1366       client.deleteInstanceAsync(name).get();
1367       Assert.fail("No exception raised");
1368     } catch (ExecutionException e) {
1369     }
1370   }
1371 
1372   @Test
failoverInstanceTest()1373   public void failoverInstanceTest() throws Exception {
1374     Instance expectedResponse =
1375         Instance.newBuilder()
1376             .setName(
1377                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1378             .setDisplayName("displayName1714148973")
1379             .setUid("uid115792")
1380             .setCreateTime(Timestamp.newBuilder().build())
1381             .setUpdateTime(Timestamp.newBuilder().build())
1382             .setDeleteTime(Timestamp.newBuilder().build())
1383             .putAllLabels(new HashMap<String, String>())
1384             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1385             .setGceZone("gceZone-146048427")
1386             .putAllDatabaseFlags(new HashMap<String, String>())
1387             .setWritableNode(Instance.Node.newBuilder().build())
1388             .addAllNodes(new ArrayList<Instance.Node>())
1389             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1390             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1391             .setIpAddress("ipAddress1634032845")
1392             .setReconciling(true)
1393             .setEtag("etag3123477")
1394             .putAllAnnotations(new HashMap<String, String>())
1395             .build();
1396     Operation resultOperation =
1397         Operation.newBuilder()
1398             .setName("failoverInstanceTest")
1399             .setDone(true)
1400             .setResponse(Any.pack(expectedResponse))
1401             .build();
1402     mockService.addResponse(resultOperation);
1403 
1404     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1405 
1406     Instance actualResponse = client.failoverInstanceAsync(name).get();
1407     Assert.assertEquals(expectedResponse, actualResponse);
1408 
1409     List<String> actualRequests = mockService.getRequestPaths();
1410     Assert.assertEquals(1, actualRequests.size());
1411 
1412     String apiClientHeaderKey =
1413         mockService
1414             .getRequestHeaders()
1415             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1416             .iterator()
1417             .next();
1418     Assert.assertTrue(
1419         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1420             .matcher(apiClientHeaderKey)
1421             .matches());
1422   }
1423 
1424   @Test
failoverInstanceExceptionTest()1425   public void failoverInstanceExceptionTest() throws Exception {
1426     ApiException exception =
1427         ApiExceptionFactory.createException(
1428             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1429     mockService.addException(exception);
1430 
1431     try {
1432       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1433       client.failoverInstanceAsync(name).get();
1434       Assert.fail("No exception raised");
1435     } catch (ExecutionException e) {
1436     }
1437   }
1438 
1439   @Test
failoverInstanceTest2()1440   public void failoverInstanceTest2() throws Exception {
1441     Instance expectedResponse =
1442         Instance.newBuilder()
1443             .setName(
1444                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1445             .setDisplayName("displayName1714148973")
1446             .setUid("uid115792")
1447             .setCreateTime(Timestamp.newBuilder().build())
1448             .setUpdateTime(Timestamp.newBuilder().build())
1449             .setDeleteTime(Timestamp.newBuilder().build())
1450             .putAllLabels(new HashMap<String, String>())
1451             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1452             .setGceZone("gceZone-146048427")
1453             .putAllDatabaseFlags(new HashMap<String, String>())
1454             .setWritableNode(Instance.Node.newBuilder().build())
1455             .addAllNodes(new ArrayList<Instance.Node>())
1456             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1457             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1458             .setIpAddress("ipAddress1634032845")
1459             .setReconciling(true)
1460             .setEtag("etag3123477")
1461             .putAllAnnotations(new HashMap<String, String>())
1462             .build();
1463     Operation resultOperation =
1464         Operation.newBuilder()
1465             .setName("failoverInstanceTest")
1466             .setDone(true)
1467             .setResponse(Any.pack(expectedResponse))
1468             .build();
1469     mockService.addResponse(resultOperation);
1470 
1471     String name =
1472         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1473 
1474     Instance actualResponse = client.failoverInstanceAsync(name).get();
1475     Assert.assertEquals(expectedResponse, actualResponse);
1476 
1477     List<String> actualRequests = mockService.getRequestPaths();
1478     Assert.assertEquals(1, actualRequests.size());
1479 
1480     String apiClientHeaderKey =
1481         mockService
1482             .getRequestHeaders()
1483             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1484             .iterator()
1485             .next();
1486     Assert.assertTrue(
1487         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1488             .matcher(apiClientHeaderKey)
1489             .matches());
1490   }
1491 
1492   @Test
failoverInstanceExceptionTest2()1493   public void failoverInstanceExceptionTest2() throws Exception {
1494     ApiException exception =
1495         ApiExceptionFactory.createException(
1496             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1497     mockService.addException(exception);
1498 
1499     try {
1500       String name =
1501           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1502       client.failoverInstanceAsync(name).get();
1503       Assert.fail("No exception raised");
1504     } catch (ExecutionException e) {
1505     }
1506   }
1507 
1508   @Test
restartInstanceTest()1509   public void restartInstanceTest() throws Exception {
1510     Instance expectedResponse =
1511         Instance.newBuilder()
1512             .setName(
1513                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1514             .setDisplayName("displayName1714148973")
1515             .setUid("uid115792")
1516             .setCreateTime(Timestamp.newBuilder().build())
1517             .setUpdateTime(Timestamp.newBuilder().build())
1518             .setDeleteTime(Timestamp.newBuilder().build())
1519             .putAllLabels(new HashMap<String, String>())
1520             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1521             .setGceZone("gceZone-146048427")
1522             .putAllDatabaseFlags(new HashMap<String, String>())
1523             .setWritableNode(Instance.Node.newBuilder().build())
1524             .addAllNodes(new ArrayList<Instance.Node>())
1525             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1526             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1527             .setIpAddress("ipAddress1634032845")
1528             .setReconciling(true)
1529             .setEtag("etag3123477")
1530             .putAllAnnotations(new HashMap<String, String>())
1531             .build();
1532     Operation resultOperation =
1533         Operation.newBuilder()
1534             .setName("restartInstanceTest")
1535             .setDone(true)
1536             .setResponse(Any.pack(expectedResponse))
1537             .build();
1538     mockService.addResponse(resultOperation);
1539 
1540     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1541 
1542     Instance actualResponse = client.restartInstanceAsync(name).get();
1543     Assert.assertEquals(expectedResponse, actualResponse);
1544 
1545     List<String> actualRequests = mockService.getRequestPaths();
1546     Assert.assertEquals(1, actualRequests.size());
1547 
1548     String apiClientHeaderKey =
1549         mockService
1550             .getRequestHeaders()
1551             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1552             .iterator()
1553             .next();
1554     Assert.assertTrue(
1555         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1556             .matcher(apiClientHeaderKey)
1557             .matches());
1558   }
1559 
1560   @Test
restartInstanceExceptionTest()1561   public void restartInstanceExceptionTest() throws Exception {
1562     ApiException exception =
1563         ApiExceptionFactory.createException(
1564             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1565     mockService.addException(exception);
1566 
1567     try {
1568       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]");
1569       client.restartInstanceAsync(name).get();
1570       Assert.fail("No exception raised");
1571     } catch (ExecutionException e) {
1572     }
1573   }
1574 
1575   @Test
restartInstanceTest2()1576   public void restartInstanceTest2() throws Exception {
1577     Instance expectedResponse =
1578         Instance.newBuilder()
1579             .setName(
1580                 InstanceName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[INSTANCE]").toString())
1581             .setDisplayName("displayName1714148973")
1582             .setUid("uid115792")
1583             .setCreateTime(Timestamp.newBuilder().build())
1584             .setUpdateTime(Timestamp.newBuilder().build())
1585             .setDeleteTime(Timestamp.newBuilder().build())
1586             .putAllLabels(new HashMap<String, String>())
1587             .setMachineConfig(Instance.MachineConfig.newBuilder().build())
1588             .setGceZone("gceZone-146048427")
1589             .putAllDatabaseFlags(new HashMap<String, String>())
1590             .setWritableNode(Instance.Node.newBuilder().build())
1591             .addAllNodes(new ArrayList<Instance.Node>())
1592             .setQueryInsightsConfig(Instance.QueryInsightsInstanceConfig.newBuilder().build())
1593             .setReadPoolConfig(Instance.ReadPoolConfig.newBuilder().build())
1594             .setIpAddress("ipAddress1634032845")
1595             .setReconciling(true)
1596             .setEtag("etag3123477")
1597             .putAllAnnotations(new HashMap<String, String>())
1598             .build();
1599     Operation resultOperation =
1600         Operation.newBuilder()
1601             .setName("restartInstanceTest")
1602             .setDone(true)
1603             .setResponse(Any.pack(expectedResponse))
1604             .build();
1605     mockService.addResponse(resultOperation);
1606 
1607     String name =
1608         "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1609 
1610     Instance actualResponse = client.restartInstanceAsync(name).get();
1611     Assert.assertEquals(expectedResponse, actualResponse);
1612 
1613     List<String> actualRequests = mockService.getRequestPaths();
1614     Assert.assertEquals(1, actualRequests.size());
1615 
1616     String apiClientHeaderKey =
1617         mockService
1618             .getRequestHeaders()
1619             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1620             .iterator()
1621             .next();
1622     Assert.assertTrue(
1623         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1624             .matcher(apiClientHeaderKey)
1625             .matches());
1626   }
1627 
1628   @Test
restartInstanceExceptionTest2()1629   public void restartInstanceExceptionTest2() throws Exception {
1630     ApiException exception =
1631         ApiExceptionFactory.createException(
1632             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1633     mockService.addException(exception);
1634 
1635     try {
1636       String name =
1637           "projects/project-867/locations/location-867/clusters/cluster-867/instances/instance-867";
1638       client.restartInstanceAsync(name).get();
1639       Assert.fail("No exception raised");
1640     } catch (ExecutionException e) {
1641     }
1642   }
1643 
1644   @Test
listBackupsTest()1645   public void listBackupsTest() throws Exception {
1646     Backup responsesElement = Backup.newBuilder().build();
1647     ListBackupsResponse expectedResponse =
1648         ListBackupsResponse.newBuilder()
1649             .setNextPageToken("")
1650             .addAllBackups(Arrays.asList(responsesElement))
1651             .build();
1652     mockService.addResponse(expectedResponse);
1653 
1654     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1655 
1656     ListBackupsPagedResponse pagedListResponse = client.listBackups(parent);
1657 
1658     List<Backup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1659 
1660     Assert.assertEquals(1, resources.size());
1661     Assert.assertEquals(expectedResponse.getBackupsList().get(0), resources.get(0));
1662 
1663     List<String> actualRequests = mockService.getRequestPaths();
1664     Assert.assertEquals(1, actualRequests.size());
1665 
1666     String apiClientHeaderKey =
1667         mockService
1668             .getRequestHeaders()
1669             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1670             .iterator()
1671             .next();
1672     Assert.assertTrue(
1673         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1674             .matcher(apiClientHeaderKey)
1675             .matches());
1676   }
1677 
1678   @Test
listBackupsExceptionTest()1679   public void listBackupsExceptionTest() throws Exception {
1680     ApiException exception =
1681         ApiExceptionFactory.createException(
1682             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1683     mockService.addException(exception);
1684 
1685     try {
1686       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1687       client.listBackups(parent);
1688       Assert.fail("No exception raised");
1689     } catch (InvalidArgumentException e) {
1690       // Expected exception.
1691     }
1692   }
1693 
1694   @Test
listBackupsTest2()1695   public void listBackupsTest2() throws Exception {
1696     Backup responsesElement = Backup.newBuilder().build();
1697     ListBackupsResponse expectedResponse =
1698         ListBackupsResponse.newBuilder()
1699             .setNextPageToken("")
1700             .addAllBackups(Arrays.asList(responsesElement))
1701             .build();
1702     mockService.addResponse(expectedResponse);
1703 
1704     String parent = "projects/project-5833/locations/location-5833";
1705 
1706     ListBackupsPagedResponse pagedListResponse = client.listBackups(parent);
1707 
1708     List<Backup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1709 
1710     Assert.assertEquals(1, resources.size());
1711     Assert.assertEquals(expectedResponse.getBackupsList().get(0), resources.get(0));
1712 
1713     List<String> actualRequests = mockService.getRequestPaths();
1714     Assert.assertEquals(1, actualRequests.size());
1715 
1716     String apiClientHeaderKey =
1717         mockService
1718             .getRequestHeaders()
1719             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1720             .iterator()
1721             .next();
1722     Assert.assertTrue(
1723         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1724             .matcher(apiClientHeaderKey)
1725             .matches());
1726   }
1727 
1728   @Test
listBackupsExceptionTest2()1729   public void listBackupsExceptionTest2() throws Exception {
1730     ApiException exception =
1731         ApiExceptionFactory.createException(
1732             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1733     mockService.addException(exception);
1734 
1735     try {
1736       String parent = "projects/project-5833/locations/location-5833";
1737       client.listBackups(parent);
1738       Assert.fail("No exception raised");
1739     } catch (InvalidArgumentException e) {
1740       // Expected exception.
1741     }
1742   }
1743 
1744   @Test
getBackupTest()1745   public void getBackupTest() throws Exception {
1746     Backup expectedResponse =
1747         Backup.newBuilder()
1748             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
1749             .setDisplayName("displayName1714148973")
1750             .setUid("uid115792")
1751             .setCreateTime(Timestamp.newBuilder().build())
1752             .setUpdateTime(Timestamp.newBuilder().build())
1753             .setDeleteTime(Timestamp.newBuilder().build())
1754             .putAllLabels(new HashMap<String, String>())
1755             .setDescription("description-1724546052")
1756             .setClusterUid("clusterUid240271350")
1757             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1758             .setReconciling(true)
1759             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
1760             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
1761             .setEtag("etag3123477")
1762             .putAllAnnotations(new HashMap<String, String>())
1763             .setSizeBytes(-1796325715)
1764             .setExpiryTime(Timestamp.newBuilder().build())
1765             .build();
1766     mockService.addResponse(expectedResponse);
1767 
1768     BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
1769 
1770     Backup actualResponse = client.getBackup(name);
1771     Assert.assertEquals(expectedResponse, actualResponse);
1772 
1773     List<String> actualRequests = mockService.getRequestPaths();
1774     Assert.assertEquals(1, actualRequests.size());
1775 
1776     String apiClientHeaderKey =
1777         mockService
1778             .getRequestHeaders()
1779             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1780             .iterator()
1781             .next();
1782     Assert.assertTrue(
1783         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1784             .matcher(apiClientHeaderKey)
1785             .matches());
1786   }
1787 
1788   @Test
getBackupExceptionTest()1789   public void getBackupExceptionTest() throws Exception {
1790     ApiException exception =
1791         ApiExceptionFactory.createException(
1792             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1793     mockService.addException(exception);
1794 
1795     try {
1796       BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
1797       client.getBackup(name);
1798       Assert.fail("No exception raised");
1799     } catch (InvalidArgumentException e) {
1800       // Expected exception.
1801     }
1802   }
1803 
1804   @Test
getBackupTest2()1805   public void getBackupTest2() throws Exception {
1806     Backup expectedResponse =
1807         Backup.newBuilder()
1808             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
1809             .setDisplayName("displayName1714148973")
1810             .setUid("uid115792")
1811             .setCreateTime(Timestamp.newBuilder().build())
1812             .setUpdateTime(Timestamp.newBuilder().build())
1813             .setDeleteTime(Timestamp.newBuilder().build())
1814             .putAllLabels(new HashMap<String, String>())
1815             .setDescription("description-1724546052")
1816             .setClusterUid("clusterUid240271350")
1817             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1818             .setReconciling(true)
1819             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
1820             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
1821             .setEtag("etag3123477")
1822             .putAllAnnotations(new HashMap<String, String>())
1823             .setSizeBytes(-1796325715)
1824             .setExpiryTime(Timestamp.newBuilder().build())
1825             .build();
1826     mockService.addResponse(expectedResponse);
1827 
1828     String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
1829 
1830     Backup actualResponse = client.getBackup(name);
1831     Assert.assertEquals(expectedResponse, actualResponse);
1832 
1833     List<String> actualRequests = mockService.getRequestPaths();
1834     Assert.assertEquals(1, actualRequests.size());
1835 
1836     String apiClientHeaderKey =
1837         mockService
1838             .getRequestHeaders()
1839             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1840             .iterator()
1841             .next();
1842     Assert.assertTrue(
1843         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1844             .matcher(apiClientHeaderKey)
1845             .matches());
1846   }
1847 
1848   @Test
getBackupExceptionTest2()1849   public void getBackupExceptionTest2() throws Exception {
1850     ApiException exception =
1851         ApiExceptionFactory.createException(
1852             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1853     mockService.addException(exception);
1854 
1855     try {
1856       String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
1857       client.getBackup(name);
1858       Assert.fail("No exception raised");
1859     } catch (InvalidArgumentException e) {
1860       // Expected exception.
1861     }
1862   }
1863 
1864   @Test
createBackupTest()1865   public void createBackupTest() throws Exception {
1866     Backup expectedResponse =
1867         Backup.newBuilder()
1868             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
1869             .setDisplayName("displayName1714148973")
1870             .setUid("uid115792")
1871             .setCreateTime(Timestamp.newBuilder().build())
1872             .setUpdateTime(Timestamp.newBuilder().build())
1873             .setDeleteTime(Timestamp.newBuilder().build())
1874             .putAllLabels(new HashMap<String, String>())
1875             .setDescription("description-1724546052")
1876             .setClusterUid("clusterUid240271350")
1877             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1878             .setReconciling(true)
1879             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
1880             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
1881             .setEtag("etag3123477")
1882             .putAllAnnotations(new HashMap<String, String>())
1883             .setSizeBytes(-1796325715)
1884             .setExpiryTime(Timestamp.newBuilder().build())
1885             .build();
1886     Operation resultOperation =
1887         Operation.newBuilder()
1888             .setName("createBackupTest")
1889             .setDone(true)
1890             .setResponse(Any.pack(expectedResponse))
1891             .build();
1892     mockService.addResponse(resultOperation);
1893 
1894     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1895     Backup backup = Backup.newBuilder().build();
1896     String backupId = "backupId2121930365";
1897 
1898     Backup actualResponse = client.createBackupAsync(parent, backup, backupId).get();
1899     Assert.assertEquals(expectedResponse, actualResponse);
1900 
1901     List<String> actualRequests = mockService.getRequestPaths();
1902     Assert.assertEquals(1, actualRequests.size());
1903 
1904     String apiClientHeaderKey =
1905         mockService
1906             .getRequestHeaders()
1907             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1908             .iterator()
1909             .next();
1910     Assert.assertTrue(
1911         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1912             .matcher(apiClientHeaderKey)
1913             .matches());
1914   }
1915 
1916   @Test
createBackupExceptionTest()1917   public void createBackupExceptionTest() throws Exception {
1918     ApiException exception =
1919         ApiExceptionFactory.createException(
1920             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1921     mockService.addException(exception);
1922 
1923     try {
1924       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1925       Backup backup = Backup.newBuilder().build();
1926       String backupId = "backupId2121930365";
1927       client.createBackupAsync(parent, backup, backupId).get();
1928       Assert.fail("No exception raised");
1929     } catch (ExecutionException e) {
1930     }
1931   }
1932 
1933   @Test
createBackupTest2()1934   public void createBackupTest2() throws Exception {
1935     Backup expectedResponse =
1936         Backup.newBuilder()
1937             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
1938             .setDisplayName("displayName1714148973")
1939             .setUid("uid115792")
1940             .setCreateTime(Timestamp.newBuilder().build())
1941             .setUpdateTime(Timestamp.newBuilder().build())
1942             .setDeleteTime(Timestamp.newBuilder().build())
1943             .putAllLabels(new HashMap<String, String>())
1944             .setDescription("description-1724546052")
1945             .setClusterUid("clusterUid240271350")
1946             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
1947             .setReconciling(true)
1948             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
1949             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
1950             .setEtag("etag3123477")
1951             .putAllAnnotations(new HashMap<String, String>())
1952             .setSizeBytes(-1796325715)
1953             .setExpiryTime(Timestamp.newBuilder().build())
1954             .build();
1955     Operation resultOperation =
1956         Operation.newBuilder()
1957             .setName("createBackupTest")
1958             .setDone(true)
1959             .setResponse(Any.pack(expectedResponse))
1960             .build();
1961     mockService.addResponse(resultOperation);
1962 
1963     String parent = "projects/project-5833/locations/location-5833";
1964     Backup backup = Backup.newBuilder().build();
1965     String backupId = "backupId2121930365";
1966 
1967     Backup actualResponse = client.createBackupAsync(parent, backup, backupId).get();
1968     Assert.assertEquals(expectedResponse, actualResponse);
1969 
1970     List<String> actualRequests = mockService.getRequestPaths();
1971     Assert.assertEquals(1, actualRequests.size());
1972 
1973     String apiClientHeaderKey =
1974         mockService
1975             .getRequestHeaders()
1976             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1977             .iterator()
1978             .next();
1979     Assert.assertTrue(
1980         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1981             .matcher(apiClientHeaderKey)
1982             .matches());
1983   }
1984 
1985   @Test
createBackupExceptionTest2()1986   public void createBackupExceptionTest2() throws Exception {
1987     ApiException exception =
1988         ApiExceptionFactory.createException(
1989             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1990     mockService.addException(exception);
1991 
1992     try {
1993       String parent = "projects/project-5833/locations/location-5833";
1994       Backup backup = Backup.newBuilder().build();
1995       String backupId = "backupId2121930365";
1996       client.createBackupAsync(parent, backup, backupId).get();
1997       Assert.fail("No exception raised");
1998     } catch (ExecutionException e) {
1999     }
2000   }
2001 
2002   @Test
updateBackupTest()2003   public void updateBackupTest() throws Exception {
2004     Backup expectedResponse =
2005         Backup.newBuilder()
2006             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2007             .setDisplayName("displayName1714148973")
2008             .setUid("uid115792")
2009             .setCreateTime(Timestamp.newBuilder().build())
2010             .setUpdateTime(Timestamp.newBuilder().build())
2011             .setDeleteTime(Timestamp.newBuilder().build())
2012             .putAllLabels(new HashMap<String, String>())
2013             .setDescription("description-1724546052")
2014             .setClusterUid("clusterUid240271350")
2015             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2016             .setReconciling(true)
2017             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2018             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2019             .setEtag("etag3123477")
2020             .putAllAnnotations(new HashMap<String, String>())
2021             .setSizeBytes(-1796325715)
2022             .setExpiryTime(Timestamp.newBuilder().build())
2023             .build();
2024     Operation resultOperation =
2025         Operation.newBuilder()
2026             .setName("updateBackupTest")
2027             .setDone(true)
2028             .setResponse(Any.pack(expectedResponse))
2029             .build();
2030     mockService.addResponse(resultOperation);
2031 
2032     Backup backup =
2033         Backup.newBuilder()
2034             .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2035             .setDisplayName("displayName1714148973")
2036             .setUid("uid115792")
2037             .setCreateTime(Timestamp.newBuilder().build())
2038             .setUpdateTime(Timestamp.newBuilder().build())
2039             .setDeleteTime(Timestamp.newBuilder().build())
2040             .putAllLabels(new HashMap<String, String>())
2041             .setDescription("description-1724546052")
2042             .setClusterUid("clusterUid240271350")
2043             .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2044             .setReconciling(true)
2045             .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2046             .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2047             .setEtag("etag3123477")
2048             .putAllAnnotations(new HashMap<String, String>())
2049             .setSizeBytes(-1796325715)
2050             .setExpiryTime(Timestamp.newBuilder().build())
2051             .build();
2052     FieldMask updateMask = FieldMask.newBuilder().build();
2053 
2054     Backup actualResponse = client.updateBackupAsync(backup, updateMask).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
updateBackupExceptionTest()2073   public void updateBackupExceptionTest() 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       Backup backup =
2081           Backup.newBuilder()
2082               .setName(BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]").toString())
2083               .setDisplayName("displayName1714148973")
2084               .setUid("uid115792")
2085               .setCreateTime(Timestamp.newBuilder().build())
2086               .setUpdateTime(Timestamp.newBuilder().build())
2087               .setDeleteTime(Timestamp.newBuilder().build())
2088               .putAllLabels(new HashMap<String, String>())
2089               .setDescription("description-1724546052")
2090               .setClusterUid("clusterUid240271350")
2091               .setClusterName(ClusterName.of("[PROJECT]", "[LOCATION]", "[CLUSTER]").toString())
2092               .setReconciling(true)
2093               .setEncryptionConfig(EncryptionConfig.newBuilder().build())
2094               .setEncryptionInfo(EncryptionInfo.newBuilder().build())
2095               .setEtag("etag3123477")
2096               .putAllAnnotations(new HashMap<String, String>())
2097               .setSizeBytes(-1796325715)
2098               .setExpiryTime(Timestamp.newBuilder().build())
2099               .build();
2100       FieldMask updateMask = FieldMask.newBuilder().build();
2101       client.updateBackupAsync(backup, updateMask).get();
2102       Assert.fail("No exception raised");
2103     } catch (ExecutionException e) {
2104     }
2105   }
2106 
2107   @Test
deleteBackupTest()2108   public void deleteBackupTest() throws Exception {
2109     Empty expectedResponse = Empty.newBuilder().build();
2110     Operation resultOperation =
2111         Operation.newBuilder()
2112             .setName("deleteBackupTest")
2113             .setDone(true)
2114             .setResponse(Any.pack(expectedResponse))
2115             .build();
2116     mockService.addResponse(resultOperation);
2117 
2118     BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2119 
2120     client.deleteBackupAsync(name).get();
2121 
2122     List<String> actualRequests = mockService.getRequestPaths();
2123     Assert.assertEquals(1, actualRequests.size());
2124 
2125     String apiClientHeaderKey =
2126         mockService
2127             .getRequestHeaders()
2128             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2129             .iterator()
2130             .next();
2131     Assert.assertTrue(
2132         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2133             .matcher(apiClientHeaderKey)
2134             .matches());
2135   }
2136 
2137   @Test
deleteBackupExceptionTest()2138   public void deleteBackupExceptionTest() throws Exception {
2139     ApiException exception =
2140         ApiExceptionFactory.createException(
2141             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2142     mockService.addException(exception);
2143 
2144     try {
2145       BackupName name = BackupName.of("[PROJECT]", "[LOCATION]", "[BACKUP]");
2146       client.deleteBackupAsync(name).get();
2147       Assert.fail("No exception raised");
2148     } catch (ExecutionException e) {
2149     }
2150   }
2151 
2152   @Test
deleteBackupTest2()2153   public void deleteBackupTest2() throws Exception {
2154     Empty expectedResponse = Empty.newBuilder().build();
2155     Operation resultOperation =
2156         Operation.newBuilder()
2157             .setName("deleteBackupTest")
2158             .setDone(true)
2159             .setResponse(Any.pack(expectedResponse))
2160             .build();
2161     mockService.addResponse(resultOperation);
2162 
2163     String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2164 
2165     client.deleteBackupAsync(name).get();
2166 
2167     List<String> actualRequests = mockService.getRequestPaths();
2168     Assert.assertEquals(1, actualRequests.size());
2169 
2170     String apiClientHeaderKey =
2171         mockService
2172             .getRequestHeaders()
2173             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2174             .iterator()
2175             .next();
2176     Assert.assertTrue(
2177         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2178             .matcher(apiClientHeaderKey)
2179             .matches());
2180   }
2181 
2182   @Test
deleteBackupExceptionTest2()2183   public void deleteBackupExceptionTest2() throws Exception {
2184     ApiException exception =
2185         ApiExceptionFactory.createException(
2186             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2187     mockService.addException(exception);
2188 
2189     try {
2190       String name = "projects/project-1607/locations/location-1607/backups/backup-1607";
2191       client.deleteBackupAsync(name).get();
2192       Assert.fail("No exception raised");
2193     } catch (ExecutionException e) {
2194     }
2195   }
2196 
2197   @Test
listSupportedDatabaseFlagsTest()2198   public void listSupportedDatabaseFlagsTest() throws Exception {
2199     SupportedDatabaseFlag responsesElement = SupportedDatabaseFlag.newBuilder().build();
2200     ListSupportedDatabaseFlagsResponse expectedResponse =
2201         ListSupportedDatabaseFlagsResponse.newBuilder()
2202             .setNextPageToken("")
2203             .addAllSupportedDatabaseFlags(Arrays.asList(responsesElement))
2204             .build();
2205     mockService.addResponse(expectedResponse);
2206 
2207     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2208 
2209     ListSupportedDatabaseFlagsPagedResponse pagedListResponse =
2210         client.listSupportedDatabaseFlags(parent);
2211 
2212     List<SupportedDatabaseFlag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2213 
2214     Assert.assertEquals(1, resources.size());
2215     Assert.assertEquals(expectedResponse.getSupportedDatabaseFlagsList().get(0), resources.get(0));
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
listSupportedDatabaseFlagsExceptionTest()2233   public void listSupportedDatabaseFlagsExceptionTest() 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       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2241       client.listSupportedDatabaseFlags(parent);
2242       Assert.fail("No exception raised");
2243     } catch (InvalidArgumentException e) {
2244       // Expected exception.
2245     }
2246   }
2247 
2248   @Test
listSupportedDatabaseFlagsTest2()2249   public void listSupportedDatabaseFlagsTest2() throws Exception {
2250     SupportedDatabaseFlag responsesElement = SupportedDatabaseFlag.newBuilder().build();
2251     ListSupportedDatabaseFlagsResponse expectedResponse =
2252         ListSupportedDatabaseFlagsResponse.newBuilder()
2253             .setNextPageToken("")
2254             .addAllSupportedDatabaseFlags(Arrays.asList(responsesElement))
2255             .build();
2256     mockService.addResponse(expectedResponse);
2257 
2258     String parent = "projects/project-5833/locations/location-5833";
2259 
2260     ListSupportedDatabaseFlagsPagedResponse pagedListResponse =
2261         client.listSupportedDatabaseFlags(parent);
2262 
2263     List<SupportedDatabaseFlag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2264 
2265     Assert.assertEquals(1, resources.size());
2266     Assert.assertEquals(expectedResponse.getSupportedDatabaseFlagsList().get(0), resources.get(0));
2267 
2268     List<String> actualRequests = mockService.getRequestPaths();
2269     Assert.assertEquals(1, actualRequests.size());
2270 
2271     String apiClientHeaderKey =
2272         mockService
2273             .getRequestHeaders()
2274             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2275             .iterator()
2276             .next();
2277     Assert.assertTrue(
2278         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2279             .matcher(apiClientHeaderKey)
2280             .matches());
2281   }
2282 
2283   @Test
listSupportedDatabaseFlagsExceptionTest2()2284   public void listSupportedDatabaseFlagsExceptionTest2() throws Exception {
2285     ApiException exception =
2286         ApiExceptionFactory.createException(
2287             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2288     mockService.addException(exception);
2289 
2290     try {
2291       String parent = "projects/project-5833/locations/location-5833";
2292       client.listSupportedDatabaseFlags(parent);
2293       Assert.fail("No exception raised");
2294     } catch (InvalidArgumentException e) {
2295       // Expected exception.
2296     }
2297   }
2298 
2299   @Test
listLocationsTest()2300   public void listLocationsTest() throws Exception {
2301     Location responsesElement = Location.newBuilder().build();
2302     ListLocationsResponse expectedResponse =
2303         ListLocationsResponse.newBuilder()
2304             .setNextPageToken("")
2305             .addAllLocations(Arrays.asList(responsesElement))
2306             .build();
2307     mockService.addResponse(expectedResponse);
2308 
2309     ListLocationsRequest request =
2310         ListLocationsRequest.newBuilder()
2311             .setName("projects/project-3664")
2312             .setFilter("filter-1274492040")
2313             .setPageSize(883849137)
2314             .setPageToken("pageToken873572522")
2315             .build();
2316 
2317     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2318 
2319     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2320 
2321     Assert.assertEquals(1, resources.size());
2322     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2323 
2324     List<String> actualRequests = mockService.getRequestPaths();
2325     Assert.assertEquals(1, actualRequests.size());
2326 
2327     String apiClientHeaderKey =
2328         mockService
2329             .getRequestHeaders()
2330             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2331             .iterator()
2332             .next();
2333     Assert.assertTrue(
2334         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2335             .matcher(apiClientHeaderKey)
2336             .matches());
2337   }
2338 
2339   @Test
listLocationsExceptionTest()2340   public void listLocationsExceptionTest() throws Exception {
2341     ApiException exception =
2342         ApiExceptionFactory.createException(
2343             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2344     mockService.addException(exception);
2345 
2346     try {
2347       ListLocationsRequest request =
2348           ListLocationsRequest.newBuilder()
2349               .setName("projects/project-3664")
2350               .setFilter("filter-1274492040")
2351               .setPageSize(883849137)
2352               .setPageToken("pageToken873572522")
2353               .build();
2354       client.listLocations(request);
2355       Assert.fail("No exception raised");
2356     } catch (InvalidArgumentException e) {
2357       // Expected exception.
2358     }
2359   }
2360 
2361   @Test
getLocationTest()2362   public void getLocationTest() throws Exception {
2363     Location expectedResponse =
2364         Location.newBuilder()
2365             .setName("name3373707")
2366             .setLocationId("locationId1541836720")
2367             .setDisplayName("displayName1714148973")
2368             .putAllLabels(new HashMap<String, String>())
2369             .setMetadata(Any.newBuilder().build())
2370             .build();
2371     mockService.addResponse(expectedResponse);
2372 
2373     GetLocationRequest request =
2374         GetLocationRequest.newBuilder()
2375             .setName("projects/project-9062/locations/location-9062")
2376             .build();
2377 
2378     Location actualResponse = client.getLocation(request);
2379     Assert.assertEquals(expectedResponse, actualResponse);
2380 
2381     List<String> actualRequests = mockService.getRequestPaths();
2382     Assert.assertEquals(1, actualRequests.size());
2383 
2384     String apiClientHeaderKey =
2385         mockService
2386             .getRequestHeaders()
2387             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2388             .iterator()
2389             .next();
2390     Assert.assertTrue(
2391         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2392             .matcher(apiClientHeaderKey)
2393             .matches());
2394   }
2395 
2396   @Test
getLocationExceptionTest()2397   public void getLocationExceptionTest() throws Exception {
2398     ApiException exception =
2399         ApiExceptionFactory.createException(
2400             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2401     mockService.addException(exception);
2402 
2403     try {
2404       GetLocationRequest request =
2405           GetLocationRequest.newBuilder()
2406               .setName("projects/project-9062/locations/location-9062")
2407               .build();
2408       client.getLocation(request);
2409       Assert.fail("No exception raised");
2410     } catch (InvalidArgumentException e) {
2411       // Expected exception.
2412     }
2413   }
2414 }
2415