• 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.v1beta1;
18 
19 import static com.google.cloud.redis.v1beta1.CloudRedisClient.ListInstancesPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.grpc.GaxGrpcProperties;
23 import com.google.api.gax.grpc.testing.LocalChannelProvider;
24 import com.google.api.gax.grpc.testing.MockGrpcService;
25 import com.google.api.gax.grpc.testing.MockServiceHelper;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Timestamp;
36 import io.grpc.StatusRuntimeException;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.HashMap;
41 import java.util.List;
42 import java.util.UUID;
43 import java.util.concurrent.ExecutionException;
44 import javax.annotation.Generated;
45 import org.junit.After;
46 import org.junit.AfterClass;
47 import org.junit.Assert;
48 import org.junit.Before;
49 import org.junit.BeforeClass;
50 import org.junit.Test;
51 
52 @Generated("by gapic-generator-java")
53 public class CloudRedisClientTest {
54   private static MockCloudRedis mockCloudRedis;
55   private static MockServiceHelper mockServiceHelper;
56   private LocalChannelProvider channelProvider;
57   private CloudRedisClient client;
58 
59   @BeforeClass
startStaticServer()60   public static void startStaticServer() {
61     mockCloudRedis = new MockCloudRedis();
62     mockServiceHelper =
63         new MockServiceHelper(
64             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockCloudRedis));
65     mockServiceHelper.start();
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     mockServiceHelper.stop();
71   }
72 
73   @Before
setUp()74   public void setUp() throws IOException {
75     mockServiceHelper.reset();
76     channelProvider = mockServiceHelper.createChannelProvider();
77     CloudRedisSettings settings =
78         CloudRedisSettings.newBuilder()
79             .setTransportChannelProvider(channelProvider)
80             .setCredentialsProvider(NoCredentialsProvider.create())
81             .build();
82     client = CloudRedisClient.create(settings);
83   }
84 
85   @After
tearDown()86   public void tearDown() throws Exception {
87     client.close();
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     mockCloudRedis.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<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
110     Assert.assertEquals(1, actualRequests.size());
111     ListInstancesRequest actualRequest = ((ListInstancesRequest) actualRequests.get(0));
112 
113     Assert.assertEquals(parent.toString(), actualRequest.getParent());
114     Assert.assertTrue(
115         channelProvider.isHeaderSent(
116             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
117             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
118   }
119 
120   @Test
listInstancesExceptionTest()121   public void listInstancesExceptionTest() throws Exception {
122     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
123     mockCloudRedis.addException(exception);
124 
125     try {
126       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
127       client.listInstances(parent);
128       Assert.fail("No exception raised");
129     } catch (InvalidArgumentException e) {
130       // Expected exception.
131     }
132   }
133 
134   @Test
listInstancesTest2()135   public void listInstancesTest2() throws Exception {
136     Instance responsesElement = Instance.newBuilder().build();
137     ListInstancesResponse expectedResponse =
138         ListInstancesResponse.newBuilder()
139             .setNextPageToken("")
140             .addAllInstances(Arrays.asList(responsesElement))
141             .build();
142     mockCloudRedis.addResponse(expectedResponse);
143 
144     String parent = "parent-995424086";
145 
146     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
147 
148     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
149 
150     Assert.assertEquals(1, resources.size());
151     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
152 
153     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
154     Assert.assertEquals(1, actualRequests.size());
155     ListInstancesRequest actualRequest = ((ListInstancesRequest) actualRequests.get(0));
156 
157     Assert.assertEquals(parent, actualRequest.getParent());
158     Assert.assertTrue(
159         channelProvider.isHeaderSent(
160             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
161             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
162   }
163 
164   @Test
listInstancesExceptionTest2()165   public void listInstancesExceptionTest2() throws Exception {
166     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
167     mockCloudRedis.addException(exception);
168 
169     try {
170       String parent = "parent-995424086";
171       client.listInstances(parent);
172       Assert.fail("No exception raised");
173     } catch (InvalidArgumentException e) {
174       // Expected exception.
175     }
176   }
177 
178   @Test
getInstanceTest()179   public void getInstanceTest() throws Exception {
180     Instance expectedResponse =
181         Instance.newBuilder()
182             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
183             .setDisplayName("displayName1714148973")
184             .putAllLabels(new HashMap<String, String>())
185             .setLocationId("locationId1541836720")
186             .setAlternativeLocationId("alternativeLocationId1787141949")
187             .setRedisVersion("redisVersion-1972584739")
188             .setReservedIpRange("reservedIpRange575015950")
189             .setSecondaryIpRange("secondaryIpRange-1937131454")
190             .setHost("host3208616")
191             .setPort(3446913)
192             .setCurrentLocationId("currentLocationId-1808505335")
193             .setCreateTime(Timestamp.newBuilder().build())
194             .setStatusMessage("statusMessage-958704715")
195             .putAllRedisConfigs(new HashMap<String, String>())
196             .setMemorySizeGb(34199707)
197             .setAuthorizedNetwork("authorizedNetwork1515554835")
198             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
199             .setAuthEnabled(true)
200             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
201             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
202             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
203             .setReplicaCount(564075208)
204             .addAllNodes(new ArrayList<NodeInfo>())
205             .setReadEndpoint("readEndpoint294053195")
206             .setReadEndpointPort(-1676143102)
207             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
208             .build();
209     mockCloudRedis.addResponse(expectedResponse);
210 
211     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
212 
213     Instance actualResponse = client.getInstance(name);
214     Assert.assertEquals(expectedResponse, actualResponse);
215 
216     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
217     Assert.assertEquals(1, actualRequests.size());
218     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
219 
220     Assert.assertEquals(name.toString(), actualRequest.getName());
221     Assert.assertTrue(
222         channelProvider.isHeaderSent(
223             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
224             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
225   }
226 
227   @Test
getInstanceExceptionTest()228   public void getInstanceExceptionTest() throws Exception {
229     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
230     mockCloudRedis.addException(exception);
231 
232     try {
233       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
234       client.getInstance(name);
235       Assert.fail("No exception raised");
236     } catch (InvalidArgumentException e) {
237       // Expected exception.
238     }
239   }
240 
241   @Test
getInstanceTest2()242   public void getInstanceTest2() throws Exception {
243     Instance expectedResponse =
244         Instance.newBuilder()
245             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
246             .setDisplayName("displayName1714148973")
247             .putAllLabels(new HashMap<String, String>())
248             .setLocationId("locationId1541836720")
249             .setAlternativeLocationId("alternativeLocationId1787141949")
250             .setRedisVersion("redisVersion-1972584739")
251             .setReservedIpRange("reservedIpRange575015950")
252             .setSecondaryIpRange("secondaryIpRange-1937131454")
253             .setHost("host3208616")
254             .setPort(3446913)
255             .setCurrentLocationId("currentLocationId-1808505335")
256             .setCreateTime(Timestamp.newBuilder().build())
257             .setStatusMessage("statusMessage-958704715")
258             .putAllRedisConfigs(new HashMap<String, String>())
259             .setMemorySizeGb(34199707)
260             .setAuthorizedNetwork("authorizedNetwork1515554835")
261             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
262             .setAuthEnabled(true)
263             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
264             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
265             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
266             .setReplicaCount(564075208)
267             .addAllNodes(new ArrayList<NodeInfo>())
268             .setReadEndpoint("readEndpoint294053195")
269             .setReadEndpointPort(-1676143102)
270             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
271             .build();
272     mockCloudRedis.addResponse(expectedResponse);
273 
274     String name = "name3373707";
275 
276     Instance actualResponse = client.getInstance(name);
277     Assert.assertEquals(expectedResponse, actualResponse);
278 
279     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
280     Assert.assertEquals(1, actualRequests.size());
281     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
282 
283     Assert.assertEquals(name, actualRequest.getName());
284     Assert.assertTrue(
285         channelProvider.isHeaderSent(
286             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
287             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
288   }
289 
290   @Test
getInstanceExceptionTest2()291   public void getInstanceExceptionTest2() throws Exception {
292     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
293     mockCloudRedis.addException(exception);
294 
295     try {
296       String name = "name3373707";
297       client.getInstance(name);
298       Assert.fail("No exception raised");
299     } catch (InvalidArgumentException e) {
300       // Expected exception.
301     }
302   }
303 
304   @Test
getInstanceAuthStringTest()305   public void getInstanceAuthStringTest() throws Exception {
306     InstanceAuthString expectedResponse =
307         InstanceAuthString.newBuilder().setAuthString("authString1994738649").build();
308     mockCloudRedis.addResponse(expectedResponse);
309 
310     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
311 
312     InstanceAuthString actualResponse = client.getInstanceAuthString(name);
313     Assert.assertEquals(expectedResponse, actualResponse);
314 
315     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
316     Assert.assertEquals(1, actualRequests.size());
317     GetInstanceAuthStringRequest actualRequest =
318         ((GetInstanceAuthStringRequest) actualRequests.get(0));
319 
320     Assert.assertEquals(name.toString(), actualRequest.getName());
321     Assert.assertTrue(
322         channelProvider.isHeaderSent(
323             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
324             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
325   }
326 
327   @Test
getInstanceAuthStringExceptionTest()328   public void getInstanceAuthStringExceptionTest() throws Exception {
329     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
330     mockCloudRedis.addException(exception);
331 
332     try {
333       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
334       client.getInstanceAuthString(name);
335       Assert.fail("No exception raised");
336     } catch (InvalidArgumentException e) {
337       // Expected exception.
338     }
339   }
340 
341   @Test
getInstanceAuthStringTest2()342   public void getInstanceAuthStringTest2() throws Exception {
343     InstanceAuthString expectedResponse =
344         InstanceAuthString.newBuilder().setAuthString("authString1994738649").build();
345     mockCloudRedis.addResponse(expectedResponse);
346 
347     String name = "name3373707";
348 
349     InstanceAuthString actualResponse = client.getInstanceAuthString(name);
350     Assert.assertEquals(expectedResponse, actualResponse);
351 
352     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
353     Assert.assertEquals(1, actualRequests.size());
354     GetInstanceAuthStringRequest actualRequest =
355         ((GetInstanceAuthStringRequest) actualRequests.get(0));
356 
357     Assert.assertEquals(name, actualRequest.getName());
358     Assert.assertTrue(
359         channelProvider.isHeaderSent(
360             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
361             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
362   }
363 
364   @Test
getInstanceAuthStringExceptionTest2()365   public void getInstanceAuthStringExceptionTest2() throws Exception {
366     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
367     mockCloudRedis.addException(exception);
368 
369     try {
370       String name = "name3373707";
371       client.getInstanceAuthString(name);
372       Assert.fail("No exception raised");
373     } catch (InvalidArgumentException e) {
374       // Expected exception.
375     }
376   }
377 
378   @Test
createInstanceTest()379   public void createInstanceTest() throws Exception {
380     Instance expectedResponse =
381         Instance.newBuilder()
382             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
383             .setDisplayName("displayName1714148973")
384             .putAllLabels(new HashMap<String, String>())
385             .setLocationId("locationId1541836720")
386             .setAlternativeLocationId("alternativeLocationId1787141949")
387             .setRedisVersion("redisVersion-1972584739")
388             .setReservedIpRange("reservedIpRange575015950")
389             .setSecondaryIpRange("secondaryIpRange-1937131454")
390             .setHost("host3208616")
391             .setPort(3446913)
392             .setCurrentLocationId("currentLocationId-1808505335")
393             .setCreateTime(Timestamp.newBuilder().build())
394             .setStatusMessage("statusMessage-958704715")
395             .putAllRedisConfigs(new HashMap<String, String>())
396             .setMemorySizeGb(34199707)
397             .setAuthorizedNetwork("authorizedNetwork1515554835")
398             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
399             .setAuthEnabled(true)
400             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
401             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
402             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
403             .setReplicaCount(564075208)
404             .addAllNodes(new ArrayList<NodeInfo>())
405             .setReadEndpoint("readEndpoint294053195")
406             .setReadEndpointPort(-1676143102)
407             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
408             .build();
409     Operation resultOperation =
410         Operation.newBuilder()
411             .setName("createInstanceTest")
412             .setDone(true)
413             .setResponse(Any.pack(expectedResponse))
414             .build();
415     mockCloudRedis.addResponse(resultOperation);
416 
417     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
418     String instanceId = "instanceId902024336";
419     Instance instance = Instance.newBuilder().build();
420 
421     Instance actualResponse = client.createInstanceAsync(parent, instanceId, instance).get();
422     Assert.assertEquals(expectedResponse, actualResponse);
423 
424     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
425     Assert.assertEquals(1, actualRequests.size());
426     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
427 
428     Assert.assertEquals(parent.toString(), actualRequest.getParent());
429     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
430     Assert.assertEquals(instance, actualRequest.getInstance());
431     Assert.assertTrue(
432         channelProvider.isHeaderSent(
433             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
434             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
435   }
436 
437   @Test
createInstanceExceptionTest()438   public void createInstanceExceptionTest() throws Exception {
439     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
440     mockCloudRedis.addException(exception);
441 
442     try {
443       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
444       String instanceId = "instanceId902024336";
445       Instance instance = Instance.newBuilder().build();
446       client.createInstanceAsync(parent, instanceId, instance).get();
447       Assert.fail("No exception raised");
448     } catch (ExecutionException e) {
449       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
450       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
451       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
452     }
453   }
454 
455   @Test
createInstanceTest2()456   public void createInstanceTest2() throws Exception {
457     Instance expectedResponse =
458         Instance.newBuilder()
459             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
460             .setDisplayName("displayName1714148973")
461             .putAllLabels(new HashMap<String, String>())
462             .setLocationId("locationId1541836720")
463             .setAlternativeLocationId("alternativeLocationId1787141949")
464             .setRedisVersion("redisVersion-1972584739")
465             .setReservedIpRange("reservedIpRange575015950")
466             .setSecondaryIpRange("secondaryIpRange-1937131454")
467             .setHost("host3208616")
468             .setPort(3446913)
469             .setCurrentLocationId("currentLocationId-1808505335")
470             .setCreateTime(Timestamp.newBuilder().build())
471             .setStatusMessage("statusMessage-958704715")
472             .putAllRedisConfigs(new HashMap<String, String>())
473             .setMemorySizeGb(34199707)
474             .setAuthorizedNetwork("authorizedNetwork1515554835")
475             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
476             .setAuthEnabled(true)
477             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
478             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
479             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
480             .setReplicaCount(564075208)
481             .addAllNodes(new ArrayList<NodeInfo>())
482             .setReadEndpoint("readEndpoint294053195")
483             .setReadEndpointPort(-1676143102)
484             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
485             .build();
486     Operation resultOperation =
487         Operation.newBuilder()
488             .setName("createInstanceTest")
489             .setDone(true)
490             .setResponse(Any.pack(expectedResponse))
491             .build();
492     mockCloudRedis.addResponse(resultOperation);
493 
494     String parent = "parent-995424086";
495     String instanceId = "instanceId902024336";
496     Instance instance = Instance.newBuilder().build();
497 
498     Instance actualResponse = client.createInstanceAsync(parent, instanceId, instance).get();
499     Assert.assertEquals(expectedResponse, actualResponse);
500 
501     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
502     Assert.assertEquals(1, actualRequests.size());
503     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
504 
505     Assert.assertEquals(parent, actualRequest.getParent());
506     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
507     Assert.assertEquals(instance, actualRequest.getInstance());
508     Assert.assertTrue(
509         channelProvider.isHeaderSent(
510             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
511             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
512   }
513 
514   @Test
createInstanceExceptionTest2()515   public void createInstanceExceptionTest2() throws Exception {
516     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
517     mockCloudRedis.addException(exception);
518 
519     try {
520       String parent = "parent-995424086";
521       String instanceId = "instanceId902024336";
522       Instance instance = Instance.newBuilder().build();
523       client.createInstanceAsync(parent, instanceId, instance).get();
524       Assert.fail("No exception raised");
525     } catch (ExecutionException e) {
526       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
527       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
528       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
529     }
530   }
531 
532   @Test
updateInstanceTest()533   public void updateInstanceTest() throws Exception {
534     Instance expectedResponse =
535         Instance.newBuilder()
536             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
537             .setDisplayName("displayName1714148973")
538             .putAllLabels(new HashMap<String, String>())
539             .setLocationId("locationId1541836720")
540             .setAlternativeLocationId("alternativeLocationId1787141949")
541             .setRedisVersion("redisVersion-1972584739")
542             .setReservedIpRange("reservedIpRange575015950")
543             .setSecondaryIpRange("secondaryIpRange-1937131454")
544             .setHost("host3208616")
545             .setPort(3446913)
546             .setCurrentLocationId("currentLocationId-1808505335")
547             .setCreateTime(Timestamp.newBuilder().build())
548             .setStatusMessage("statusMessage-958704715")
549             .putAllRedisConfigs(new HashMap<String, String>())
550             .setMemorySizeGb(34199707)
551             .setAuthorizedNetwork("authorizedNetwork1515554835")
552             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
553             .setAuthEnabled(true)
554             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
555             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
556             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
557             .setReplicaCount(564075208)
558             .addAllNodes(new ArrayList<NodeInfo>())
559             .setReadEndpoint("readEndpoint294053195")
560             .setReadEndpointPort(-1676143102)
561             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
562             .build();
563     Operation resultOperation =
564         Operation.newBuilder()
565             .setName("updateInstanceTest")
566             .setDone(true)
567             .setResponse(Any.pack(expectedResponse))
568             .build();
569     mockCloudRedis.addResponse(resultOperation);
570 
571     FieldMask updateMask = FieldMask.newBuilder().build();
572     Instance instance = Instance.newBuilder().build();
573 
574     Instance actualResponse = client.updateInstanceAsync(updateMask, instance).get();
575     Assert.assertEquals(expectedResponse, actualResponse);
576 
577     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
578     Assert.assertEquals(1, actualRequests.size());
579     UpdateInstanceRequest actualRequest = ((UpdateInstanceRequest) actualRequests.get(0));
580 
581     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
582     Assert.assertEquals(instance, actualRequest.getInstance());
583     Assert.assertTrue(
584         channelProvider.isHeaderSent(
585             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
586             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
587   }
588 
589   @Test
updateInstanceExceptionTest()590   public void updateInstanceExceptionTest() throws Exception {
591     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
592     mockCloudRedis.addException(exception);
593 
594     try {
595       FieldMask updateMask = FieldMask.newBuilder().build();
596       Instance instance = Instance.newBuilder().build();
597       client.updateInstanceAsync(updateMask, instance).get();
598       Assert.fail("No exception raised");
599     } catch (ExecutionException e) {
600       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
601       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
602       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
603     }
604   }
605 
606   @Test
upgradeInstanceTest()607   public void upgradeInstanceTest() throws Exception {
608     Instance expectedResponse =
609         Instance.newBuilder()
610             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
611             .setDisplayName("displayName1714148973")
612             .putAllLabels(new HashMap<String, String>())
613             .setLocationId("locationId1541836720")
614             .setAlternativeLocationId("alternativeLocationId1787141949")
615             .setRedisVersion("redisVersion-1972584739")
616             .setReservedIpRange("reservedIpRange575015950")
617             .setSecondaryIpRange("secondaryIpRange-1937131454")
618             .setHost("host3208616")
619             .setPort(3446913)
620             .setCurrentLocationId("currentLocationId-1808505335")
621             .setCreateTime(Timestamp.newBuilder().build())
622             .setStatusMessage("statusMessage-958704715")
623             .putAllRedisConfigs(new HashMap<String, String>())
624             .setMemorySizeGb(34199707)
625             .setAuthorizedNetwork("authorizedNetwork1515554835")
626             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
627             .setAuthEnabled(true)
628             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
629             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
630             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
631             .setReplicaCount(564075208)
632             .addAllNodes(new ArrayList<NodeInfo>())
633             .setReadEndpoint("readEndpoint294053195")
634             .setReadEndpointPort(-1676143102)
635             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
636             .build();
637     Operation resultOperation =
638         Operation.newBuilder()
639             .setName("upgradeInstanceTest")
640             .setDone(true)
641             .setResponse(Any.pack(expectedResponse))
642             .build();
643     mockCloudRedis.addResponse(resultOperation);
644 
645     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
646     String redisVersion = "redisVersion-1972584739";
647 
648     Instance actualResponse = client.upgradeInstanceAsync(name, redisVersion).get();
649     Assert.assertEquals(expectedResponse, actualResponse);
650 
651     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
652     Assert.assertEquals(1, actualRequests.size());
653     UpgradeInstanceRequest actualRequest = ((UpgradeInstanceRequest) actualRequests.get(0));
654 
655     Assert.assertEquals(name.toString(), actualRequest.getName());
656     Assert.assertEquals(redisVersion, actualRequest.getRedisVersion());
657     Assert.assertTrue(
658         channelProvider.isHeaderSent(
659             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
660             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
661   }
662 
663   @Test
upgradeInstanceExceptionTest()664   public void upgradeInstanceExceptionTest() throws Exception {
665     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
666     mockCloudRedis.addException(exception);
667 
668     try {
669       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
670       String redisVersion = "redisVersion-1972584739";
671       client.upgradeInstanceAsync(name, redisVersion).get();
672       Assert.fail("No exception raised");
673     } catch (ExecutionException e) {
674       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
675       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
676       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
677     }
678   }
679 
680   @Test
upgradeInstanceTest2()681   public void upgradeInstanceTest2() throws Exception {
682     Instance expectedResponse =
683         Instance.newBuilder()
684             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
685             .setDisplayName("displayName1714148973")
686             .putAllLabels(new HashMap<String, String>())
687             .setLocationId("locationId1541836720")
688             .setAlternativeLocationId("alternativeLocationId1787141949")
689             .setRedisVersion("redisVersion-1972584739")
690             .setReservedIpRange("reservedIpRange575015950")
691             .setSecondaryIpRange("secondaryIpRange-1937131454")
692             .setHost("host3208616")
693             .setPort(3446913)
694             .setCurrentLocationId("currentLocationId-1808505335")
695             .setCreateTime(Timestamp.newBuilder().build())
696             .setStatusMessage("statusMessage-958704715")
697             .putAllRedisConfigs(new HashMap<String, String>())
698             .setMemorySizeGb(34199707)
699             .setAuthorizedNetwork("authorizedNetwork1515554835")
700             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
701             .setAuthEnabled(true)
702             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
703             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
704             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
705             .setReplicaCount(564075208)
706             .addAllNodes(new ArrayList<NodeInfo>())
707             .setReadEndpoint("readEndpoint294053195")
708             .setReadEndpointPort(-1676143102)
709             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
710             .build();
711     Operation resultOperation =
712         Operation.newBuilder()
713             .setName("upgradeInstanceTest")
714             .setDone(true)
715             .setResponse(Any.pack(expectedResponse))
716             .build();
717     mockCloudRedis.addResponse(resultOperation);
718 
719     String name = "name3373707";
720     String redisVersion = "redisVersion-1972584739";
721 
722     Instance actualResponse = client.upgradeInstanceAsync(name, redisVersion).get();
723     Assert.assertEquals(expectedResponse, actualResponse);
724 
725     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
726     Assert.assertEquals(1, actualRequests.size());
727     UpgradeInstanceRequest actualRequest = ((UpgradeInstanceRequest) actualRequests.get(0));
728 
729     Assert.assertEquals(name, actualRequest.getName());
730     Assert.assertEquals(redisVersion, actualRequest.getRedisVersion());
731     Assert.assertTrue(
732         channelProvider.isHeaderSent(
733             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
734             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
735   }
736 
737   @Test
upgradeInstanceExceptionTest2()738   public void upgradeInstanceExceptionTest2() throws Exception {
739     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
740     mockCloudRedis.addException(exception);
741 
742     try {
743       String name = "name3373707";
744       String redisVersion = "redisVersion-1972584739";
745       client.upgradeInstanceAsync(name, redisVersion).get();
746       Assert.fail("No exception raised");
747     } catch (ExecutionException e) {
748       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
749       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
750       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
751     }
752   }
753 
754   @Test
importInstanceTest()755   public void importInstanceTest() throws Exception {
756     Instance expectedResponse =
757         Instance.newBuilder()
758             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
759             .setDisplayName("displayName1714148973")
760             .putAllLabels(new HashMap<String, String>())
761             .setLocationId("locationId1541836720")
762             .setAlternativeLocationId("alternativeLocationId1787141949")
763             .setRedisVersion("redisVersion-1972584739")
764             .setReservedIpRange("reservedIpRange575015950")
765             .setSecondaryIpRange("secondaryIpRange-1937131454")
766             .setHost("host3208616")
767             .setPort(3446913)
768             .setCurrentLocationId("currentLocationId-1808505335")
769             .setCreateTime(Timestamp.newBuilder().build())
770             .setStatusMessage("statusMessage-958704715")
771             .putAllRedisConfigs(new HashMap<String, String>())
772             .setMemorySizeGb(34199707)
773             .setAuthorizedNetwork("authorizedNetwork1515554835")
774             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
775             .setAuthEnabled(true)
776             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
777             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
778             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
779             .setReplicaCount(564075208)
780             .addAllNodes(new ArrayList<NodeInfo>())
781             .setReadEndpoint("readEndpoint294053195")
782             .setReadEndpointPort(-1676143102)
783             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
784             .build();
785     Operation resultOperation =
786         Operation.newBuilder()
787             .setName("importInstanceTest")
788             .setDone(true)
789             .setResponse(Any.pack(expectedResponse))
790             .build();
791     mockCloudRedis.addResponse(resultOperation);
792 
793     String name = "name3373707";
794     InputConfig inputConfig = InputConfig.newBuilder().build();
795 
796     Instance actualResponse = client.importInstanceAsync(name, inputConfig).get();
797     Assert.assertEquals(expectedResponse, actualResponse);
798 
799     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
800     Assert.assertEquals(1, actualRequests.size());
801     ImportInstanceRequest actualRequest = ((ImportInstanceRequest) actualRequests.get(0));
802 
803     Assert.assertEquals(name, actualRequest.getName());
804     Assert.assertEquals(inputConfig, actualRequest.getInputConfig());
805     Assert.assertTrue(
806         channelProvider.isHeaderSent(
807             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
808             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
809   }
810 
811   @Test
importInstanceExceptionTest()812   public void importInstanceExceptionTest() throws Exception {
813     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
814     mockCloudRedis.addException(exception);
815 
816     try {
817       String name = "name3373707";
818       InputConfig inputConfig = InputConfig.newBuilder().build();
819       client.importInstanceAsync(name, inputConfig).get();
820       Assert.fail("No exception raised");
821     } catch (ExecutionException e) {
822       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
823       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
824       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
825     }
826   }
827 
828   @Test
exportInstanceTest()829   public void exportInstanceTest() throws Exception {
830     Instance expectedResponse =
831         Instance.newBuilder()
832             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
833             .setDisplayName("displayName1714148973")
834             .putAllLabels(new HashMap<String, String>())
835             .setLocationId("locationId1541836720")
836             .setAlternativeLocationId("alternativeLocationId1787141949")
837             .setRedisVersion("redisVersion-1972584739")
838             .setReservedIpRange("reservedIpRange575015950")
839             .setSecondaryIpRange("secondaryIpRange-1937131454")
840             .setHost("host3208616")
841             .setPort(3446913)
842             .setCurrentLocationId("currentLocationId-1808505335")
843             .setCreateTime(Timestamp.newBuilder().build())
844             .setStatusMessage("statusMessage-958704715")
845             .putAllRedisConfigs(new HashMap<String, String>())
846             .setMemorySizeGb(34199707)
847             .setAuthorizedNetwork("authorizedNetwork1515554835")
848             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
849             .setAuthEnabled(true)
850             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
851             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
852             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
853             .setReplicaCount(564075208)
854             .addAllNodes(new ArrayList<NodeInfo>())
855             .setReadEndpoint("readEndpoint294053195")
856             .setReadEndpointPort(-1676143102)
857             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
858             .build();
859     Operation resultOperation =
860         Operation.newBuilder()
861             .setName("exportInstanceTest")
862             .setDone(true)
863             .setResponse(Any.pack(expectedResponse))
864             .build();
865     mockCloudRedis.addResponse(resultOperation);
866 
867     String name = "name3373707";
868     OutputConfig outputConfig = OutputConfig.newBuilder().build();
869 
870     Instance actualResponse = client.exportInstanceAsync(name, outputConfig).get();
871     Assert.assertEquals(expectedResponse, actualResponse);
872 
873     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
874     Assert.assertEquals(1, actualRequests.size());
875     ExportInstanceRequest actualRequest = ((ExportInstanceRequest) actualRequests.get(0));
876 
877     Assert.assertEquals(name, actualRequest.getName());
878     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
879     Assert.assertTrue(
880         channelProvider.isHeaderSent(
881             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
882             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
883   }
884 
885   @Test
exportInstanceExceptionTest()886   public void exportInstanceExceptionTest() throws Exception {
887     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
888     mockCloudRedis.addException(exception);
889 
890     try {
891       String name = "name3373707";
892       OutputConfig outputConfig = OutputConfig.newBuilder().build();
893       client.exportInstanceAsync(name, outputConfig).get();
894       Assert.fail("No exception raised");
895     } catch (ExecutionException e) {
896       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
897       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
898       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
899     }
900   }
901 
902   @Test
failoverInstanceTest()903   public void failoverInstanceTest() throws Exception {
904     Instance expectedResponse =
905         Instance.newBuilder()
906             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
907             .setDisplayName("displayName1714148973")
908             .putAllLabels(new HashMap<String, String>())
909             .setLocationId("locationId1541836720")
910             .setAlternativeLocationId("alternativeLocationId1787141949")
911             .setRedisVersion("redisVersion-1972584739")
912             .setReservedIpRange("reservedIpRange575015950")
913             .setSecondaryIpRange("secondaryIpRange-1937131454")
914             .setHost("host3208616")
915             .setPort(3446913)
916             .setCurrentLocationId("currentLocationId-1808505335")
917             .setCreateTime(Timestamp.newBuilder().build())
918             .setStatusMessage("statusMessage-958704715")
919             .putAllRedisConfigs(new HashMap<String, String>())
920             .setMemorySizeGb(34199707)
921             .setAuthorizedNetwork("authorizedNetwork1515554835")
922             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
923             .setAuthEnabled(true)
924             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
925             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
926             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
927             .setReplicaCount(564075208)
928             .addAllNodes(new ArrayList<NodeInfo>())
929             .setReadEndpoint("readEndpoint294053195")
930             .setReadEndpointPort(-1676143102)
931             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
932             .build();
933     Operation resultOperation =
934         Operation.newBuilder()
935             .setName("failoverInstanceTest")
936             .setDone(true)
937             .setResponse(Any.pack(expectedResponse))
938             .build();
939     mockCloudRedis.addResponse(resultOperation);
940 
941     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
942     FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
943         FailoverInstanceRequest.DataProtectionMode.forNumber(0);
944 
945     Instance actualResponse = client.failoverInstanceAsync(name, dataProtectionMode).get();
946     Assert.assertEquals(expectedResponse, actualResponse);
947 
948     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
949     Assert.assertEquals(1, actualRequests.size());
950     FailoverInstanceRequest actualRequest = ((FailoverInstanceRequest) actualRequests.get(0));
951 
952     Assert.assertEquals(name.toString(), actualRequest.getName());
953     Assert.assertEquals(dataProtectionMode, actualRequest.getDataProtectionMode());
954     Assert.assertTrue(
955         channelProvider.isHeaderSent(
956             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
957             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
958   }
959 
960   @Test
failoverInstanceExceptionTest()961   public void failoverInstanceExceptionTest() throws Exception {
962     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
963     mockCloudRedis.addException(exception);
964 
965     try {
966       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
967       FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
968           FailoverInstanceRequest.DataProtectionMode.forNumber(0);
969       client.failoverInstanceAsync(name, dataProtectionMode).get();
970       Assert.fail("No exception raised");
971     } catch (ExecutionException e) {
972       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
973       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
974       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
975     }
976   }
977 
978   @Test
failoverInstanceTest2()979   public void failoverInstanceTest2() throws Exception {
980     Instance expectedResponse =
981         Instance.newBuilder()
982             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
983             .setDisplayName("displayName1714148973")
984             .putAllLabels(new HashMap<String, String>())
985             .setLocationId("locationId1541836720")
986             .setAlternativeLocationId("alternativeLocationId1787141949")
987             .setRedisVersion("redisVersion-1972584739")
988             .setReservedIpRange("reservedIpRange575015950")
989             .setSecondaryIpRange("secondaryIpRange-1937131454")
990             .setHost("host3208616")
991             .setPort(3446913)
992             .setCurrentLocationId("currentLocationId-1808505335")
993             .setCreateTime(Timestamp.newBuilder().build())
994             .setStatusMessage("statusMessage-958704715")
995             .putAllRedisConfigs(new HashMap<String, String>())
996             .setMemorySizeGb(34199707)
997             .setAuthorizedNetwork("authorizedNetwork1515554835")
998             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
999             .setAuthEnabled(true)
1000             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1001             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1002             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1003             .setReplicaCount(564075208)
1004             .addAllNodes(new ArrayList<NodeInfo>())
1005             .setReadEndpoint("readEndpoint294053195")
1006             .setReadEndpointPort(-1676143102)
1007             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1008             .build();
1009     Operation resultOperation =
1010         Operation.newBuilder()
1011             .setName("failoverInstanceTest")
1012             .setDone(true)
1013             .setResponse(Any.pack(expectedResponse))
1014             .build();
1015     mockCloudRedis.addResponse(resultOperation);
1016 
1017     String name = "name3373707";
1018     FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1019         FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1020 
1021     Instance actualResponse = client.failoverInstanceAsync(name, dataProtectionMode).get();
1022     Assert.assertEquals(expectedResponse, actualResponse);
1023 
1024     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
1025     Assert.assertEquals(1, actualRequests.size());
1026     FailoverInstanceRequest actualRequest = ((FailoverInstanceRequest) actualRequests.get(0));
1027 
1028     Assert.assertEquals(name, actualRequest.getName());
1029     Assert.assertEquals(dataProtectionMode, actualRequest.getDataProtectionMode());
1030     Assert.assertTrue(
1031         channelProvider.isHeaderSent(
1032             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1033             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1034   }
1035 
1036   @Test
failoverInstanceExceptionTest2()1037   public void failoverInstanceExceptionTest2() throws Exception {
1038     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1039     mockCloudRedis.addException(exception);
1040 
1041     try {
1042       String name = "name3373707";
1043       FailoverInstanceRequest.DataProtectionMode dataProtectionMode =
1044           FailoverInstanceRequest.DataProtectionMode.forNumber(0);
1045       client.failoverInstanceAsync(name, dataProtectionMode).get();
1046       Assert.fail("No exception raised");
1047     } catch (ExecutionException e) {
1048       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1049       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1050       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1051     }
1052   }
1053 
1054   @Test
deleteInstanceTest()1055   public void deleteInstanceTest() throws Exception {
1056     Empty expectedResponse = Empty.newBuilder().build();
1057     Operation resultOperation =
1058         Operation.newBuilder()
1059             .setName("deleteInstanceTest")
1060             .setDone(true)
1061             .setResponse(Any.pack(expectedResponse))
1062             .build();
1063     mockCloudRedis.addResponse(resultOperation);
1064 
1065     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1066 
1067     client.deleteInstanceAsync(name).get();
1068 
1069     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
1070     Assert.assertEquals(1, actualRequests.size());
1071     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
1072 
1073     Assert.assertEquals(name.toString(), actualRequest.getName());
1074     Assert.assertTrue(
1075         channelProvider.isHeaderSent(
1076             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1077             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1078   }
1079 
1080   @Test
deleteInstanceExceptionTest()1081   public void deleteInstanceExceptionTest() throws Exception {
1082     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1083     mockCloudRedis.addException(exception);
1084 
1085     try {
1086       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1087       client.deleteInstanceAsync(name).get();
1088       Assert.fail("No exception raised");
1089     } catch (ExecutionException e) {
1090       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1091       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1092       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1093     }
1094   }
1095 
1096   @Test
deleteInstanceTest2()1097   public void deleteInstanceTest2() throws Exception {
1098     Empty expectedResponse = Empty.newBuilder().build();
1099     Operation resultOperation =
1100         Operation.newBuilder()
1101             .setName("deleteInstanceTest")
1102             .setDone(true)
1103             .setResponse(Any.pack(expectedResponse))
1104             .build();
1105     mockCloudRedis.addResponse(resultOperation);
1106 
1107     String name = "name3373707";
1108 
1109     client.deleteInstanceAsync(name).get();
1110 
1111     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
1112     Assert.assertEquals(1, actualRequests.size());
1113     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
1114 
1115     Assert.assertEquals(name, actualRequest.getName());
1116     Assert.assertTrue(
1117         channelProvider.isHeaderSent(
1118             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1119             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1120   }
1121 
1122   @Test
deleteInstanceExceptionTest2()1123   public void deleteInstanceExceptionTest2() throws Exception {
1124     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1125     mockCloudRedis.addException(exception);
1126 
1127     try {
1128       String name = "name3373707";
1129       client.deleteInstanceAsync(name).get();
1130       Assert.fail("No exception raised");
1131     } catch (ExecutionException e) {
1132       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1133       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1134       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1135     }
1136   }
1137 
1138   @Test
rescheduleMaintenanceTest()1139   public void rescheduleMaintenanceTest() throws Exception {
1140     Instance expectedResponse =
1141         Instance.newBuilder()
1142             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1143             .setDisplayName("displayName1714148973")
1144             .putAllLabels(new HashMap<String, String>())
1145             .setLocationId("locationId1541836720")
1146             .setAlternativeLocationId("alternativeLocationId1787141949")
1147             .setRedisVersion("redisVersion-1972584739")
1148             .setReservedIpRange("reservedIpRange575015950")
1149             .setSecondaryIpRange("secondaryIpRange-1937131454")
1150             .setHost("host3208616")
1151             .setPort(3446913)
1152             .setCurrentLocationId("currentLocationId-1808505335")
1153             .setCreateTime(Timestamp.newBuilder().build())
1154             .setStatusMessage("statusMessage-958704715")
1155             .putAllRedisConfigs(new HashMap<String, String>())
1156             .setMemorySizeGb(34199707)
1157             .setAuthorizedNetwork("authorizedNetwork1515554835")
1158             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1159             .setAuthEnabled(true)
1160             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1161             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1162             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1163             .setReplicaCount(564075208)
1164             .addAllNodes(new ArrayList<NodeInfo>())
1165             .setReadEndpoint("readEndpoint294053195")
1166             .setReadEndpointPort(-1676143102)
1167             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1168             .build();
1169     Operation resultOperation =
1170         Operation.newBuilder()
1171             .setName("rescheduleMaintenanceTest")
1172             .setDone(true)
1173             .setResponse(Any.pack(expectedResponse))
1174             .build();
1175     mockCloudRedis.addResponse(resultOperation);
1176 
1177     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1178     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1179         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1180     Timestamp scheduleTime = Timestamp.newBuilder().build();
1181 
1182     Instance actualResponse =
1183         client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1184     Assert.assertEquals(expectedResponse, actualResponse);
1185 
1186     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
1187     Assert.assertEquals(1, actualRequests.size());
1188     RescheduleMaintenanceRequest actualRequest =
1189         ((RescheduleMaintenanceRequest) actualRequests.get(0));
1190 
1191     Assert.assertEquals(name.toString(), actualRequest.getName());
1192     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
1193     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
1194     Assert.assertTrue(
1195         channelProvider.isHeaderSent(
1196             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1197             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1198   }
1199 
1200   @Test
rescheduleMaintenanceExceptionTest()1201   public void rescheduleMaintenanceExceptionTest() throws Exception {
1202     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1203     mockCloudRedis.addException(exception);
1204 
1205     try {
1206       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1207       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1208           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1209       Timestamp scheduleTime = Timestamp.newBuilder().build();
1210       client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1211       Assert.fail("No exception raised");
1212     } catch (ExecutionException e) {
1213       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1214       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1215       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1216     }
1217   }
1218 
1219   @Test
rescheduleMaintenanceTest2()1220   public void rescheduleMaintenanceTest2() throws Exception {
1221     Instance expectedResponse =
1222         Instance.newBuilder()
1223             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1224             .setDisplayName("displayName1714148973")
1225             .putAllLabels(new HashMap<String, String>())
1226             .setLocationId("locationId1541836720")
1227             .setAlternativeLocationId("alternativeLocationId1787141949")
1228             .setRedisVersion("redisVersion-1972584739")
1229             .setReservedIpRange("reservedIpRange575015950")
1230             .setSecondaryIpRange("secondaryIpRange-1937131454")
1231             .setHost("host3208616")
1232             .setPort(3446913)
1233             .setCurrentLocationId("currentLocationId-1808505335")
1234             .setCreateTime(Timestamp.newBuilder().build())
1235             .setStatusMessage("statusMessage-958704715")
1236             .putAllRedisConfigs(new HashMap<String, String>())
1237             .setMemorySizeGb(34199707)
1238             .setAuthorizedNetwork("authorizedNetwork1515554835")
1239             .setPersistenceIamIdentity("persistenceIamIdentity1464017428")
1240             .setAuthEnabled(true)
1241             .addAllServerCaCerts(new ArrayList<TlsCertificate>())
1242             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1243             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1244             .setReplicaCount(564075208)
1245             .addAllNodes(new ArrayList<NodeInfo>())
1246             .setReadEndpoint("readEndpoint294053195")
1247             .setReadEndpointPort(-1676143102)
1248             .setPersistenceConfig(PersistenceConfig.newBuilder().build())
1249             .build();
1250     Operation resultOperation =
1251         Operation.newBuilder()
1252             .setName("rescheduleMaintenanceTest")
1253             .setDone(true)
1254             .setResponse(Any.pack(expectedResponse))
1255             .build();
1256     mockCloudRedis.addResponse(resultOperation);
1257 
1258     String name = "name3373707";
1259     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1260         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1261     Timestamp scheduleTime = Timestamp.newBuilder().build();
1262 
1263     Instance actualResponse =
1264         client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1265     Assert.assertEquals(expectedResponse, actualResponse);
1266 
1267     List<AbstractMessage> actualRequests = mockCloudRedis.getRequests();
1268     Assert.assertEquals(1, actualRequests.size());
1269     RescheduleMaintenanceRequest actualRequest =
1270         ((RescheduleMaintenanceRequest) actualRequests.get(0));
1271 
1272     Assert.assertEquals(name, actualRequest.getName());
1273     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
1274     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
1275     Assert.assertTrue(
1276         channelProvider.isHeaderSent(
1277             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1278             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1279   }
1280 
1281   @Test
rescheduleMaintenanceExceptionTest2()1282   public void rescheduleMaintenanceExceptionTest2() throws Exception {
1283     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1284     mockCloudRedis.addException(exception);
1285 
1286     try {
1287       String name = "name3373707";
1288       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1289           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1290       Timestamp scheduleTime = Timestamp.newBuilder().build();
1291       client.rescheduleMaintenanceAsync(name, rescheduleType, scheduleTime).get();
1292       Assert.fail("No exception raised");
1293     } catch (ExecutionException e) {
1294       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1295       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1296       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1297     }
1298   }
1299 }
1300