• 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.v1;
18 
19 import static com.google.cloud.memcache.v1.CloudMemcacheClient.ListInstancesPagedResponse;
20 import static com.google.cloud.memcache.v1.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             .addAllInstances(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.getInstancesList().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             .addAllInstances(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.getInstancesList().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             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
206             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
207             .build();
208     mockCloudMemcache.addResponse(expectedResponse);
209 
210     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
211 
212     Instance actualResponse = client.getInstance(name);
213     Assert.assertEquals(expectedResponse, actualResponse);
214 
215     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
216     Assert.assertEquals(1, actualRequests.size());
217     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
218 
219     Assert.assertEquals(name.toString(), actualRequest.getName());
220     Assert.assertTrue(
221         channelProvider.isHeaderSent(
222             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
223             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
224   }
225 
226   @Test
getInstanceExceptionTest()227   public void getInstanceExceptionTest() throws Exception {
228     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
229     mockCloudMemcache.addException(exception);
230 
231     try {
232       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
233       client.getInstance(name);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
getInstanceTest2()241   public void getInstanceTest2() throws Exception {
242     Instance expectedResponse =
243         Instance.newBuilder()
244             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
245             .setDisplayName("displayName1714148973")
246             .putAllLabels(new HashMap<String, String>())
247             .setAuthorizedNetwork("authorizedNetwork1515554835")
248             .addAllZones(new ArrayList<String>())
249             .setNodeCount(1539922066)
250             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
251             .setMemcacheVersion(MemcacheVersion.forNumber(0))
252             .setParameters(MemcacheParameters.newBuilder().build())
253             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
254             .setCreateTime(Timestamp.newBuilder().build())
255             .setUpdateTime(Timestamp.newBuilder().build())
256             .setMemcacheFullVersion("memcacheFullVersion976507452")
257             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
258             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
259             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
260             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
261             .build();
262     mockCloudMemcache.addResponse(expectedResponse);
263 
264     String name = "name3373707";
265 
266     Instance actualResponse = client.getInstance(name);
267     Assert.assertEquals(expectedResponse, actualResponse);
268 
269     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
270     Assert.assertEquals(1, actualRequests.size());
271     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
272 
273     Assert.assertEquals(name, actualRequest.getName());
274     Assert.assertTrue(
275         channelProvider.isHeaderSent(
276             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
277             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
278   }
279 
280   @Test
getInstanceExceptionTest2()281   public void getInstanceExceptionTest2() throws Exception {
282     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
283     mockCloudMemcache.addException(exception);
284 
285     try {
286       String name = "name3373707";
287       client.getInstance(name);
288       Assert.fail("No exception raised");
289     } catch (InvalidArgumentException e) {
290       // Expected exception.
291     }
292   }
293 
294   @Test
createInstanceTest()295   public void createInstanceTest() throws Exception {
296     Instance expectedResponse =
297         Instance.newBuilder()
298             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
299             .setDisplayName("displayName1714148973")
300             .putAllLabels(new HashMap<String, String>())
301             .setAuthorizedNetwork("authorizedNetwork1515554835")
302             .addAllZones(new ArrayList<String>())
303             .setNodeCount(1539922066)
304             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
305             .setMemcacheVersion(MemcacheVersion.forNumber(0))
306             .setParameters(MemcacheParameters.newBuilder().build())
307             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
308             .setCreateTime(Timestamp.newBuilder().build())
309             .setUpdateTime(Timestamp.newBuilder().build())
310             .setMemcacheFullVersion("memcacheFullVersion976507452")
311             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
312             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
313             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
314             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
315             .build();
316     Operation resultOperation =
317         Operation.newBuilder()
318             .setName("createInstanceTest")
319             .setDone(true)
320             .setResponse(Any.pack(expectedResponse))
321             .build();
322     mockCloudMemcache.addResponse(resultOperation);
323 
324     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
325     Instance instance = Instance.newBuilder().build();
326     String instanceId = "instanceId902024336";
327 
328     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
329     Assert.assertEquals(expectedResponse, actualResponse);
330 
331     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
332     Assert.assertEquals(1, actualRequests.size());
333     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
334 
335     Assert.assertEquals(parent.toString(), actualRequest.getParent());
336     Assert.assertEquals(instance, actualRequest.getInstance());
337     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
338     Assert.assertTrue(
339         channelProvider.isHeaderSent(
340             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
341             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
342   }
343 
344   @Test
createInstanceExceptionTest()345   public void createInstanceExceptionTest() throws Exception {
346     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
347     mockCloudMemcache.addException(exception);
348 
349     try {
350       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
351       Instance instance = Instance.newBuilder().build();
352       String instanceId = "instanceId902024336";
353       client.createInstanceAsync(parent, instance, instanceId).get();
354       Assert.fail("No exception raised");
355     } catch (ExecutionException e) {
356       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
357       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
358       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
359     }
360   }
361 
362   @Test
createInstanceTest2()363   public void createInstanceTest2() throws Exception {
364     Instance expectedResponse =
365         Instance.newBuilder()
366             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
367             .setDisplayName("displayName1714148973")
368             .putAllLabels(new HashMap<String, String>())
369             .setAuthorizedNetwork("authorizedNetwork1515554835")
370             .addAllZones(new ArrayList<String>())
371             .setNodeCount(1539922066)
372             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
373             .setMemcacheVersion(MemcacheVersion.forNumber(0))
374             .setParameters(MemcacheParameters.newBuilder().build())
375             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
376             .setCreateTime(Timestamp.newBuilder().build())
377             .setUpdateTime(Timestamp.newBuilder().build())
378             .setMemcacheFullVersion("memcacheFullVersion976507452")
379             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
380             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
381             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
382             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
383             .build();
384     Operation resultOperation =
385         Operation.newBuilder()
386             .setName("createInstanceTest")
387             .setDone(true)
388             .setResponse(Any.pack(expectedResponse))
389             .build();
390     mockCloudMemcache.addResponse(resultOperation);
391 
392     String parent = "parent-995424086";
393     Instance instance = Instance.newBuilder().build();
394     String instanceId = "instanceId902024336";
395 
396     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
397     Assert.assertEquals(expectedResponse, actualResponse);
398 
399     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
400     Assert.assertEquals(1, actualRequests.size());
401     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
402 
403     Assert.assertEquals(parent, actualRequest.getParent());
404     Assert.assertEquals(instance, actualRequest.getInstance());
405     Assert.assertEquals(instanceId, actualRequest.getInstanceId());
406     Assert.assertTrue(
407         channelProvider.isHeaderSent(
408             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
409             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
410   }
411 
412   @Test
createInstanceExceptionTest2()413   public void createInstanceExceptionTest2() throws Exception {
414     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
415     mockCloudMemcache.addException(exception);
416 
417     try {
418       String parent = "parent-995424086";
419       Instance instance = Instance.newBuilder().build();
420       String instanceId = "instanceId902024336";
421       client.createInstanceAsync(parent, instance, instanceId).get();
422       Assert.fail("No exception raised");
423     } catch (ExecutionException e) {
424       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
425       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
426       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
427     }
428   }
429 
430   @Test
updateInstanceTest()431   public void updateInstanceTest() throws Exception {
432     Instance expectedResponse =
433         Instance.newBuilder()
434             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
435             .setDisplayName("displayName1714148973")
436             .putAllLabels(new HashMap<String, String>())
437             .setAuthorizedNetwork("authorizedNetwork1515554835")
438             .addAllZones(new ArrayList<String>())
439             .setNodeCount(1539922066)
440             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
441             .setMemcacheVersion(MemcacheVersion.forNumber(0))
442             .setParameters(MemcacheParameters.newBuilder().build())
443             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
444             .setCreateTime(Timestamp.newBuilder().build())
445             .setUpdateTime(Timestamp.newBuilder().build())
446             .setMemcacheFullVersion("memcacheFullVersion976507452")
447             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
448             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
449             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
450             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
451             .build();
452     Operation resultOperation =
453         Operation.newBuilder()
454             .setName("updateInstanceTest")
455             .setDone(true)
456             .setResponse(Any.pack(expectedResponse))
457             .build();
458     mockCloudMemcache.addResponse(resultOperation);
459 
460     Instance instance = Instance.newBuilder().build();
461     FieldMask updateMask = FieldMask.newBuilder().build();
462 
463     Instance actualResponse = client.updateInstanceAsync(instance, updateMask).get();
464     Assert.assertEquals(expectedResponse, actualResponse);
465 
466     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
467     Assert.assertEquals(1, actualRequests.size());
468     UpdateInstanceRequest actualRequest = ((UpdateInstanceRequest) actualRequests.get(0));
469 
470     Assert.assertEquals(instance, actualRequest.getInstance());
471     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
472     Assert.assertTrue(
473         channelProvider.isHeaderSent(
474             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
475             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
476   }
477 
478   @Test
updateInstanceExceptionTest()479   public void updateInstanceExceptionTest() throws Exception {
480     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
481     mockCloudMemcache.addException(exception);
482 
483     try {
484       Instance instance = Instance.newBuilder().build();
485       FieldMask updateMask = FieldMask.newBuilder().build();
486       client.updateInstanceAsync(instance, updateMask).get();
487       Assert.fail("No exception raised");
488     } catch (ExecutionException e) {
489       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
490       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
491       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
492     }
493   }
494 
495   @Test
updateParametersTest()496   public void updateParametersTest() throws Exception {
497     Instance expectedResponse =
498         Instance.newBuilder()
499             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
500             .setDisplayName("displayName1714148973")
501             .putAllLabels(new HashMap<String, String>())
502             .setAuthorizedNetwork("authorizedNetwork1515554835")
503             .addAllZones(new ArrayList<String>())
504             .setNodeCount(1539922066)
505             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
506             .setMemcacheVersion(MemcacheVersion.forNumber(0))
507             .setParameters(MemcacheParameters.newBuilder().build())
508             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
509             .setCreateTime(Timestamp.newBuilder().build())
510             .setUpdateTime(Timestamp.newBuilder().build())
511             .setMemcacheFullVersion("memcacheFullVersion976507452")
512             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
513             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
514             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
515             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
516             .build();
517     Operation resultOperation =
518         Operation.newBuilder()
519             .setName("updateParametersTest")
520             .setDone(true)
521             .setResponse(Any.pack(expectedResponse))
522             .build();
523     mockCloudMemcache.addResponse(resultOperation);
524 
525     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
526     FieldMask updateMask = FieldMask.newBuilder().build();
527     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
528 
529     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
530     Assert.assertEquals(expectedResponse, actualResponse);
531 
532     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
533     Assert.assertEquals(1, actualRequests.size());
534     UpdateParametersRequest actualRequest = ((UpdateParametersRequest) actualRequests.get(0));
535 
536     Assert.assertEquals(name.toString(), actualRequest.getName());
537     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
538     Assert.assertEquals(parameters, actualRequest.getParameters());
539     Assert.assertTrue(
540         channelProvider.isHeaderSent(
541             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
542             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
543   }
544 
545   @Test
updateParametersExceptionTest()546   public void updateParametersExceptionTest() throws Exception {
547     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
548     mockCloudMemcache.addException(exception);
549 
550     try {
551       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
552       FieldMask updateMask = FieldMask.newBuilder().build();
553       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
554       client.updateParametersAsync(name, updateMask, parameters).get();
555       Assert.fail("No exception raised");
556     } catch (ExecutionException e) {
557       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
558       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
559       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
560     }
561   }
562 
563   @Test
updateParametersTest2()564   public void updateParametersTest2() throws Exception {
565     Instance expectedResponse =
566         Instance.newBuilder()
567             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
568             .setDisplayName("displayName1714148973")
569             .putAllLabels(new HashMap<String, String>())
570             .setAuthorizedNetwork("authorizedNetwork1515554835")
571             .addAllZones(new ArrayList<String>())
572             .setNodeCount(1539922066)
573             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
574             .setMemcacheVersion(MemcacheVersion.forNumber(0))
575             .setParameters(MemcacheParameters.newBuilder().build())
576             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
577             .setCreateTime(Timestamp.newBuilder().build())
578             .setUpdateTime(Timestamp.newBuilder().build())
579             .setMemcacheFullVersion("memcacheFullVersion976507452")
580             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
581             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
582             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
583             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
584             .build();
585     Operation resultOperation =
586         Operation.newBuilder()
587             .setName("updateParametersTest")
588             .setDone(true)
589             .setResponse(Any.pack(expectedResponse))
590             .build();
591     mockCloudMemcache.addResponse(resultOperation);
592 
593     String name = "name3373707";
594     FieldMask updateMask = FieldMask.newBuilder().build();
595     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
596 
597     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
598     Assert.assertEquals(expectedResponse, actualResponse);
599 
600     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
601     Assert.assertEquals(1, actualRequests.size());
602     UpdateParametersRequest actualRequest = ((UpdateParametersRequest) actualRequests.get(0));
603 
604     Assert.assertEquals(name, actualRequest.getName());
605     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
606     Assert.assertEquals(parameters, actualRequest.getParameters());
607     Assert.assertTrue(
608         channelProvider.isHeaderSent(
609             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
610             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
611   }
612 
613   @Test
updateParametersExceptionTest2()614   public void updateParametersExceptionTest2() throws Exception {
615     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
616     mockCloudMemcache.addException(exception);
617 
618     try {
619       String name = "name3373707";
620       FieldMask updateMask = FieldMask.newBuilder().build();
621       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
622       client.updateParametersAsync(name, updateMask, parameters).get();
623       Assert.fail("No exception raised");
624     } catch (ExecutionException e) {
625       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
626       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
627       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
628     }
629   }
630 
631   @Test
deleteInstanceTest()632   public void deleteInstanceTest() throws Exception {
633     Empty expectedResponse = Empty.newBuilder().build();
634     Operation resultOperation =
635         Operation.newBuilder()
636             .setName("deleteInstanceTest")
637             .setDone(true)
638             .setResponse(Any.pack(expectedResponse))
639             .build();
640     mockCloudMemcache.addResponse(resultOperation);
641 
642     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
643 
644     client.deleteInstanceAsync(name).get();
645 
646     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
647     Assert.assertEquals(1, actualRequests.size());
648     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
649 
650     Assert.assertEquals(name.toString(), actualRequest.getName());
651     Assert.assertTrue(
652         channelProvider.isHeaderSent(
653             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
654             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
655   }
656 
657   @Test
deleteInstanceExceptionTest()658   public void deleteInstanceExceptionTest() throws Exception {
659     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
660     mockCloudMemcache.addException(exception);
661 
662     try {
663       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
664       client.deleteInstanceAsync(name).get();
665       Assert.fail("No exception raised");
666     } catch (ExecutionException e) {
667       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
668       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
669       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
670     }
671   }
672 
673   @Test
deleteInstanceTest2()674   public void deleteInstanceTest2() throws Exception {
675     Empty expectedResponse = Empty.newBuilder().build();
676     Operation resultOperation =
677         Operation.newBuilder()
678             .setName("deleteInstanceTest")
679             .setDone(true)
680             .setResponse(Any.pack(expectedResponse))
681             .build();
682     mockCloudMemcache.addResponse(resultOperation);
683 
684     String name = "name3373707";
685 
686     client.deleteInstanceAsync(name).get();
687 
688     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
689     Assert.assertEquals(1, actualRequests.size());
690     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
691 
692     Assert.assertEquals(name, actualRequest.getName());
693     Assert.assertTrue(
694         channelProvider.isHeaderSent(
695             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
696             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
697   }
698 
699   @Test
deleteInstanceExceptionTest2()700   public void deleteInstanceExceptionTest2() throws Exception {
701     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
702     mockCloudMemcache.addException(exception);
703 
704     try {
705       String name = "name3373707";
706       client.deleteInstanceAsync(name).get();
707       Assert.fail("No exception raised");
708     } catch (ExecutionException e) {
709       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
710       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
711       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
712     }
713   }
714 
715   @Test
applyParametersTest()716   public void applyParametersTest() throws Exception {
717     Instance expectedResponse =
718         Instance.newBuilder()
719             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
720             .setDisplayName("displayName1714148973")
721             .putAllLabels(new HashMap<String, String>())
722             .setAuthorizedNetwork("authorizedNetwork1515554835")
723             .addAllZones(new ArrayList<String>())
724             .setNodeCount(1539922066)
725             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
726             .setMemcacheVersion(MemcacheVersion.forNumber(0))
727             .setParameters(MemcacheParameters.newBuilder().build())
728             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
729             .setCreateTime(Timestamp.newBuilder().build())
730             .setUpdateTime(Timestamp.newBuilder().build())
731             .setMemcacheFullVersion("memcacheFullVersion976507452")
732             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
733             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
734             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
735             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
736             .build();
737     Operation resultOperation =
738         Operation.newBuilder()
739             .setName("applyParametersTest")
740             .setDone(true)
741             .setResponse(Any.pack(expectedResponse))
742             .build();
743     mockCloudMemcache.addResponse(resultOperation);
744 
745     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
746     List<String> nodeIds = new ArrayList<>();
747     boolean applyAll = true;
748 
749     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
750     Assert.assertEquals(expectedResponse, actualResponse);
751 
752     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
753     Assert.assertEquals(1, actualRequests.size());
754     ApplyParametersRequest actualRequest = ((ApplyParametersRequest) actualRequests.get(0));
755 
756     Assert.assertEquals(name.toString(), actualRequest.getName());
757     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
758     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
759     Assert.assertTrue(
760         channelProvider.isHeaderSent(
761             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
762             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
763   }
764 
765   @Test
applyParametersExceptionTest()766   public void applyParametersExceptionTest() throws Exception {
767     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
768     mockCloudMemcache.addException(exception);
769 
770     try {
771       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
772       List<String> nodeIds = new ArrayList<>();
773       boolean applyAll = true;
774       client.applyParametersAsync(name, nodeIds, applyAll).get();
775       Assert.fail("No exception raised");
776     } catch (ExecutionException e) {
777       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
778       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
779       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
780     }
781   }
782 
783   @Test
applyParametersTest2()784   public void applyParametersTest2() throws Exception {
785     Instance expectedResponse =
786         Instance.newBuilder()
787             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
788             .setDisplayName("displayName1714148973")
789             .putAllLabels(new HashMap<String, String>())
790             .setAuthorizedNetwork("authorizedNetwork1515554835")
791             .addAllZones(new ArrayList<String>())
792             .setNodeCount(1539922066)
793             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
794             .setMemcacheVersion(MemcacheVersion.forNumber(0))
795             .setParameters(MemcacheParameters.newBuilder().build())
796             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
797             .setCreateTime(Timestamp.newBuilder().build())
798             .setUpdateTime(Timestamp.newBuilder().build())
799             .setMemcacheFullVersion("memcacheFullVersion976507452")
800             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
801             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
802             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
803             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
804             .build();
805     Operation resultOperation =
806         Operation.newBuilder()
807             .setName("applyParametersTest")
808             .setDone(true)
809             .setResponse(Any.pack(expectedResponse))
810             .build();
811     mockCloudMemcache.addResponse(resultOperation);
812 
813     String name = "name3373707";
814     List<String> nodeIds = new ArrayList<>();
815     boolean applyAll = true;
816 
817     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
818     Assert.assertEquals(expectedResponse, actualResponse);
819 
820     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
821     Assert.assertEquals(1, actualRequests.size());
822     ApplyParametersRequest actualRequest = ((ApplyParametersRequest) actualRequests.get(0));
823 
824     Assert.assertEquals(name, actualRequest.getName());
825     Assert.assertEquals(nodeIds, actualRequest.getNodeIdsList());
826     Assert.assertEquals(applyAll, actualRequest.getApplyAll());
827     Assert.assertTrue(
828         channelProvider.isHeaderSent(
829             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
830             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
831   }
832 
833   @Test
applyParametersExceptionTest2()834   public void applyParametersExceptionTest2() throws Exception {
835     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
836     mockCloudMemcache.addException(exception);
837 
838     try {
839       String name = "name3373707";
840       List<String> nodeIds = new ArrayList<>();
841       boolean applyAll = true;
842       client.applyParametersAsync(name, nodeIds, applyAll).get();
843       Assert.fail("No exception raised");
844     } catch (ExecutionException e) {
845       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
846       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
847       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
848     }
849   }
850 
851   @Test
rescheduleMaintenanceTest()852   public void rescheduleMaintenanceTest() throws Exception {
853     Instance expectedResponse =
854         Instance.newBuilder()
855             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
856             .setDisplayName("displayName1714148973")
857             .putAllLabels(new HashMap<String, String>())
858             .setAuthorizedNetwork("authorizedNetwork1515554835")
859             .addAllZones(new ArrayList<String>())
860             .setNodeCount(1539922066)
861             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
862             .setMemcacheVersion(MemcacheVersion.forNumber(0))
863             .setParameters(MemcacheParameters.newBuilder().build())
864             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
865             .setCreateTime(Timestamp.newBuilder().build())
866             .setUpdateTime(Timestamp.newBuilder().build())
867             .setMemcacheFullVersion("memcacheFullVersion976507452")
868             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
869             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
870             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
871             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
872             .build();
873     Operation resultOperation =
874         Operation.newBuilder()
875             .setName("rescheduleMaintenanceTest")
876             .setDone(true)
877             .setResponse(Any.pack(expectedResponse))
878             .build();
879     mockCloudMemcache.addResponse(resultOperation);
880 
881     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
882     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
883         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
884     Timestamp scheduleTime = Timestamp.newBuilder().build();
885 
886     Instance actualResponse =
887         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
888     Assert.assertEquals(expectedResponse, actualResponse);
889 
890     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
891     Assert.assertEquals(1, actualRequests.size());
892     RescheduleMaintenanceRequest actualRequest =
893         ((RescheduleMaintenanceRequest) actualRequests.get(0));
894 
895     Assert.assertEquals(instance.toString(), actualRequest.getInstance());
896     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
897     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
898     Assert.assertTrue(
899         channelProvider.isHeaderSent(
900             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
901             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
902   }
903 
904   @Test
rescheduleMaintenanceExceptionTest()905   public void rescheduleMaintenanceExceptionTest() throws Exception {
906     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
907     mockCloudMemcache.addException(exception);
908 
909     try {
910       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
911       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
912           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
913       Timestamp scheduleTime = Timestamp.newBuilder().build();
914       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
915       Assert.fail("No exception raised");
916     } catch (ExecutionException e) {
917       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
918       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
919       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
920     }
921   }
922 
923   @Test
rescheduleMaintenanceTest2()924   public void rescheduleMaintenanceTest2() throws Exception {
925     Instance expectedResponse =
926         Instance.newBuilder()
927             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
928             .setDisplayName("displayName1714148973")
929             .putAllLabels(new HashMap<String, String>())
930             .setAuthorizedNetwork("authorizedNetwork1515554835")
931             .addAllZones(new ArrayList<String>())
932             .setNodeCount(1539922066)
933             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
934             .setMemcacheVersion(MemcacheVersion.forNumber(0))
935             .setParameters(MemcacheParameters.newBuilder().build())
936             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
937             .setCreateTime(Timestamp.newBuilder().build())
938             .setUpdateTime(Timestamp.newBuilder().build())
939             .setMemcacheFullVersion("memcacheFullVersion976507452")
940             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
941             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
942             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
943             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
944             .build();
945     Operation resultOperation =
946         Operation.newBuilder()
947             .setName("rescheduleMaintenanceTest")
948             .setDone(true)
949             .setResponse(Any.pack(expectedResponse))
950             .build();
951     mockCloudMemcache.addResponse(resultOperation);
952 
953     String instance = "instance555127957";
954     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
955         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
956     Timestamp scheduleTime = Timestamp.newBuilder().build();
957 
958     Instance actualResponse =
959         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
960     Assert.assertEquals(expectedResponse, actualResponse);
961 
962     List<AbstractMessage> actualRequests = mockCloudMemcache.getRequests();
963     Assert.assertEquals(1, actualRequests.size());
964     RescheduleMaintenanceRequest actualRequest =
965         ((RescheduleMaintenanceRequest) actualRequests.get(0));
966 
967     Assert.assertEquals(instance, actualRequest.getInstance());
968     Assert.assertEquals(rescheduleType, actualRequest.getRescheduleType());
969     Assert.assertEquals(scheduleTime, actualRequest.getScheduleTime());
970     Assert.assertTrue(
971         channelProvider.isHeaderSent(
972             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
973             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
974   }
975 
976   @Test
rescheduleMaintenanceExceptionTest2()977   public void rescheduleMaintenanceExceptionTest2() throws Exception {
978     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
979     mockCloudMemcache.addException(exception);
980 
981     try {
982       String instance = "instance555127957";
983       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
984           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
985       Timestamp scheduleTime = Timestamp.newBuilder().build();
986       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
987       Assert.fail("No exception raised");
988     } catch (ExecutionException e) {
989       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
990       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
991       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
992     }
993   }
994 
995   @Test
listLocationsTest()996   public void listLocationsTest() throws Exception {
997     Location responsesElement = Location.newBuilder().build();
998     ListLocationsResponse expectedResponse =
999         ListLocationsResponse.newBuilder()
1000             .setNextPageToken("")
1001             .addAllLocations(Arrays.asList(responsesElement))
1002             .build();
1003     mockLocations.addResponse(expectedResponse);
1004 
1005     ListLocationsRequest request =
1006         ListLocationsRequest.newBuilder()
1007             .setName("name3373707")
1008             .setFilter("filter-1274492040")
1009             .setPageSize(883849137)
1010             .setPageToken("pageToken873572522")
1011             .build();
1012 
1013     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1014 
1015     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1016 
1017     Assert.assertEquals(1, resources.size());
1018     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1019 
1020     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1021     Assert.assertEquals(1, actualRequests.size());
1022     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1023 
1024     Assert.assertEquals(request.getName(), actualRequest.getName());
1025     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1026     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1027     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1028     Assert.assertTrue(
1029         channelProvider.isHeaderSent(
1030             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1031             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1032   }
1033 
1034   @Test
listLocationsExceptionTest()1035   public void listLocationsExceptionTest() throws Exception {
1036     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1037     mockLocations.addException(exception);
1038 
1039     try {
1040       ListLocationsRequest request =
1041           ListLocationsRequest.newBuilder()
1042               .setName("name3373707")
1043               .setFilter("filter-1274492040")
1044               .setPageSize(883849137)
1045               .setPageToken("pageToken873572522")
1046               .build();
1047       client.listLocations(request);
1048       Assert.fail("No exception raised");
1049     } catch (InvalidArgumentException e) {
1050       // Expected exception.
1051     }
1052   }
1053 
1054   @Test
getLocationTest()1055   public void getLocationTest() throws Exception {
1056     Location expectedResponse =
1057         Location.newBuilder()
1058             .setName("name3373707")
1059             .setLocationId("locationId1541836720")
1060             .setDisplayName("displayName1714148973")
1061             .putAllLabels(new HashMap<String, String>())
1062             .setMetadata(Any.newBuilder().build())
1063             .build();
1064     mockLocations.addResponse(expectedResponse);
1065 
1066     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1067 
1068     Location actualResponse = client.getLocation(request);
1069     Assert.assertEquals(expectedResponse, actualResponse);
1070 
1071     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1072     Assert.assertEquals(1, actualRequests.size());
1073     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1074 
1075     Assert.assertEquals(request.getName(), actualRequest.getName());
1076     Assert.assertTrue(
1077         channelProvider.isHeaderSent(
1078             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1079             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1080   }
1081 
1082   @Test
getLocationExceptionTest()1083   public void getLocationExceptionTest() throws Exception {
1084     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1085     mockLocations.addException(exception);
1086 
1087     try {
1088       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1089       client.getLocation(request);
1090       Assert.fail("No exception raised");
1091     } catch (InvalidArgumentException e) {
1092       // Expected exception.
1093     }
1094   }
1095 }
1096