• 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.redis.v1;
18 
19 import static com.google.cloud.redis.v1.CloudRedisClient.ListInstancesPagedResponse;
20 import static com.google.cloud.redis.v1.CloudRedisClient.ListLocationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.cloud.location.GetLocationRequest;
32 import com.google.cloud.location.ListLocationsRequest;
33 import com.google.cloud.location.ListLocationsResponse;
34 import com.google.cloud.location.Location;
35 import com.google.cloud.redis.v1.stub.HttpJsonCloudRedisStub;
36 import com.google.common.collect.Lists;
37 import com.google.longrunning.Operation;
38 import com.google.protobuf.Any;
39 import com.google.protobuf.Empty;
40 import com.google.protobuf.FieldMask;
41 import com.google.protobuf.Timestamp;
42 import java.io.IOException;
43 import java.util.ArrayList;
44 import java.util.Arrays;
45 import java.util.HashMap;
46 import java.util.List;
47 import java.util.concurrent.ExecutionException;
48 import javax.annotation.Generated;
49 import org.junit.After;
50 import org.junit.AfterClass;
51 import org.junit.Assert;
52 import org.junit.Before;
53 import org.junit.BeforeClass;
54 import org.junit.Test;
55 
56 @Generated("by gapic-generator-java")
57 public class CloudRedisClientHttpJsonTest {
58   private static MockHttpService mockService;
59   private static CloudRedisClient client;
60 
61   @BeforeClass
startStaticServer()62   public static void startStaticServer() throws IOException {
63     mockService =
64         new MockHttpService(
65             HttpJsonCloudRedisStub.getMethodDescriptors(), CloudRedisSettings.getDefaultEndpoint());
66     CloudRedisSettings settings =
67         CloudRedisSettings.newHttpJsonBuilder()
68             .setTransportChannelProvider(
69                 CloudRedisSettings.defaultHttpJsonTransportProviderBuilder()
70                     .setHttpTransport(mockService)
71                     .build())
72             .setCredentialsProvider(NoCredentialsProvider.create())
73             .build();
74     client = CloudRedisClient.create(settings);
75   }
76 
77   @AfterClass
stopServer()78   public static void stopServer() {
79     client.close();
80   }
81 
82   @Before
setUp()83   public void setUp() {}
84 
85   @After
tearDown()86   public void tearDown() throws Exception {
87     mockService.reset();
88   }
89 
90   @Test
listInstancesTest()91   public void listInstancesTest() throws Exception {
92     Instance responsesElement = Instance.newBuilder().build();
93     ListInstancesResponse expectedResponse =
94         ListInstancesResponse.newBuilder()
95             .setNextPageToken("")
96             .addAllInstances(Arrays.asList(responsesElement))
97             .build();
98     mockService.addResponse(expectedResponse);
99 
100     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
101 
102     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
103 
104     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
105 
106     Assert.assertEquals(1, resources.size());
107     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
108 
109     List<String> actualRequests = mockService.getRequestPaths();
110     Assert.assertEquals(1, actualRequests.size());
111 
112     String apiClientHeaderKey =
113         mockService
114             .getRequestHeaders()
115             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
116             .iterator()
117             .next();
118     Assert.assertTrue(
119         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
120             .matcher(apiClientHeaderKey)
121             .matches());
122   }
123 
124   @Test
listInstancesExceptionTest()125   public void listInstancesExceptionTest() throws Exception {
126     ApiException exception =
127         ApiExceptionFactory.createException(
128             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
129     mockService.addException(exception);
130 
131     try {
132       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
133       client.listInstances(parent);
134       Assert.fail("No exception raised");
135     } catch (InvalidArgumentException e) {
136       // Expected exception.
137     }
138   }
139 
140   @Test
listInstancesTest2()141   public void listInstancesTest2() throws Exception {
142     Instance responsesElement = Instance.newBuilder().build();
143     ListInstancesResponse expectedResponse =
144         ListInstancesResponse.newBuilder()
145             .setNextPageToken("")
146             .addAllInstances(Arrays.asList(responsesElement))
147             .build();
148     mockService.addResponse(expectedResponse);
149 
150     String parent = "projects/project-5833/locations/location-5833";
151 
152     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
153 
154     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
155 
156     Assert.assertEquals(1, resources.size());
157     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
158 
159     List<String> actualRequests = mockService.getRequestPaths();
160     Assert.assertEquals(1, actualRequests.size());
161 
162     String apiClientHeaderKey =
163         mockService
164             .getRequestHeaders()
165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
166             .iterator()
167             .next();
168     Assert.assertTrue(
169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
170             .matcher(apiClientHeaderKey)
171             .matches());
172   }
173 
174   @Test
listInstancesExceptionTest2()175   public void listInstancesExceptionTest2() throws Exception {
176     ApiException exception =
177         ApiExceptionFactory.createException(
178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
179     mockService.addException(exception);
180 
181     try {
182       String parent = "projects/project-5833/locations/location-5833";
183       client.listInstances(parent);
184       Assert.fail("No exception raised");
185     } catch (InvalidArgumentException e) {
186       // Expected exception.
187     }
188   }
189 
190   @Test
getInstanceTest()191   public void getInstanceTest() throws Exception {
192     Instance expectedResponse =
193         Instance.newBuilder()
194             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
195             .setDisplayName("displayName1714148973")
196             .putAllLabels(new HashMap<String, String>())
197             .setLocationId("locationId1541836720")
198             .setAlternativeLocationId("alternativeLocationId1787141949")
199             .setRedisVersion("redisVersion-1972584739")
200             .setReservedIpRange("reservedIpRange575015950")
201             .setSecondaryIpRange("secondaryIpRange-1937131454")
202             .setHost("host3208616")
203             .setPort(3446913)
204             .setCurrentLocationId("currentLocationId-1808505335")
205             .setCreateTime(Timestamp.newBuilder().build())
206             .setStatusMessage("statusMessage-958704715")
207             .putAllRedisConfigs(new HashMap<String, String>())
208             .setMemorySizeGb(34199707)
209             .setAuthorizedNetwork("authorizedNetwork1515554835")
210             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
211             .setAuthEnabled(true)
212             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
213             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
214             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
215             .setReplicaCount(564075208)
216             .addAllNodes(new ArrayList<NodeInfo>())
217             .setReadEndpoint("readEndpoint294053195")
218             .setReadEndpointPort(-1676143102)
219             .setCustomerManagedKey("customerManagedKey-848978754")
220             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
221             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
222             .setMaintenanceVersion("maintenanceVersion1355658821")
223             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
224             .build();
225     mockService.addResponse(expectedResponse);
226 
227     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
228 
229     Instance actualResponse = client.getInstance(name);
230     Assert.assertEquals(expectedResponse, actualResponse);
231 
232     List<String> actualRequests = mockService.getRequestPaths();
233     Assert.assertEquals(1, actualRequests.size());
234 
235     String apiClientHeaderKey =
236         mockService
237             .getRequestHeaders()
238             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
239             .iterator()
240             .next();
241     Assert.assertTrue(
242         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
243             .matcher(apiClientHeaderKey)
244             .matches());
245   }
246 
247   @Test
getInstanceExceptionTest()248   public void getInstanceExceptionTest() throws Exception {
249     ApiException exception =
250         ApiExceptionFactory.createException(
251             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
252     mockService.addException(exception);
253 
254     try {
255       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
256       client.getInstance(name);
257       Assert.fail("No exception raised");
258     } catch (InvalidArgumentException e) {
259       // Expected exception.
260     }
261   }
262 
263   @Test
getInstanceTest2()264   public void getInstanceTest2() throws Exception {
265     Instance expectedResponse =
266         Instance.newBuilder()
267             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
268             .setDisplayName("displayName1714148973")
269             .putAllLabels(new HashMap<String, String>())
270             .setLocationId("locationId1541836720")
271             .setAlternativeLocationId("alternativeLocationId1787141949")
272             .setRedisVersion("redisVersion-1972584739")
273             .setReservedIpRange("reservedIpRange575015950")
274             .setSecondaryIpRange("secondaryIpRange-1937131454")
275             .setHost("host3208616")
276             .setPort(3446913)
277             .setCurrentLocationId("currentLocationId-1808505335")
278             .setCreateTime(Timestamp.newBuilder().build())
279             .setStatusMessage("statusMessage-958704715")
280             .putAllRedisConfigs(new HashMap<String, String>())
281             .setMemorySizeGb(34199707)
282             .setAuthorizedNetwork("authorizedNetwork1515554835")
283             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
284             .setAuthEnabled(true)
285             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
286             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
287             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
288             .setReplicaCount(564075208)
289             .addAllNodes(new ArrayList<NodeInfo>())
290             .setReadEndpoint("readEndpoint294053195")
291             .setReadEndpointPort(-1676143102)
292             .setCustomerManagedKey("customerManagedKey-848978754")
293             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
294             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
295             .setMaintenanceVersion("maintenanceVersion1355658821")
296             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
297             .build();
298     mockService.addResponse(expectedResponse);
299 
300     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
301 
302     Instance actualResponse = client.getInstance(name);
303     Assert.assertEquals(expectedResponse, actualResponse);
304 
305     List<String> actualRequests = mockService.getRequestPaths();
306     Assert.assertEquals(1, actualRequests.size());
307 
308     String apiClientHeaderKey =
309         mockService
310             .getRequestHeaders()
311             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
312             .iterator()
313             .next();
314     Assert.assertTrue(
315         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
316             .matcher(apiClientHeaderKey)
317             .matches());
318   }
319 
320   @Test
getInstanceExceptionTest2()321   public void getInstanceExceptionTest2() throws Exception {
322     ApiException exception =
323         ApiExceptionFactory.createException(
324             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
325     mockService.addException(exception);
326 
327     try {
328       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
329       client.getInstance(name);
330       Assert.fail("No exception raised");
331     } catch (InvalidArgumentException e) {
332       // Expected exception.
333     }
334   }
335 
336   @Test
getInstanceAuthStringTest()337   public void getInstanceAuthStringTest() throws Exception {
338     InstanceAuthString expectedResponse =
339         InstanceAuthString.newBuilder().setAuthString("authString1994738649").build();
340     mockService.addResponse(expectedResponse);
341 
342     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
343 
344     InstanceAuthString actualResponse = client.getInstanceAuthString(name);
345     Assert.assertEquals(expectedResponse, actualResponse);
346 
347     List<String> actualRequests = mockService.getRequestPaths();
348     Assert.assertEquals(1, actualRequests.size());
349 
350     String apiClientHeaderKey =
351         mockService
352             .getRequestHeaders()
353             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
354             .iterator()
355             .next();
356     Assert.assertTrue(
357         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
358             .matcher(apiClientHeaderKey)
359             .matches());
360   }
361 
362   @Test
getInstanceAuthStringExceptionTest()363   public void getInstanceAuthStringExceptionTest() throws Exception {
364     ApiException exception =
365         ApiExceptionFactory.createException(
366             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
367     mockService.addException(exception);
368 
369     try {
370       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
371       client.getInstanceAuthString(name);
372       Assert.fail("No exception raised");
373     } catch (InvalidArgumentException e) {
374       // Expected exception.
375     }
376   }
377 
378   @Test
getInstanceAuthStringTest2()379   public void getInstanceAuthStringTest2() throws Exception {
380     InstanceAuthString expectedResponse =
381         InstanceAuthString.newBuilder().setAuthString("authString1994738649").build();
382     mockService.addResponse(expectedResponse);
383 
384     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
385 
386     InstanceAuthString actualResponse = client.getInstanceAuthString(name);
387     Assert.assertEquals(expectedResponse, actualResponse);
388 
389     List<String> actualRequests = mockService.getRequestPaths();
390     Assert.assertEquals(1, actualRequests.size());
391 
392     String apiClientHeaderKey =
393         mockService
394             .getRequestHeaders()
395             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
396             .iterator()
397             .next();
398     Assert.assertTrue(
399         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
400             .matcher(apiClientHeaderKey)
401             .matches());
402   }
403 
404   @Test
getInstanceAuthStringExceptionTest2()405   public void getInstanceAuthStringExceptionTest2() throws Exception {
406     ApiException exception =
407         ApiExceptionFactory.createException(
408             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
409     mockService.addException(exception);
410 
411     try {
412       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
413       client.getInstanceAuthString(name);
414       Assert.fail("No exception raised");
415     } catch (InvalidArgumentException e) {
416       // Expected exception.
417     }
418   }
419 
420   @Test
createInstanceTest()421   public void createInstanceTest() throws Exception {
422     Instance expectedResponse =
423         Instance.newBuilder()
424             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
425             .setDisplayName("displayName1714148973")
426             .putAllLabels(new HashMap<String, String>())
427             .setLocationId("locationId1541836720")
428             .setAlternativeLocationId("alternativeLocationId1787141949")
429             .setRedisVersion("redisVersion-1972584739")
430             .setReservedIpRange("reservedIpRange575015950")
431             .setSecondaryIpRange("secondaryIpRange-1937131454")
432             .setHost("host3208616")
433             .setPort(3446913)
434             .setCurrentLocationId("currentLocationId-1808505335")
435             .setCreateTime(Timestamp.newBuilder().build())
436             .setStatusMessage("statusMessage-958704715")
437             .putAllRedisConfigs(new HashMap<String, String>())
438             .setMemorySizeGb(34199707)
439             .setAuthorizedNetwork("authorizedNetwork1515554835")
440             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
441             .setAuthEnabled(true)
442             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
443             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
444             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
445             .setReplicaCount(564075208)
446             .addAllNodes(new ArrayList<NodeInfo>())
447             .setReadEndpoint("readEndpoint294053195")
448             .setReadEndpointPort(-1676143102)
449             .setCustomerManagedKey("customerManagedKey-848978754")
450             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
451             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
452             .setMaintenanceVersion("maintenanceVersion1355658821")
453             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
454             .build();
455     Operation resultOperation =
456         Operation.newBuilder()
457             .setName("createInstanceTest")
458             .setDone(true)
459             .setResponse(Any.pack(expectedResponse))
460             .build();
461     mockService.addResponse(resultOperation);
462 
463     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
464     String instanceId = "instanceId902024336";
465     Instance instance = Instance.newBuilder().build();
466 
467     Instance actualResponse = client.createInstanceAsync(parent, instanceId, instance).get();
468     Assert.assertEquals(expectedResponse, actualResponse);
469 
470     List<String> actualRequests = mockService.getRequestPaths();
471     Assert.assertEquals(1, actualRequests.size());
472 
473     String apiClientHeaderKey =
474         mockService
475             .getRequestHeaders()
476             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
477             .iterator()
478             .next();
479     Assert.assertTrue(
480         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
481             .matcher(apiClientHeaderKey)
482             .matches());
483   }
484 
485   @Test
createInstanceExceptionTest()486   public void createInstanceExceptionTest() throws Exception {
487     ApiException exception =
488         ApiExceptionFactory.createException(
489             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
490     mockService.addException(exception);
491 
492     try {
493       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
494       String instanceId = "instanceId902024336";
495       Instance instance = Instance.newBuilder().build();
496       client.createInstanceAsync(parent, instanceId, instance).get();
497       Assert.fail("No exception raised");
498     } catch (ExecutionException e) {
499     }
500   }
501 
502   @Test
createInstanceTest2()503   public void createInstanceTest2() throws Exception {
504     Instance expectedResponse =
505         Instance.newBuilder()
506             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
507             .setDisplayName("displayName1714148973")
508             .putAllLabels(new HashMap<String, String>())
509             .setLocationId("locationId1541836720")
510             .setAlternativeLocationId("alternativeLocationId1787141949")
511             .setRedisVersion("redisVersion-1972584739")
512             .setReservedIpRange("reservedIpRange575015950")
513             .setSecondaryIpRange("secondaryIpRange-1937131454")
514             .setHost("host3208616")
515             .setPort(3446913)
516             .setCurrentLocationId("currentLocationId-1808505335")
517             .setCreateTime(Timestamp.newBuilder().build())
518             .setStatusMessage("statusMessage-958704715")
519             .putAllRedisConfigs(new HashMap<String, String>())
520             .setMemorySizeGb(34199707)
521             .setAuthorizedNetwork("authorizedNetwork1515554835")
522             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
523             .setAuthEnabled(true)
524             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
525             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
526             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
527             .setReplicaCount(564075208)
528             .addAllNodes(new ArrayList<NodeInfo>())
529             .setReadEndpoint("readEndpoint294053195")
530             .setReadEndpointPort(-1676143102)
531             .setCustomerManagedKey("customerManagedKey-848978754")
532             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
533             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
534             .setMaintenanceVersion("maintenanceVersion1355658821")
535             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
536             .build();
537     Operation resultOperation =
538         Operation.newBuilder()
539             .setName("createInstanceTest")
540             .setDone(true)
541             .setResponse(Any.pack(expectedResponse))
542             .build();
543     mockService.addResponse(resultOperation);
544 
545     String parent = "projects/project-5833/locations/location-5833";
546     String instanceId = "instanceId902024336";
547     Instance instance = Instance.newBuilder().build();
548 
549     Instance actualResponse = client.createInstanceAsync(parent, instanceId, instance).get();
550     Assert.assertEquals(expectedResponse, actualResponse);
551 
552     List<String> actualRequests = mockService.getRequestPaths();
553     Assert.assertEquals(1, actualRequests.size());
554 
555     String apiClientHeaderKey =
556         mockService
557             .getRequestHeaders()
558             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
559             .iterator()
560             .next();
561     Assert.assertTrue(
562         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
563             .matcher(apiClientHeaderKey)
564             .matches());
565   }
566 
567   @Test
createInstanceExceptionTest2()568   public void createInstanceExceptionTest2() throws Exception {
569     ApiException exception =
570         ApiExceptionFactory.createException(
571             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
572     mockService.addException(exception);
573 
574     try {
575       String parent = "projects/project-5833/locations/location-5833";
576       String instanceId = "instanceId902024336";
577       Instance instance = Instance.newBuilder().build();
578       client.createInstanceAsync(parent, instanceId, instance).get();
579       Assert.fail("No exception raised");
580     } catch (ExecutionException e) {
581     }
582   }
583 
584   @Test
updateInstanceTest()585   public void updateInstanceTest() throws Exception {
586     Instance expectedResponse =
587         Instance.newBuilder()
588             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
589             .setDisplayName("displayName1714148973")
590             .putAllLabels(new HashMap<String, String>())
591             .setLocationId("locationId1541836720")
592             .setAlternativeLocationId("alternativeLocationId1787141949")
593             .setRedisVersion("redisVersion-1972584739")
594             .setReservedIpRange("reservedIpRange575015950")
595             .setSecondaryIpRange("secondaryIpRange-1937131454")
596             .setHost("host3208616")
597             .setPort(3446913)
598             .setCurrentLocationId("currentLocationId-1808505335")
599             .setCreateTime(Timestamp.newBuilder().build())
600             .setStatusMessage("statusMessage-958704715")
601             .putAllRedisConfigs(new HashMap<String, String>())
602             .setMemorySizeGb(34199707)
603             .setAuthorizedNetwork("authorizedNetwork1515554835")
604             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
605             .setAuthEnabled(true)
606             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
607             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
608             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
609             .setReplicaCount(564075208)
610             .addAllNodes(new ArrayList<NodeInfo>())
611             .setReadEndpoint("readEndpoint294053195")
612             .setReadEndpointPort(-1676143102)
613             .setCustomerManagedKey("customerManagedKey-848978754")
614             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
615             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
616             .setMaintenanceVersion("maintenanceVersion1355658821")
617             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
618             .build();
619     Operation resultOperation =
620         Operation.newBuilder()
621             .setName("updateInstanceTest")
622             .setDone(true)
623             .setResponse(Any.pack(expectedResponse))
624             .build();
625     mockService.addResponse(resultOperation);
626 
627     FieldMask updateMask = FieldMask.newBuilder().build();
628     Instance instance =
629         Instance.newBuilder()
630             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
631             .setDisplayName("displayName1714148973")
632             .putAllLabels(new HashMap<String, String>())
633             .setLocationId("locationId1541836720")
634             .setAlternativeLocationId("alternativeLocationId1787141949")
635             .setRedisVersion("redisVersion-1972584739")
636             .setReservedIpRange("reservedIpRange575015950")
637             .setSecondaryIpRange("secondaryIpRange-1937131454")
638             .setHost("host3208616")
639             .setPort(3446913)
640             .setCurrentLocationId("currentLocationId-1808505335")
641             .setCreateTime(Timestamp.newBuilder().build())
642             .setStatusMessage("statusMessage-958704715")
643             .putAllRedisConfigs(new HashMap<String, String>())
644             .setMemorySizeGb(34199707)
645             .setAuthorizedNetwork("authorizedNetwork1515554835")
646             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
647             .setAuthEnabled(true)
648             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
649             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
650             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
651             .setReplicaCount(564075208)
652             .addAllNodes(new ArrayList<NodeInfo>())
653             .setReadEndpoint("readEndpoint294053195")
654             .setReadEndpointPort(-1676143102)
655             .setCustomerManagedKey("customerManagedKey-848978754")
656             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
657             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
658             .setMaintenanceVersion("maintenanceVersion1355658821")
659             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
660             .build();
661 
662     Instance actualResponse = client.updateInstanceAsync(updateMask, instance).get();
663     Assert.assertEquals(expectedResponse, actualResponse);
664 
665     List<String> actualRequests = mockService.getRequestPaths();
666     Assert.assertEquals(1, actualRequests.size());
667 
668     String apiClientHeaderKey =
669         mockService
670             .getRequestHeaders()
671             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
672             .iterator()
673             .next();
674     Assert.assertTrue(
675         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
676             .matcher(apiClientHeaderKey)
677             .matches());
678   }
679 
680   @Test
updateInstanceExceptionTest()681   public void updateInstanceExceptionTest() throws Exception {
682     ApiException exception =
683         ApiExceptionFactory.createException(
684             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
685     mockService.addException(exception);
686 
687     try {
688       FieldMask updateMask = FieldMask.newBuilder().build();
689       Instance instance =
690           Instance.newBuilder()
691               .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
692               .setDisplayName("displayName1714148973")
693               .putAllLabels(new HashMap<String, String>())
694               .setLocationId("locationId1541836720")
695               .setAlternativeLocationId("alternativeLocationId1787141949")
696               .setRedisVersion("redisVersion-1972584739")
697               .setReservedIpRange("reservedIpRange575015950")
698               .setSecondaryIpRange("secondaryIpRange-1937131454")
699               .setHost("host3208616")
700               .setPort(3446913)
701               .setCurrentLocationId("currentLocationId-1808505335")
702               .setCreateTime(Timestamp.newBuilder().build())
703               .setStatusMessage("statusMessage-958704715")
704               .putAllRedisConfigs(new HashMap<String, String>())
705               .setMemorySizeGb(34199707)
706               .setAuthorizedNetwork("authorizedNetwork1515554835")
707               .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
708               .setAuthEnabled(true)
709               .addAllServerCaCerts(new ArrayList<TlsCertificate>())
710               .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
711               .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
712               .setReplicaCount(564075208)
713               .addAllNodes(new ArrayList<NodeInfo>())
714               .setReadEndpoint("readEndpoint294053195")
715               .setReadEndpointPort(-1676143102)
716               .setCustomerManagedKey("customerManagedKey-848978754")
717               .setPersistenceConfig(PersistenceConfig.newBuilder().build())
718               .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
719               .setMaintenanceVersion("maintenanceVersion1355658821")
720               .addAllAvailableMaintenanceVersions(new ArrayList<String>())
721               .build();
722       client.updateInstanceAsync(updateMask, instance).get();
723       Assert.fail("No exception raised");
724     } catch (ExecutionException e) {
725     }
726   }
727 
728   @Test
upgradeInstanceTest()729   public void upgradeInstanceTest() throws Exception {
730     Instance expectedResponse =
731         Instance.newBuilder()
732             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
733             .setDisplayName("displayName1714148973")
734             .putAllLabels(new HashMap<String, String>())
735             .setLocationId("locationId1541836720")
736             .setAlternativeLocationId("alternativeLocationId1787141949")
737             .setRedisVersion("redisVersion-1972584739")
738             .setReservedIpRange("reservedIpRange575015950")
739             .setSecondaryIpRange("secondaryIpRange-1937131454")
740             .setHost("host3208616")
741             .setPort(3446913)
742             .setCurrentLocationId("currentLocationId-1808505335")
743             .setCreateTime(Timestamp.newBuilder().build())
744             .setStatusMessage("statusMessage-958704715")
745             .putAllRedisConfigs(new HashMap<String, String>())
746             .setMemorySizeGb(34199707)
747             .setAuthorizedNetwork("authorizedNetwork1515554835")
748             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
749             .setAuthEnabled(true)
750             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
751             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
752             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
753             .setReplicaCount(564075208)
754             .addAllNodes(new ArrayList<NodeInfo>())
755             .setReadEndpoint("readEndpoint294053195")
756             .setReadEndpointPort(-1676143102)
757             .setCustomerManagedKey("customerManagedKey-848978754")
758             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
759             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
760             .setMaintenanceVersion("maintenanceVersion1355658821")
761             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
762             .build();
763     Operation resultOperation =
764         Operation.newBuilder()
765             .setName("upgradeInstanceTest")
766             .setDone(true)
767             .setResponse(Any.pack(expectedResponse))
768             .build();
769     mockService.addResponse(resultOperation);
770 
771     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
772     String redisVersion = "redisVersion-1972584739";
773 
774     Instance actualResponse = client.upgradeInstanceAsync(name, redisVersion).get();
775     Assert.assertEquals(expectedResponse, actualResponse);
776 
777     List<String> actualRequests = mockService.getRequestPaths();
778     Assert.assertEquals(1, actualRequests.size());
779 
780     String apiClientHeaderKey =
781         mockService
782             .getRequestHeaders()
783             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
784             .iterator()
785             .next();
786     Assert.assertTrue(
787         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
788             .matcher(apiClientHeaderKey)
789             .matches());
790   }
791 
792   @Test
upgradeInstanceExceptionTest()793   public void upgradeInstanceExceptionTest() throws Exception {
794     ApiException exception =
795         ApiExceptionFactory.createException(
796             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
797     mockService.addException(exception);
798 
799     try {
800       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
801       String redisVersion = "redisVersion-1972584739";
802       client.upgradeInstanceAsync(name, redisVersion).get();
803       Assert.fail("No exception raised");
804     } catch (ExecutionException e) {
805     }
806   }
807 
808   @Test
upgradeInstanceTest2()809   public void upgradeInstanceTest2() throws Exception {
810     Instance expectedResponse =
811         Instance.newBuilder()
812             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
813             .setDisplayName("displayName1714148973")
814             .putAllLabels(new HashMap<String, String>())
815             .setLocationId("locationId1541836720")
816             .setAlternativeLocationId("alternativeLocationId1787141949")
817             .setRedisVersion("redisVersion-1972584739")
818             .setReservedIpRange("reservedIpRange575015950")
819             .setSecondaryIpRange("secondaryIpRange-1937131454")
820             .setHost("host3208616")
821             .setPort(3446913)
822             .setCurrentLocationId("currentLocationId-1808505335")
823             .setCreateTime(Timestamp.newBuilder().build())
824             .setStatusMessage("statusMessage-958704715")
825             .putAllRedisConfigs(new HashMap<String, String>())
826             .setMemorySizeGb(34199707)
827             .setAuthorizedNetwork("authorizedNetwork1515554835")
828             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
829             .setAuthEnabled(true)
830             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
831             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
832             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
833             .setReplicaCount(564075208)
834             .addAllNodes(new ArrayList<NodeInfo>())
835             .setReadEndpoint("readEndpoint294053195")
836             .setReadEndpointPort(-1676143102)
837             .setCustomerManagedKey("customerManagedKey-848978754")
838             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
839             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
840             .setMaintenanceVersion("maintenanceVersion1355658821")
841             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
842             .build();
843     Operation resultOperation =
844         Operation.newBuilder()
845             .setName("upgradeInstanceTest")
846             .setDone(true)
847             .setResponse(Any.pack(expectedResponse))
848             .build();
849     mockService.addResponse(resultOperation);
850 
851     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
852     String redisVersion = "redisVersion-1972584739";
853 
854     Instance actualResponse = client.upgradeInstanceAsync(name, redisVersion).get();
855     Assert.assertEquals(expectedResponse, actualResponse);
856 
857     List<String> actualRequests = mockService.getRequestPaths();
858     Assert.assertEquals(1, actualRequests.size());
859 
860     String apiClientHeaderKey =
861         mockService
862             .getRequestHeaders()
863             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
864             .iterator()
865             .next();
866     Assert.assertTrue(
867         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
868             .matcher(apiClientHeaderKey)
869             .matches());
870   }
871 
872   @Test
upgradeInstanceExceptionTest2()873   public void upgradeInstanceExceptionTest2() throws Exception {
874     ApiException exception =
875         ApiExceptionFactory.createException(
876             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
877     mockService.addException(exception);
878 
879     try {
880       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
881       String redisVersion = "redisVersion-1972584739";
882       client.upgradeInstanceAsync(name, redisVersion).get();
883       Assert.fail("No exception raised");
884     } catch (ExecutionException e) {
885     }
886   }
887 
888   @Test
importInstanceTest()889   public void importInstanceTest() throws Exception {
890     Instance expectedResponse =
891         Instance.newBuilder()
892             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
893             .setDisplayName("displayName1714148973")
894             .putAllLabels(new HashMap<String, String>())
895             .setLocationId("locationId1541836720")
896             .setAlternativeLocationId("alternativeLocationId1787141949")
897             .setRedisVersion("redisVersion-1972584739")
898             .setReservedIpRange("reservedIpRange575015950")
899             .setSecondaryIpRange("secondaryIpRange-1937131454")
900             .setHost("host3208616")
901             .setPort(3446913)
902             .setCurrentLocationId("currentLocationId-1808505335")
903             .setCreateTime(Timestamp.newBuilder().build())
904             .setStatusMessage("statusMessage-958704715")
905             .putAllRedisConfigs(new HashMap<String, String>())
906             .setMemorySizeGb(34199707)
907             .setAuthorizedNetwork("authorizedNetwork1515554835")
908             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
909             .setAuthEnabled(true)
910             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
911             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
912             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
913             .setReplicaCount(564075208)
914             .addAllNodes(new ArrayList<NodeInfo>())
915             .setReadEndpoint("readEndpoint294053195")
916             .setReadEndpointPort(-1676143102)
917             .setCustomerManagedKey("customerManagedKey-848978754")
918             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
919             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
920             .setMaintenanceVersion("maintenanceVersion1355658821")
921             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
922             .build();
923     Operation resultOperation =
924         Operation.newBuilder()
925             .setName("importInstanceTest")
926             .setDone(true)
927             .setResponse(Any.pack(expectedResponse))
928             .build();
929     mockService.addResponse(resultOperation);
930 
931     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
932     InputConfig inputConfig = InputConfig.newBuilder().build();
933 
934     Instance actualResponse = client.importInstanceAsync(name, inputConfig).get();
935     Assert.assertEquals(expectedResponse, actualResponse);
936 
937     List<String> actualRequests = mockService.getRequestPaths();
938     Assert.assertEquals(1, actualRequests.size());
939 
940     String apiClientHeaderKey =
941         mockService
942             .getRequestHeaders()
943             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
944             .iterator()
945             .next();
946     Assert.assertTrue(
947         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
948             .matcher(apiClientHeaderKey)
949             .matches());
950   }
951 
952   @Test
importInstanceExceptionTest()953   public void importInstanceExceptionTest() throws Exception {
954     ApiException exception =
955         ApiExceptionFactory.createException(
956             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
957     mockService.addException(exception);
958 
959     try {
960       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
961       InputConfig inputConfig = InputConfig.newBuilder().build();
962       client.importInstanceAsync(name, inputConfig).get();
963       Assert.fail("No exception raised");
964     } catch (ExecutionException e) {
965     }
966   }
967 
968   @Test
exportInstanceTest()969   public void exportInstanceTest() throws Exception {
970     Instance expectedResponse =
971         Instance.newBuilder()
972             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
973             .setDisplayName("displayName1714148973")
974             .putAllLabels(new HashMap<String, String>())
975             .setLocationId("locationId1541836720")
976             .setAlternativeLocationId("alternativeLocationId1787141949")
977             .setRedisVersion("redisVersion-1972584739")
978             .setReservedIpRange("reservedIpRange575015950")
979             .setSecondaryIpRange("secondaryIpRange-1937131454")
980             .setHost("host3208616")
981             .setPort(3446913)
982             .setCurrentLocationId("currentLocationId-1808505335")
983             .setCreateTime(Timestamp.newBuilder().build())
984             .setStatusMessage("statusMessage-958704715")
985             .putAllRedisConfigs(new HashMap<String, String>())
986             .setMemorySizeGb(34199707)
987             .setAuthorizedNetwork("authorizedNetwork1515554835")
988             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
989             .setAuthEnabled(true)
990             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
991             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
992             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
993             .setReplicaCount(564075208)
994             .addAllNodes(new ArrayList<NodeInfo>())
995             .setReadEndpoint("readEndpoint294053195")
996             .setReadEndpointPort(-1676143102)
997             .setCustomerManagedKey("customerManagedKey-848978754")
998             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
999             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
1000             .setMaintenanceVersion("maintenanceVersion1355658821")
1001             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
1002             .build();
1003     Operation resultOperation =
1004         Operation.newBuilder()
1005             .setName("exportInstanceTest")
1006             .setDone(true)
1007             .setResponse(Any.pack(expectedResponse))
1008             .build();
1009     mockService.addResponse(resultOperation);
1010 
1011     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1012     OutputConfig outputConfig = OutputConfig.newBuilder().build();
1013 
1014     Instance actualResponse = client.exportInstanceAsync(name, outputConfig).get();
1015     Assert.assertEquals(expectedResponse, actualResponse);
1016 
1017     List<String> actualRequests = mockService.getRequestPaths();
1018     Assert.assertEquals(1, actualRequests.size());
1019 
1020     String apiClientHeaderKey =
1021         mockService
1022             .getRequestHeaders()
1023             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1024             .iterator()
1025             .next();
1026     Assert.assertTrue(
1027         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1028             .matcher(apiClientHeaderKey)
1029             .matches());
1030   }
1031 
1032   @Test
exportInstanceExceptionTest()1033   public void exportInstanceExceptionTest() throws Exception {
1034     ApiException exception =
1035         ApiExceptionFactory.createException(
1036             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1037     mockService.addException(exception);
1038 
1039     try {
1040       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1041       OutputConfig outputConfig = OutputConfig.newBuilder().build();
1042       client.exportInstanceAsync(name, outputConfig).get();
1043       Assert.fail("No exception raised");
1044     } catch (ExecutionException e) {
1045     }
1046   }
1047 
1048   @Test
failoverInstanceTest()1049   public void failoverInstanceTest() throws Exception {
1050     Instance expectedResponse =
1051         Instance.newBuilder()
1052             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1053             .setDisplayName("displayName1714148973")
1054             .putAllLabels(new HashMap<String, String>())
1055             .setLocationId("locationId1541836720")
1056             .setAlternativeLocationId("alternativeLocationId1787141949")
1057             .setRedisVersion("redisVersion-1972584739")
1058             .setReservedIpRange("reservedIpRange575015950")
1059             .setSecondaryIpRange("secondaryIpRange-1937131454")
1060             .setHost("host3208616")
1061             .setPort(3446913)
1062             .setCurrentLocationId("currentLocationId-1808505335")
1063             .setCreateTime(Timestamp.newBuilder().build())
1064             .setStatusMessage("statusMessage-958704715")
1065             .putAllRedisConfigs(new HashMap<String, String>())
1066             .setMemorySizeGb(34199707)
1067             .setAuthorizedNetwork("authorizedNetwork1515554835")
1068             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1069             .setAuthEnabled(true)
1070             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1071             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1072             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1073             .setReplicaCount(564075208)
1074             .addAllNodes(new ArrayList<NodeInfo>())
1075             .setReadEndpoint("readEndpoint294053195")
1076             .setReadEndpointPort(-1676143102)
1077             .setCustomerManagedKey("customerManagedKey-848978754")
1078             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1079             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
1080             .setMaintenanceVersion("maintenanceVersion1355658821")
1081             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
1082             .build();
1083     Operation resultOperation =
1084         Operation.newBuilder()
1085             .setName("failoverInstanceTest")
1086             .setDone(true)
1087             .setResponse(Any.pack(expectedResponse))
1088             .build();
1089     mockService.addResponse(resultOperation);
1090 
1091     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1092     FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1093         FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1094 
1095     Instance actualResponse = client.failoverInstanceAsync(name, dataProtectionMode).get();
1096     Assert.assertEquals(expectedResponse, actualResponse);
1097 
1098     List<String> actualRequests = mockService.getRequestPaths();
1099     Assert.assertEquals(1, actualRequests.size());
1100 
1101     String apiClientHeaderKey =
1102         mockService
1103             .getRequestHeaders()
1104             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1105             .iterator()
1106             .next();
1107     Assert.assertTrue(
1108         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1109             .matcher(apiClientHeaderKey)
1110             .matches());
1111   }
1112 
1113   @Test
failoverInstanceExceptionTest()1114   public void failoverInstanceExceptionTest() throws Exception {
1115     ApiException exception =
1116         ApiExceptionFactory.createException(
1117             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1118     mockService.addException(exception);
1119 
1120     try {
1121       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1122       FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1123           FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1124       client.failoverInstanceAsync(name, dataProtectionMode).get();
1125       Assert.fail("No exception raised");
1126     } catch (ExecutionException e) {
1127     }
1128   }
1129 
1130   @Test
failoverInstanceTest2()1131   public void failoverInstanceTest2() throws Exception {
1132     Instance expectedResponse =
1133         Instance.newBuilder()
1134             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1135             .setDisplayName("displayName1714148973")
1136             .putAllLabels(new HashMap<String, String>())
1137             .setLocationId("locationId1541836720")
1138             .setAlternativeLocationId("alternativeLocationId1787141949")
1139             .setRedisVersion("redisVersion-1972584739")
1140             .setReservedIpRange("reservedIpRange575015950")
1141             .setSecondaryIpRange("secondaryIpRange-1937131454")
1142             .setHost("host3208616")
1143             .setPort(3446913)
1144             .setCurrentLocationId("currentLocationId-1808505335")
1145             .setCreateTime(Timestamp.newBuilder().build())
1146             .setStatusMessage("statusMessage-958704715")
1147             .putAllRedisConfigs(new HashMap<String, String>())
1148             .setMemorySizeGb(34199707)
1149             .setAuthorizedNetwork("authorizedNetwork1515554835")
1150             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1151             .setAuthEnabled(true)
1152             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1153             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1154             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1155             .setReplicaCount(564075208)
1156             .addAllNodes(new ArrayList<NodeInfo>())
1157             .setReadEndpoint("readEndpoint294053195")
1158             .setReadEndpointPort(-1676143102)
1159             .setCustomerManagedKey("customerManagedKey-848978754")
1160             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1161             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
1162             .setMaintenanceVersion("maintenanceVersion1355658821")
1163             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
1164             .build();
1165     Operation resultOperation =
1166         Operation.newBuilder()
1167             .setName("failoverInstanceTest")
1168             .setDone(true)
1169             .setResponse(Any.pack(expectedResponse))
1170             .build();
1171     mockService.addResponse(resultOperation);
1172 
1173     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1174     FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1175         FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1176 
1177     Instance actualResponse = client.failoverInstanceAsync(name, dataProtectionMode).get();
1178     Assert.assertEquals(expectedResponse, actualResponse);
1179 
1180     List<String> actualRequests = mockService.getRequestPaths();
1181     Assert.assertEquals(1, actualRequests.size());
1182 
1183     String apiClientHeaderKey =
1184         mockService
1185             .getRequestHeaders()
1186             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1187             .iterator()
1188             .next();
1189     Assert.assertTrue(
1190         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1191             .matcher(apiClientHeaderKey)
1192             .matches());
1193   }
1194 
1195   @Test
failoverInstanceExceptionTest2()1196   public void failoverInstanceExceptionTest2() throws Exception {
1197     ApiException exception =
1198         ApiExceptionFactory.createException(
1199             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1200     mockService.addException(exception);
1201 
1202     try {
1203       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1204       FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1205           FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1206       client.failoverInstanceAsync(name, dataProtectionMode).get();
1207       Assert.fail("No exception raised");
1208     } catch (ExecutionException e) {
1209     }
1210   }
1211 
1212   @Test
deleteInstanceTest()1213   public void deleteInstanceTest() throws Exception {
1214     Empty expectedResponse = Empty.newBuilder().build();
1215     Operation resultOperation =
1216         Operation.newBuilder()
1217             .setName("deleteInstanceTest")
1218             .setDone(true)
1219             .setResponse(Any.pack(expectedResponse))
1220             .build();
1221     mockService.addResponse(resultOperation);
1222 
1223     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1224 
1225     client.deleteInstanceAsync(name).get();
1226 
1227     List<String> actualRequests = mockService.getRequestPaths();
1228     Assert.assertEquals(1, actualRequests.size());
1229 
1230     String apiClientHeaderKey =
1231         mockService
1232             .getRequestHeaders()
1233             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1234             .iterator()
1235             .next();
1236     Assert.assertTrue(
1237         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1238             .matcher(apiClientHeaderKey)
1239             .matches());
1240   }
1241 
1242   @Test
deleteInstanceExceptionTest()1243   public void deleteInstanceExceptionTest() throws Exception {
1244     ApiException exception =
1245         ApiExceptionFactory.createException(
1246             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1247     mockService.addException(exception);
1248 
1249     try {
1250       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1251       client.deleteInstanceAsync(name).get();
1252       Assert.fail("No exception raised");
1253     } catch (ExecutionException e) {
1254     }
1255   }
1256 
1257   @Test
deleteInstanceTest2()1258   public void deleteInstanceTest2() throws Exception {
1259     Empty expectedResponse = Empty.newBuilder().build();
1260     Operation resultOperation =
1261         Operation.newBuilder()
1262             .setName("deleteInstanceTest")
1263             .setDone(true)
1264             .setResponse(Any.pack(expectedResponse))
1265             .build();
1266     mockService.addResponse(resultOperation);
1267 
1268     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1269 
1270     client.deleteInstanceAsync(name).get();
1271 
1272     List<String> actualRequests = mockService.getRequestPaths();
1273     Assert.assertEquals(1, actualRequests.size());
1274 
1275     String apiClientHeaderKey =
1276         mockService
1277             .getRequestHeaders()
1278             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1279             .iterator()
1280             .next();
1281     Assert.assertTrue(
1282         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1283             .matcher(apiClientHeaderKey)
1284             .matches());
1285   }
1286 
1287   @Test
deleteInstanceExceptionTest2()1288   public void deleteInstanceExceptionTest2() throws Exception {
1289     ApiException exception =
1290         ApiExceptionFactory.createException(
1291             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1292     mockService.addException(exception);
1293 
1294     try {
1295       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1296       client.deleteInstanceAsync(name).get();
1297       Assert.fail("No exception raised");
1298     } catch (ExecutionException e) {
1299     }
1300   }
1301 
1302   @Test
rescheduleMaintenanceTest()1303   public void rescheduleMaintenanceTest() throws Exception {
1304     Instance expectedResponse =
1305         Instance.newBuilder()
1306             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1307             .setDisplayName("displayName1714148973")
1308             .putAllLabels(new HashMap<String, String>())
1309             .setLocationId("locationId1541836720")
1310             .setAlternativeLocationId("alternativeLocationId1787141949")
1311             .setRedisVersion("redisVersion-1972584739")
1312             .setReservedIpRange("reservedIpRange575015950")
1313             .setSecondaryIpRange("secondaryIpRange-1937131454")
1314             .setHost("host3208616")
1315             .setPort(3446913)
1316             .setCurrentLocationId("currentLocationId-1808505335")
1317             .setCreateTime(Timestamp.newBuilder().build())
1318             .setStatusMessage("statusMessage-958704715")
1319             .putAllRedisConfigs(new HashMap<String, String>())
1320             .setMemorySizeGb(34199707)
1321             .setAuthorizedNetwork("authorizedNetwork1515554835")
1322             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1323             .setAuthEnabled(true)
1324             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1325             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1326             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1327             .setReplicaCount(564075208)
1328             .addAllNodes(new ArrayList<NodeInfo>())
1329             .setReadEndpoint("readEndpoint294053195")
1330             .setReadEndpointPort(-1676143102)
1331             .setCustomerManagedKey("customerManagedKey-848978754")
1332             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1333             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
1334             .setMaintenanceVersion("maintenanceVersion1355658821")
1335             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
1336             .build();
1337     Operation resultOperation =
1338         Operation.newBuilder()
1339             .setName("rescheduleMaintenanceTest")
1340             .setDone(true)
1341             .setResponse(Any.pack(expectedResponse))
1342             .build();
1343     mockService.addResponse(resultOperation);
1344 
1345     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1346     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1347         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1348     Timestamp scheduleTime = Timestamp.newBuilder().build();
1349 
1350     Instance actualResponse =
1351         client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1352     Assert.assertEquals(expectedResponse, actualResponse);
1353 
1354     List<String> actualRequests = mockService.getRequestPaths();
1355     Assert.assertEquals(1, actualRequests.size());
1356 
1357     String apiClientHeaderKey =
1358         mockService
1359             .getRequestHeaders()
1360             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1361             .iterator()
1362             .next();
1363     Assert.assertTrue(
1364         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1365             .matcher(apiClientHeaderKey)
1366             .matches());
1367   }
1368 
1369   @Test
rescheduleMaintenanceExceptionTest()1370   public void rescheduleMaintenanceExceptionTest() throws Exception {
1371     ApiException exception =
1372         ApiExceptionFactory.createException(
1373             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1374     mockService.addException(exception);
1375 
1376     try {
1377       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1378       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1379           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1380       Timestamp scheduleTime = Timestamp.newBuilder().build();
1381       client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1382       Assert.fail("No exception raised");
1383     } catch (ExecutionException e) {
1384     }
1385   }
1386 
1387   @Test
rescheduleMaintenanceTest2()1388   public void rescheduleMaintenanceTest2() throws Exception {
1389     Instance expectedResponse =
1390         Instance.newBuilder()
1391             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1392             .setDisplayName("displayName1714148973")
1393             .putAllLabels(new HashMap<String, String>())
1394             .setLocationId("locationId1541836720")
1395             .setAlternativeLocationId("alternativeLocationId1787141949")
1396             .setRedisVersion("redisVersion-1972584739")
1397             .setReservedIpRange("reservedIpRange575015950")
1398             .setSecondaryIpRange("secondaryIpRange-1937131454")
1399             .setHost("host3208616")
1400             .setPort(3446913)
1401             .setCurrentLocationId("currentLocationId-1808505335")
1402             .setCreateTime(Timestamp.newBuilder().build())
1403             .setStatusMessage("statusMessage-958704715")
1404             .putAllRedisConfigs(new HashMap<String, String>())
1405             .setMemorySizeGb(34199707)
1406             .setAuthorizedNetwork("authorizedNetwork1515554835")
1407             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1408             .setAuthEnabled(true)
1409             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1410             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1411             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1412             .setReplicaCount(564075208)
1413             .addAllNodes(new ArrayList<NodeInfo>())
1414             .setReadEndpoint("readEndpoint294053195")
1415             .setReadEndpointPort(-1676143102)
1416             .setCustomerManagedKey("customerManagedKey-848978754")
1417             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1418             .addAllSuspensionReasons(new ArrayList<Instance.SuspensionReason>())
1419             .setMaintenanceVersion("maintenanceVersion1355658821")
1420             .addAllAvailableMaintenanceVersions(new ArrayList<String>())
1421             .build();
1422     Operation resultOperation =
1423         Operation.newBuilder()
1424             .setName("rescheduleMaintenanceTest")
1425             .setDone(true)
1426             .setResponse(Any.pack(expectedResponse))
1427             .build();
1428     mockService.addResponse(resultOperation);
1429 
1430     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1431     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1432         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1433     Timestamp scheduleTime = Timestamp.newBuilder().build();
1434 
1435     Instance actualResponse =
1436         client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1437     Assert.assertEquals(expectedResponse, actualResponse);
1438 
1439     List<String> actualRequests = mockService.getRequestPaths();
1440     Assert.assertEquals(1, actualRequests.size());
1441 
1442     String apiClientHeaderKey =
1443         mockService
1444             .getRequestHeaders()
1445             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1446             .iterator()
1447             .next();
1448     Assert.assertTrue(
1449         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1450             .matcher(apiClientHeaderKey)
1451             .matches());
1452   }
1453 
1454   @Test
rescheduleMaintenanceExceptionTest2()1455   public void rescheduleMaintenanceExceptionTest2() throws Exception {
1456     ApiException exception =
1457         ApiExceptionFactory.createException(
1458             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1459     mockService.addException(exception);
1460 
1461     try {
1462       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
1463       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1464           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1465       Timestamp scheduleTime = Timestamp.newBuilder().build();
1466       client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1467       Assert.fail("No exception raised");
1468     } catch (ExecutionException e) {
1469     }
1470   }
1471 
1472   @Test
listLocationsTest()1473   public void listLocationsTest() throws Exception {
1474     Location responsesElement = Location.newBuilder().build();
1475     ListLocationsResponse expectedResponse =
1476         ListLocationsResponse.newBuilder()
1477             .setNextPageToken("")
1478             .addAllLocations(Arrays.asList(responsesElement))
1479             .build();
1480     mockService.addResponse(expectedResponse);
1481 
1482     ListLocationsRequest request =
1483         ListLocationsRequest.newBuilder()
1484             .setName("projects/project-3664")
1485             .setFilter("filter-1274492040")
1486             .setPageSize(883849137)
1487             .setPageToken("pageToken873572522")
1488             .build();
1489 
1490     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1491 
1492     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1493 
1494     Assert.assertEquals(1, resources.size());
1495     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1496 
1497     List<String> actualRequests = mockService.getRequestPaths();
1498     Assert.assertEquals(1, actualRequests.size());
1499 
1500     String apiClientHeaderKey =
1501         mockService
1502             .getRequestHeaders()
1503             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1504             .iterator()
1505             .next();
1506     Assert.assertTrue(
1507         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1508             .matcher(apiClientHeaderKey)
1509             .matches());
1510   }
1511 
1512   @Test
listLocationsExceptionTest()1513   public void listLocationsExceptionTest() throws Exception {
1514     ApiException exception =
1515         ApiExceptionFactory.createException(
1516             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1517     mockService.addException(exception);
1518 
1519     try {
1520       ListLocationsRequest request =
1521           ListLocationsRequest.newBuilder()
1522               .setName("projects/project-3664")
1523               .setFilter("filter-1274492040")
1524               .setPageSize(883849137)
1525               .setPageToken("pageToken873572522")
1526               .build();
1527       client.listLocations(request);
1528       Assert.fail("No exception raised");
1529     } catch (InvalidArgumentException e) {
1530       // Expected exception.
1531     }
1532   }
1533 
1534   @Test
getLocationTest()1535   public void getLocationTest() throws Exception {
1536     Location expectedResponse =
1537         Location.newBuilder()
1538             .setName("name3373707")
1539             .setLocationId("locationId1541836720")
1540             .setDisplayName("displayName1714148973")
1541             .putAllLabels(new HashMap<String, String>())
1542             .setMetadata(Any.newBuilder().build())
1543             .build();
1544     mockService.addResponse(expectedResponse);
1545 
1546     GetLocationRequest request =
1547         GetLocationRequest.newBuilder()
1548             .setName("projects/project-9062/locations/location-9062")
1549             .build();
1550 
1551     Location actualResponse = client.getLocation(request);
1552     Assert.assertEquals(expectedResponse, actualResponse);
1553 
1554     List<String> actualRequests = mockService.getRequestPaths();
1555     Assert.assertEquals(1, actualRequests.size());
1556 
1557     String apiClientHeaderKey =
1558         mockService
1559             .getRequestHeaders()
1560             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1561             .iterator()
1562             .next();
1563     Assert.assertTrue(
1564         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1565             .matcher(apiClientHeaderKey)
1566             .matches());
1567   }
1568 
1569   @Test
getLocationExceptionTest()1570   public void getLocationExceptionTest() throws Exception {
1571     ApiException exception =
1572         ApiExceptionFactory.createException(
1573             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1574     mockService.addException(exception);
1575 
1576     try {
1577       GetLocationRequest request =
1578           GetLocationRequest.newBuilder()
1579               .setName("projects/project-9062/locations/location-9062")
1580               .build();
1581       client.getLocation(request);
1582       Assert.fail("No exception raised");
1583     } catch (InvalidArgumentException e) {
1584       // Expected exception.
1585     }
1586   }
1587 }
1588