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