• 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.memcache.v1beta2;
18 
19 import static com.google.cloud.memcache.v1beta2.CloudMemcacheClient.ListInstancesPagedResponse;
20 import static com.google.cloud.memcache.v1beta2.CloudMemcacheClient.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 CloudMemcacheClientTest {
59   private static MockCloudMemcache mockCloudMemcache;
60   private static MockLocations mockLocations;
61   private static MockServiceHelper mockServiceHelper;
62   private LocalChannelProvider channelProvider;
63   private CloudMemcacheClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() {
67     mockCloudMemcache = new MockCloudMemcache();
68     mockLocations = new MockLocations();
69     mockServiceHelper =
70         new MockServiceHelper(
71             UUID.randomUUID().toString(),
72             Arrays.<MockGrpcService>asList(mockCloudMemcache, 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     CloudMemcacheSettings settings =
86         CloudMemcacheSettings.newBuilder()
87             .setTransportChannelProvider(channelProvider)
88             .setCredentialsProvider(NoCredentialsProvider.create())
89             .build();
90     client = CloudMemcacheClient.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             .addAllResources(Arrays.asList(responsesElement))
105             .build();
106     mockCloudMemcache.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.getResourcesList().get(0), resources.get(0));
116 
117     List<AbstractMessage> actualRequests = mockCloudMemcache.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     mockCloudMemcache.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             .addAllResources(Arrays.asList(responsesElement))
149             .build();
150     mockCloudMemcache.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.getResourcesList().get(0), resources.get(0));
160 
161     List<AbstractMessage> actualRequests = mockCloudMemcache.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     mockCloudMemcache.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             .setAuthorizedNetwork("authorizedNetwork1515554835")
194             .addAllZones(new ArrayList<String>())
195             .setNodeCount(1539922066)
196             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
197             .setMemcacheVersion(MemcacheVersion.forNumber(0))
198             .setParameters(MemcacheParameters.newBuilder().build())
199             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
200             .setCreateTime(Timestamp.newBuilder().build())
201             .setUpdateTime(Timestamp.newBuilder().build())
202             .setMemcacheFullVersion("memcacheFullVersion976507452")
203             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
204             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
205             .setUpdateAvailable(true)
206             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
207             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
208             .build();
209     mockCloudMemcache.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 = mockCloudMemcache.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     mockCloudMemcache.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             .setAuthorizedNetwork("authorizedNetwork1515554835")
249             .addAllZones(new ArrayList<String>())
250             .setNodeCount(1539922066)
251             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
252             .setMemcacheVersion(MemcacheVersion.forNumber(0))
253             .setParameters(MemcacheParameters.newBuilder().build())
254             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
255             .setCreateTime(Timestamp.newBuilder().build())
256             .setUpdateTime(Timestamp.newBuilder().build())
257             .setMemcacheFullVersion("memcacheFullVersion976507452")
258             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
259             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
260             .setUpdateAvailable(true)
261             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
262             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
263             .build();
264     mockCloudMemcache.addResponse(expectedResponse);
265 
266     String name = "name3373707";
267 
268     Instance actualResponse = client.getInstance(name);
269     Assert.assertEquals(expectedResponse, actualResponse);
270 
271     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
272     Assert.assertEquals(1, actualRequests.size());
273     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
274 
275     Assert.assertEquals(name, actualRequest.getName());
276     Assert.assertTrue(
277         channelProvider.isHeaderSent(
278             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
279             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
280   }
281 
282   @Test
getInstanceExceptionTest2()283   public void getInstanceExceptionTest2() throws Exception {
284     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
285     mockCloudMemcache.addException(exception);
286 
287     try {
288       String name = "name3373707";
289       client.getInstance(name);
290       Assert.fail("No exception raised");
291     } catch (InvalidArgumentException e) {
292       // Expected exception.
293     }
294   }
295 
296   @Test
createInstanceTest()297   public void createInstanceTest() throws Exception {
298     Instance expectedResponse =
299         Instance.newBuilder()
300             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
301             .setDisplayName("displayName1714148973")
302             .putAllLabels(new HashMap<String, String>())
303             .setAuthorizedNetwork("authorizedNetwork1515554835")
304             .addAllZones(new ArrayList<String>())
305             .setNodeCount(1539922066)
306             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
307             .setMemcacheVersion(MemcacheVersion.forNumber(0))
308             .setParameters(MemcacheParameters.newBuilder().build())
309             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
310             .setCreateTime(Timestamp.newBuilder().build())
311             .setUpdateTime(Timestamp.newBuilder().build())
312             .setMemcacheFullVersion("memcacheFullVersion976507452")
313             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
314             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
315             .setUpdateAvailable(true)
316             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
317             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
318             .build();
319     Operation resultOperation =
320         Operation.newBuilder()
321             .setName("createInstanceTest")
322             .setDone(true)
323             .setResponse(Any.pack(expectedResponse))
324             .build();
325     mockCloudMemcache.addResponse(resultOperation);
326 
327     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
328     String instanceId = "instanceId902024336";
329     Instance resource = Instance.newBuilder().build();
330 
331     Instance actualResponse = client.createInstanceAsync(parent, instanceId, resource).get();
332     Assert.assertEquals(expectedResponse, actualResponse);
333 
334     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
335     Assert.assertEquals(1, actualRequests.size());
336     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
337 
338     Assert.assertEquals(parent.toString(), actualRequest.getParent());
339     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
340     Assert.assertEquals(resource, actualRequest.getResource());
341     Assert.assertTrue(
342         channelProvider.isHeaderSent(
343             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
344             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
345   }
346 
347   @Test
createInstanceExceptionTest()348   public void createInstanceExceptionTest() throws Exception {
349     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
350     mockCloudMemcache.addException(exception);
351 
352     try {
353       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
354       String instanceId = "instanceId902024336";
355       Instance resource = Instance.newBuilder().build();
356       client.createInstanceAsync(parent, instanceId, resource).get();
357       Assert.fail("No exception raised");
358     } catch (ExecutionException e) {
359       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
360       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
361       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
362     }
363   }
364 
365   @Test
createInstanceTest2()366   public void createInstanceTest2() throws Exception {
367     Instance expectedResponse =
368         Instance.newBuilder()
369             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
370             .setDisplayName("displayName1714148973")
371             .putAllLabels(new HashMap<String, String>())
372             .setAuthorizedNetwork("authorizedNetwork1515554835")
373             .addAllZones(new ArrayList<String>())
374             .setNodeCount(1539922066)
375             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
376             .setMemcacheVersion(MemcacheVersion.forNumber(0))
377             .setParameters(MemcacheParameters.newBuilder().build())
378             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
379             .setCreateTime(Timestamp.newBuilder().build())
380             .setUpdateTime(Timestamp.newBuilder().build())
381             .setMemcacheFullVersion("memcacheFullVersion976507452")
382             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
383             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
384             .setUpdateAvailable(true)
385             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
386             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
387             .build();
388     Operation resultOperation =
389         Operation.newBuilder()
390             .setName("createInstanceTest")
391             .setDone(true)
392             .setResponse(Any.pack(expectedResponse))
393             .build();
394     mockCloudMemcache.addResponse(resultOperation);
395 
396     String parent = "parent-995424086";
397     String instanceId = "instanceId902024336";
398     Instance resource = Instance.newBuilder().build();
399 
400     Instance actualResponse = client.createInstanceAsync(parent, instanceId, resource).get();
401     Assert.assertEquals(expectedResponse, actualResponse);
402 
403     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
404     Assert.assertEquals(1, actualRequests.size());
405     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
406 
407     Assert.assertEquals(parent, actualRequest.getParent());
408     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
409     Assert.assertEquals(resource, actualRequest.getResource());
410     Assert.assertTrue(
411         channelProvider.isHeaderSent(
412             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
413             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
414   }
415 
416   @Test
createInstanceExceptionTest2()417   public void createInstanceExceptionTest2() throws Exception {
418     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
419     mockCloudMemcache.addException(exception);
420 
421     try {
422       String parent = "parent-995424086";
423       String instanceId = "instanceId902024336";
424       Instance resource = Instance.newBuilder().build();
425       client.createInstanceAsync(parent, instanceId, resource).get();
426       Assert.fail("No exception raised");
427     } catch (ExecutionException e) {
428       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
429       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
430       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
431     }
432   }
433 
434   @Test
updateInstanceTest()435   public void updateInstanceTest() throws Exception {
436     Instance expectedResponse =
437         Instance.newBuilder()
438             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
439             .setDisplayName("displayName1714148973")
440             .putAllLabels(new HashMap<String, String>())
441             .setAuthorizedNetwork("authorizedNetwork1515554835")
442             .addAllZones(new ArrayList<String>())
443             .setNodeCount(1539922066)
444             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
445             .setMemcacheVersion(MemcacheVersion.forNumber(0))
446             .setParameters(MemcacheParameters.newBuilder().build())
447             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
448             .setCreateTime(Timestamp.newBuilder().build())
449             .setUpdateTime(Timestamp.newBuilder().build())
450             .setMemcacheFullVersion("memcacheFullVersion976507452")
451             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
452             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
453             .setUpdateAvailable(true)
454             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
455             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
456             .build();
457     Operation resultOperation =
458         Operation.newBuilder()
459             .setName("updateInstanceTest")
460             .setDone(true)
461             .setResponse(Any.pack(expectedResponse))
462             .build();
463     mockCloudMemcache.addResponse(resultOperation);
464 
465     FieldMask updateMask = FieldMask.newBuilder().build();
466     Instance resource = Instance.newBuilder().build();
467 
468     Instance actualResponse = client.updateInstanceAsync(updateMask, resource).get();
469     Assert.assertEquals(expectedResponse, actualResponse);
470 
471     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
472     Assert.assertEquals(1, actualRequests.size());
473     UpdateInstanceRequest actualRequest = ((UpdateInstanceRequest) actualRequests.get(0));
474 
475     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
476     Assert.assertEquals(resource, actualRequest.getResource());
477     Assert.assertTrue(
478         channelProvider.isHeaderSent(
479             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
480             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
481   }
482 
483   @Test
updateInstanceExceptionTest()484   public void updateInstanceExceptionTest() throws Exception {
485     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
486     mockCloudMemcache.addException(exception);
487 
488     try {
489       FieldMask updateMask = FieldMask.newBuilder().build();
490       Instance resource = Instance.newBuilder().build();
491       client.updateInstanceAsync(updateMask, resource).get();
492       Assert.fail("No exception raised");
493     } catch (ExecutionException e) {
494       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
495       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
496       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
497     }
498   }
499 
500   @Test
updateParametersTest()501   public void updateParametersTest() throws Exception {
502     Instance expectedResponse =
503         Instance.newBuilder()
504             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
505             .setDisplayName("displayName1714148973")
506             .putAllLabels(new HashMap<String, String>())
507             .setAuthorizedNetwork("authorizedNetwork1515554835")
508             .addAllZones(new ArrayList<String>())
509             .setNodeCount(1539922066)
510             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
511             .setMemcacheVersion(MemcacheVersion.forNumber(0))
512             .setParameters(MemcacheParameters.newBuilder().build())
513             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
514             .setCreateTime(Timestamp.newBuilder().build())
515             .setUpdateTime(Timestamp.newBuilder().build())
516             .setMemcacheFullVersion("memcacheFullVersion976507452")
517             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
518             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
519             .setUpdateAvailable(true)
520             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
521             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
522             .build();
523     Operation resultOperation =
524         Operation.newBuilder()
525             .setName("updateParametersTest")
526             .setDone(true)
527             .setResponse(Any.pack(expectedResponse))
528             .build();
529     mockCloudMemcache.addResponse(resultOperation);
530 
531     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
532     FieldMask updateMask = FieldMask.newBuilder().build();
533     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
534 
535     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
536     Assert.assertEquals(expectedResponse, actualResponse);
537 
538     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
539     Assert.assertEquals(1, actualRequests.size());
540     UpdateParametersRequest actualRequest = ((UpdateParametersRequest) actualRequests.get(0));
541 
542     Assert.assertEquals(name.toString(), actualRequest.getName());
543     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
544     Assert.assertEquals(parameters, actualRequest.getParameters());
545     Assert.assertTrue(
546         channelProvider.isHeaderSent(
547             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
548             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
549   }
550 
551   @Test
updateParametersExceptionTest()552   public void updateParametersExceptionTest() throws Exception {
553     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
554     mockCloudMemcache.addException(exception);
555 
556     try {
557       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
558       FieldMask updateMask = FieldMask.newBuilder().build();
559       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
560       client.updateParametersAsync(name, updateMask, parameters).get();
561       Assert.fail("No exception raised");
562     } catch (ExecutionException e) {
563       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
564       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
565       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
566     }
567   }
568 
569   @Test
updateParametersTest2()570   public void updateParametersTest2() throws Exception {
571     Instance expectedResponse =
572         Instance.newBuilder()
573             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
574             .setDisplayName("displayName1714148973")
575             .putAllLabels(new HashMap<String, String>())
576             .setAuthorizedNetwork("authorizedNetwork1515554835")
577             .addAllZones(new ArrayList<String>())
578             .setNodeCount(1539922066)
579             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
580             .setMemcacheVersion(MemcacheVersion.forNumber(0))
581             .setParameters(MemcacheParameters.newBuilder().build())
582             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
583             .setCreateTime(Timestamp.newBuilder().build())
584             .setUpdateTime(Timestamp.newBuilder().build())
585             .setMemcacheFullVersion("memcacheFullVersion976507452")
586             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
587             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
588             .setUpdateAvailable(true)
589             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
590             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
591             .build();
592     Operation resultOperation =
593         Operation.newBuilder()
594             .setName("updateParametersTest")
595             .setDone(true)
596             .setResponse(Any.pack(expectedResponse))
597             .build();
598     mockCloudMemcache.addResponse(resultOperation);
599 
600     String name = "name3373707";
601     FieldMask updateMask = FieldMask.newBuilder().build();
602     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
603 
604     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
605     Assert.assertEquals(expectedResponse, actualResponse);
606 
607     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
608     Assert.assertEquals(1, actualRequests.size());
609     UpdateParametersRequest actualRequest = ((UpdateParametersRequest) actualRequests.get(0));
610 
611     Assert.assertEquals(name, actualRequest.getName());
612     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
613     Assert.assertEquals(parameters, actualRequest.getParameters());
614     Assert.assertTrue(
615         channelProvider.isHeaderSent(
616             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
617             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
618   }
619 
620   @Test
updateParametersExceptionTest2()621   public void updateParametersExceptionTest2() throws Exception {
622     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
623     mockCloudMemcache.addException(exception);
624 
625     try {
626       String name = "name3373707";
627       FieldMask updateMask = FieldMask.newBuilder().build();
628       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
629       client.updateParametersAsync(name, updateMask, parameters).get();
630       Assert.fail("No exception raised");
631     } catch (ExecutionException e) {
632       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
633       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
634       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
635     }
636   }
637 
638   @Test
deleteInstanceTest()639   public void deleteInstanceTest() throws Exception {
640     Empty expectedResponse = Empty.newBuilder().build();
641     Operation resultOperation =
642         Operation.newBuilder()
643             .setName("deleteInstanceTest")
644             .setDone(true)
645             .setResponse(Any.pack(expectedResponse))
646             .build();
647     mockCloudMemcache.addResponse(resultOperation);
648 
649     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
650 
651     client.deleteInstanceAsync(name).get();
652 
653     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
654     Assert.assertEquals(1, actualRequests.size());
655     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
656 
657     Assert.assertEquals(name.toString(), actualRequest.getName());
658     Assert.assertTrue(
659         channelProvider.isHeaderSent(
660             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
661             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
662   }
663 
664   @Test
deleteInstanceExceptionTest()665   public void deleteInstanceExceptionTest() throws Exception {
666     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
667     mockCloudMemcache.addException(exception);
668 
669     try {
670       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
671       client.deleteInstanceAsync(name).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
deleteInstanceTest2()681   public void deleteInstanceTest2() throws Exception {
682     Empty expectedResponse = Empty.newBuilder().build();
683     Operation resultOperation =
684         Operation.newBuilder()
685             .setName("deleteInstanceTest")
686             .setDone(true)
687             .setResponse(Any.pack(expectedResponse))
688             .build();
689     mockCloudMemcache.addResponse(resultOperation);
690 
691     String name = "name3373707";
692 
693     client.deleteInstanceAsync(name).get();
694 
695     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
696     Assert.assertEquals(1, actualRequests.size());
697     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
698 
699     Assert.assertEquals(name, actualRequest.getName());
700     Assert.assertTrue(
701         channelProvider.isHeaderSent(
702             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
703             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
704   }
705 
706   @Test
deleteInstanceExceptionTest2()707   public void deleteInstanceExceptionTest2() throws Exception {
708     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
709     mockCloudMemcache.addException(exception);
710 
711     try {
712       String name = "name3373707";
713       client.deleteInstanceAsync(name).get();
714       Assert.fail("No exception raised");
715     } catch (ExecutionException e) {
716       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
717       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
718       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
719     }
720   }
721 
722   @Test
applyParametersTest()723   public void applyParametersTest() throws Exception {
724     Instance expectedResponse =
725         Instance.newBuilder()
726             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
727             .setDisplayName("displayName1714148973")
728             .putAllLabels(new HashMap<String, String>())
729             .setAuthorizedNetwork("authorizedNetwork1515554835")
730             .addAllZones(new ArrayList<String>())
731             .setNodeCount(1539922066)
732             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
733             .setMemcacheVersion(MemcacheVersion.forNumber(0))
734             .setParameters(MemcacheParameters.newBuilder().build())
735             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
736             .setCreateTime(Timestamp.newBuilder().build())
737             .setUpdateTime(Timestamp.newBuilder().build())
738             .setMemcacheFullVersion("memcacheFullVersion976507452")
739             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
740             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
741             .setUpdateAvailable(true)
742             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
743             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
744             .build();
745     Operation resultOperation =
746         Operation.newBuilder()
747             .setName("applyParametersTest")
748             .setDone(true)
749             .setResponse(Any.pack(expectedResponse))
750             .build();
751     mockCloudMemcache.addResponse(resultOperation);
752 
753     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
754     List<String> nodeIds = new ArrayList<>();
755     boolean applyAll = true;
756 
757     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
758     Assert.assertEquals(expectedResponse, actualResponse);
759 
760     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
761     Assert.assertEquals(1, actualRequests.size());
762     ApplyParametersRequest actualRequest = ((ApplyParametersRequest) actualRequests.get(0));
763 
764     Assert.assertEquals(name.toString(), actualRequest.getName());
765     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
766     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
767     Assert.assertTrue(
768         channelProvider.isHeaderSent(
769             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
770             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
771   }
772 
773   @Test
applyParametersExceptionTest()774   public void applyParametersExceptionTest() throws Exception {
775     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
776     mockCloudMemcache.addException(exception);
777 
778     try {
779       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
780       List<String> nodeIds = new ArrayList<>();
781       boolean applyAll = true;
782       client.applyParametersAsync(name, nodeIds, applyAll).get();
783       Assert.fail("No exception raised");
784     } catch (ExecutionException e) {
785       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
786       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
787       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
788     }
789   }
790 
791   @Test
applyParametersTest2()792   public void applyParametersTest2() throws Exception {
793     Instance expectedResponse =
794         Instance.newBuilder()
795             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
796             .setDisplayName("displayName1714148973")
797             .putAllLabels(new HashMap<String, String>())
798             .setAuthorizedNetwork("authorizedNetwork1515554835")
799             .addAllZones(new ArrayList<String>())
800             .setNodeCount(1539922066)
801             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
802             .setMemcacheVersion(MemcacheVersion.forNumber(0))
803             .setParameters(MemcacheParameters.newBuilder().build())
804             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
805             .setCreateTime(Timestamp.newBuilder().build())
806             .setUpdateTime(Timestamp.newBuilder().build())
807             .setMemcacheFullVersion("memcacheFullVersion976507452")
808             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
809             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
810             .setUpdateAvailable(true)
811             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
812             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
813             .build();
814     Operation resultOperation =
815         Operation.newBuilder()
816             .setName("applyParametersTest")
817             .setDone(true)
818             .setResponse(Any.pack(expectedResponse))
819             .build();
820     mockCloudMemcache.addResponse(resultOperation);
821 
822     String name = "name3373707";
823     List<String> nodeIds = new ArrayList<>();
824     boolean applyAll = true;
825 
826     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
827     Assert.assertEquals(expectedResponse, actualResponse);
828 
829     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
830     Assert.assertEquals(1, actualRequests.size());
831     ApplyParametersRequest actualRequest = ((ApplyParametersRequest) actualRequests.get(0));
832 
833     Assert.assertEquals(name, actualRequest.getName());
834     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
835     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
836     Assert.assertTrue(
837         channelProvider.isHeaderSent(
838             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
839             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
840   }
841 
842   @Test
applyParametersExceptionTest2()843   public void applyParametersExceptionTest2() throws Exception {
844     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
845     mockCloudMemcache.addException(exception);
846 
847     try {
848       String name = "name3373707";
849       List<String> nodeIds = new ArrayList<>();
850       boolean applyAll = true;
851       client.applyParametersAsync(name, nodeIds, applyAll).get();
852       Assert.fail("No exception raised");
853     } catch (ExecutionException e) {
854       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
855       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
856       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
857     }
858   }
859 
860   @Test
applySoftwareUpdateTest()861   public void applySoftwareUpdateTest() throws Exception {
862     Instance expectedResponse =
863         Instance.newBuilder()
864             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
865             .setDisplayName("displayName1714148973")
866             .putAllLabels(new HashMap<String, String>())
867             .setAuthorizedNetwork("authorizedNetwork1515554835")
868             .addAllZones(new ArrayList<String>())
869             .setNodeCount(1539922066)
870             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
871             .setMemcacheVersion(MemcacheVersion.forNumber(0))
872             .setParameters(MemcacheParameters.newBuilder().build())
873             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
874             .setCreateTime(Timestamp.newBuilder().build())
875             .setUpdateTime(Timestamp.newBuilder().build())
876             .setMemcacheFullVersion("memcacheFullVersion976507452")
877             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
878             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
879             .setUpdateAvailable(true)
880             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
881             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
882             .build();
883     Operation resultOperation =
884         Operation.newBuilder()
885             .setName("applySoftwareUpdateTest")
886             .setDone(true)
887             .setResponse(Any.pack(expectedResponse))
888             .build();
889     mockCloudMemcache.addResponse(resultOperation);
890 
891     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
892     List<String> nodeIds = new ArrayList<>();
893     boolean applyAll = true;
894 
895     Instance actualResponse = client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
896     Assert.assertEquals(expectedResponse, actualResponse);
897 
898     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
899     Assert.assertEquals(1, actualRequests.size());
900     ApplySoftwareUpdateRequest actualRequest = ((ApplySoftwareUpdateRequest) actualRequests.get(0));
901 
902     Assert.assertEquals(instance.toString(), actualRequest.getInstance());
903     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
904     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
905     Assert.assertTrue(
906         channelProvider.isHeaderSent(
907             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
908             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
909   }
910 
911   @Test
applySoftwareUpdateExceptionTest()912   public void applySoftwareUpdateExceptionTest() throws Exception {
913     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
914     mockCloudMemcache.addException(exception);
915 
916     try {
917       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
918       List<String> nodeIds = new ArrayList<>();
919       boolean applyAll = true;
920       client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
921       Assert.fail("No exception raised");
922     } catch (ExecutionException e) {
923       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
924       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
925       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
926     }
927   }
928 
929   @Test
applySoftwareUpdateTest2()930   public void applySoftwareUpdateTest2() throws Exception {
931     Instance expectedResponse =
932         Instance.newBuilder()
933             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
934             .setDisplayName("displayName1714148973")
935             .putAllLabels(new HashMap<String, String>())
936             .setAuthorizedNetwork("authorizedNetwork1515554835")
937             .addAllZones(new ArrayList<String>())
938             .setNodeCount(1539922066)
939             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
940             .setMemcacheVersion(MemcacheVersion.forNumber(0))
941             .setParameters(MemcacheParameters.newBuilder().build())
942             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
943             .setCreateTime(Timestamp.newBuilder().build())
944             .setUpdateTime(Timestamp.newBuilder().build())
945             .setMemcacheFullVersion("memcacheFullVersion976507452")
946             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
947             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
948             .setUpdateAvailable(true)
949             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
950             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
951             .build();
952     Operation resultOperation =
953         Operation.newBuilder()
954             .setName("applySoftwareUpdateTest")
955             .setDone(true)
956             .setResponse(Any.pack(expectedResponse))
957             .build();
958     mockCloudMemcache.addResponse(resultOperation);
959 
960     String instance = "instance555127957";
961     List<String> nodeIds = new ArrayList<>();
962     boolean applyAll = true;
963 
964     Instance actualResponse = client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
965     Assert.assertEquals(expectedResponse, actualResponse);
966 
967     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
968     Assert.assertEquals(1, actualRequests.size());
969     ApplySoftwareUpdateRequest actualRequest = ((ApplySoftwareUpdateRequest) actualRequests.get(0));
970 
971     Assert.assertEquals(instance, actualRequest.getInstance());
972     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
973     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
974     Assert.assertTrue(
975         channelProvider.isHeaderSent(
976             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
977             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
978   }
979 
980   @Test
applySoftwareUpdateExceptionTest2()981   public void applySoftwareUpdateExceptionTest2() throws Exception {
982     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
983     mockCloudMemcache.addException(exception);
984 
985     try {
986       String instance = "instance555127957";
987       List<String> nodeIds = new ArrayList<>();
988       boolean applyAll = true;
989       client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
990       Assert.fail("No exception raised");
991     } catch (ExecutionException e) {
992       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
993       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
994       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
995     }
996   }
997 
998   @Test
rescheduleMaintenanceTest()999   public void rescheduleMaintenanceTest() throws Exception {
1000     Instance expectedResponse =
1001         Instance.newBuilder()
1002             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1003             .setDisplayName("displayName1714148973")
1004             .putAllLabels(new HashMap<String, String>())
1005             .setAuthorizedNetwork("authorizedNetwork1515554835")
1006             .addAllZones(new ArrayList<String>())
1007             .setNodeCount(1539922066)
1008             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1009             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1010             .setParameters(MemcacheParameters.newBuilder().build())
1011             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1012             .setCreateTime(Timestamp.newBuilder().build())
1013             .setUpdateTime(Timestamp.newBuilder().build())
1014             .setMemcacheFullVersion("memcacheFullVersion976507452")
1015             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1016             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1017             .setUpdateAvailable(true)
1018             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1019             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1020             .build();
1021     Operation resultOperation =
1022         Operation.newBuilder()
1023             .setName("rescheduleMaintenanceTest")
1024             .setDone(true)
1025             .setResponse(Any.pack(expectedResponse))
1026             .build();
1027     mockCloudMemcache.addResponse(resultOperation);
1028 
1029     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1030     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1031         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1032     Timestamp scheduleTime = Timestamp.newBuilder().build();
1033 
1034     Instance actualResponse =
1035         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1036     Assert.assertEquals(expectedResponse, actualResponse);
1037 
1038     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
1039     Assert.assertEquals(1, actualRequests.size());
1040     RescheduleMaintenanceRequest actualRequest =
1041         ((RescheduleMaintenanceRequest) actualRequests.get(0));
1042 
1043     Assert.assertEquals(instance.toString(), actualRequest.getInstance());
1044     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
1045     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
1046     Assert.assertTrue(
1047         channelProvider.isHeaderSent(
1048             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1049             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1050   }
1051 
1052   @Test
rescheduleMaintenanceExceptionTest()1053   public void rescheduleMaintenanceExceptionTest() throws Exception {
1054     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1055     mockCloudMemcache.addException(exception);
1056 
1057     try {
1058       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1059       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1060           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1061       Timestamp scheduleTime = Timestamp.newBuilder().build();
1062       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1063       Assert.fail("No exception raised");
1064     } catch (ExecutionException e) {
1065       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1066       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1067       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1068     }
1069   }
1070 
1071   @Test
rescheduleMaintenanceTest2()1072   public void rescheduleMaintenanceTest2() throws Exception {
1073     Instance expectedResponse =
1074         Instance.newBuilder()
1075             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1076             .setDisplayName("displayName1714148973")
1077             .putAllLabels(new HashMap<String, String>())
1078             .setAuthorizedNetwork("authorizedNetwork1515554835")
1079             .addAllZones(new ArrayList<String>())
1080             .setNodeCount(1539922066)
1081             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1082             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1083             .setParameters(MemcacheParameters.newBuilder().build())
1084             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1085             .setCreateTime(Timestamp.newBuilder().build())
1086             .setUpdateTime(Timestamp.newBuilder().build())
1087             .setMemcacheFullVersion("memcacheFullVersion976507452")
1088             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1089             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1090             .setUpdateAvailable(true)
1091             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1092             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1093             .build();
1094     Operation resultOperation =
1095         Operation.newBuilder()
1096             .setName("rescheduleMaintenanceTest")
1097             .setDone(true)
1098             .setResponse(Any.pack(expectedResponse))
1099             .build();
1100     mockCloudMemcache.addResponse(resultOperation);
1101 
1102     String instance = "instance555127957";
1103     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1104         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1105     Timestamp scheduleTime = Timestamp.newBuilder().build();
1106 
1107     Instance actualResponse =
1108         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1109     Assert.assertEquals(expectedResponse, actualResponse);
1110 
1111     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
1112     Assert.assertEquals(1, actualRequests.size());
1113     RescheduleMaintenanceRequest actualRequest =
1114         ((RescheduleMaintenanceRequest) actualRequests.get(0));
1115 
1116     Assert.assertEquals(instance, actualRequest.getInstance());
1117     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
1118     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
1119     Assert.assertTrue(
1120         channelProvider.isHeaderSent(
1121             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1122             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1123   }
1124 
1125   @Test
rescheduleMaintenanceExceptionTest2()1126   public void rescheduleMaintenanceExceptionTest2() throws Exception {
1127     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1128     mockCloudMemcache.addException(exception);
1129 
1130     try {
1131       String instance = "instance555127957";
1132       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1133           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1134       Timestamp scheduleTime = Timestamp.newBuilder().build();
1135       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1136       Assert.fail("No exception raised");
1137     } catch (ExecutionException e) {
1138       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1139       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1140       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1141     }
1142   }
1143 
1144   @Test
listLocationsTest()1145   public void listLocationsTest() throws Exception {
1146     Location responsesElement = Location.newBuilder().build();
1147     ListLocationsResponse expectedResponse =
1148         ListLocationsResponse.newBuilder()
1149             .setNextPageToken("")
1150             .addAllLocations(Arrays.asList(responsesElement))
1151             .build();
1152     mockLocations.addResponse(expectedResponse);
1153 
1154     ListLocationsRequest request =
1155         ListLocationsRequest.newBuilder()
1156             .setName("name3373707")
1157             .setFilter("filter-1274492040")
1158             .setPageSize(883849137)
1159             .setPageToken("pageToken873572522")
1160             .build();
1161 
1162     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1163 
1164     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1165 
1166     Assert.assertEquals(1, resources.size());
1167     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1168 
1169     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1170     Assert.assertEquals(1, actualRequests.size());
1171     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1172 
1173     Assert.assertEquals(request.getName(), actualRequest.getName());
1174     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1175     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1176     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1177     Assert.assertTrue(
1178         channelProvider.isHeaderSent(
1179             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1180             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1181   }
1182 
1183   @Test
listLocationsExceptionTest()1184   public void listLocationsExceptionTest() throws Exception {
1185     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1186     mockLocations.addException(exception);
1187 
1188     try {
1189       ListLocationsRequest request =
1190           ListLocationsRequest.newBuilder()
1191               .setName("name3373707")
1192               .setFilter("filter-1274492040")
1193               .setPageSize(883849137)
1194               .setPageToken("pageToken873572522")
1195               .build();
1196       client.listLocations(request);
1197       Assert.fail("No exception raised");
1198     } catch (InvalidArgumentException e) {
1199       // Expected exception.
1200     }
1201   }
1202 
1203   @Test
getLocationTest()1204   public void getLocationTest() throws Exception {
1205     Location expectedResponse =
1206         Location.newBuilder()
1207             .setName("name3373707")
1208             .setLocationId("locationId1541836720")
1209             .setDisplayName("displayName1714148973")
1210             .putAllLabels(new HashMap<String, String>())
1211             .setMetadata(Any.newBuilder().build())
1212             .build();
1213     mockLocations.addResponse(expectedResponse);
1214 
1215     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1216 
1217     Location actualResponse = client.getLocation(request);
1218     Assert.assertEquals(expectedResponse, actualResponse);
1219 
1220     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1221     Assert.assertEquals(1, actualRequests.size());
1222     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1223 
1224     Assert.assertEquals(request.getName(), actualRequest.getName());
1225     Assert.assertTrue(
1226         channelProvider.isHeaderSent(
1227             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1228             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1229   }
1230 
1231   @Test
getLocationExceptionTest()1232   public void getLocationExceptionTest() throws Exception {
1233     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1234     mockLocations.addException(exception);
1235 
1236     try {
1237       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1238       client.getLocation(request);
1239       Assert.fail("No exception raised");
1240     } catch (InvalidArgumentException e) {
1241       // Expected exception.
1242     }
1243   }
1244 }
1245