• 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.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.cloud.location.GetLocationRequest;
32 import com.google.cloud.location.ListLocationsRequest;
33 import com.google.cloud.location.ListLocationsResponse;
34 import com.google.cloud.location.Location;
35 import com.google.cloud.memcache.v1.stub.HttpJsonCloudMemcacheStub;
36 import com.google.common.collect.Lists;
37 import com.google.longrunning.Operation;
38 import com.google.protobuf.Any;
39 import com.google.protobuf.Empty;
40 import com.google.protobuf.FieldMask;
41 import com.google.protobuf.Timestamp;
42 import java.io.IOException;
43 import java.util.ArrayList;
44 import java.util.Arrays;
45 import java.util.HashMap;
46 import java.util.List;
47 import java.util.concurrent.ExecutionException;
48 import javax.annotation.Generated;
49 import org.junit.After;
50 import org.junit.AfterClass;
51 import org.junit.Assert;
52 import org.junit.Before;
53 import org.junit.BeforeClass;
54 import org.junit.Test;
55 
56 @Generated("by gapic-generator-java")
57 public class CloudMemcacheClientHttpJsonTest {
58   private static MockHttpService mockService;
59   private static CloudMemcacheClient client;
60 
61   @BeforeClass
startStaticServer()62   public static void startStaticServer() throws IOException {
63     mockService =
64         new MockHttpService(
65             HttpJsonCloudMemcacheStub.getMethodDescriptors(),
66             CloudMemcacheSettings.getDefaultEndpoint());
67     CloudMemcacheSettings settings =
68         CloudMemcacheSettings.newHttpJsonBuilder()
69             .setTransportChannelProvider(
70                 CloudMemcacheSettings.defaultHttpJsonTransportProviderBuilder()
71                     .setHttpTransport(mockService)
72                     .build())
73             .setCredentialsProvider(NoCredentialsProvider.create())
74             .build();
75     client = CloudMemcacheClient.create(settings);
76   }
77 
78   @AfterClass
stopServer()79   public static void stopServer() {
80     client.close();
81   }
82 
83   @Before
setUp()84   public void setUp() {}
85 
86   @After
tearDown()87   public void tearDown() throws Exception {
88     mockService.reset();
89   }
90 
91   @Test
listInstancesTest()92   public void listInstancesTest() throws Exception {
93     Instance responsesElement = Instance.newBuilder().build();
94     ListInstancesResponse expectedResponse =
95         ListInstancesResponse.newBuilder()
96             .setNextPageToken("")
97             .addAllInstances(Arrays.asList(responsesElement))
98             .build();
99     mockService.addResponse(expectedResponse);
100 
101     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
102 
103     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
104 
105     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
106 
107     Assert.assertEquals(1, resources.size());
108     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
109 
110     List<String> actualRequests = mockService.getRequestPaths();
111     Assert.assertEquals(1, actualRequests.size());
112 
113     String apiClientHeaderKey =
114         mockService
115             .getRequestHeaders()
116             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
117             .iterator()
118             .next();
119     Assert.assertTrue(
120         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
121             .matcher(apiClientHeaderKey)
122             .matches());
123   }
124 
125   @Test
listInstancesExceptionTest()126   public void listInstancesExceptionTest() throws Exception {
127     ApiException exception =
128         ApiExceptionFactory.createException(
129             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
130     mockService.addException(exception);
131 
132     try {
133       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
134       client.listInstances(parent);
135       Assert.fail("No exception raised");
136     } catch (InvalidArgumentException e) {
137       // Expected exception.
138     }
139   }
140 
141   @Test
listInstancesTest2()142   public void listInstancesTest2() throws Exception {
143     Instance responsesElement = Instance.newBuilder().build();
144     ListInstancesResponse expectedResponse =
145         ListInstancesResponse.newBuilder()
146             .setNextPageToken("")
147             .addAllInstances(Arrays.asList(responsesElement))
148             .build();
149     mockService.addResponse(expectedResponse);
150 
151     String parent = "projects/project-5833/locations/location-5833";
152 
153     ListInstancesPagedResponse pagedListResponse = client.listInstances(parent);
154 
155     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
156 
157     Assert.assertEquals(1, resources.size());
158     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
159 
160     List<String> actualRequests = mockService.getRequestPaths();
161     Assert.assertEquals(1, actualRequests.size());
162 
163     String apiClientHeaderKey =
164         mockService
165             .getRequestHeaders()
166             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
167             .iterator()
168             .next();
169     Assert.assertTrue(
170         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
171             .matcher(apiClientHeaderKey)
172             .matches());
173   }
174 
175   @Test
listInstancesExceptionTest2()176   public void listInstancesExceptionTest2() throws Exception {
177     ApiException exception =
178         ApiExceptionFactory.createException(
179             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
180     mockService.addException(exception);
181 
182     try {
183       String parent = "projects/project-5833/locations/location-5833";
184       client.listInstances(parent);
185       Assert.fail("No exception raised");
186     } catch (InvalidArgumentException e) {
187       // Expected exception.
188     }
189   }
190 
191   @Test
getInstanceTest()192   public void getInstanceTest() throws Exception {
193     Instance expectedResponse =
194         Instance.newBuilder()
195             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
196             .setDisplayName("displayName1714148973")
197             .putAllLabels(new HashMap<String, String>())
198             .setAuthorizedNetwork("authorizedNetwork1515554835")
199             .addAllZones(new ArrayList<String>())
200             .setNodeCount(1539922066)
201             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
202             .setMemcacheVersion(MemcacheVersion.forNumber(0))
203             .setParameters(MemcacheParameters.newBuilder().build())
204             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
205             .setCreateTime(Timestamp.newBuilder().build())
206             .setUpdateTime(Timestamp.newBuilder().build())
207             .setMemcacheFullVersion("memcacheFullVersion976507452")
208             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
209             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
210             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
211             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
212             .build();
213     mockService.addResponse(expectedResponse);
214 
215     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
216 
217     Instance actualResponse = client.getInstance(name);
218     Assert.assertEquals(expectedResponse, actualResponse);
219 
220     List<String> actualRequests = mockService.getRequestPaths();
221     Assert.assertEquals(1, actualRequests.size());
222 
223     String apiClientHeaderKey =
224         mockService
225             .getRequestHeaders()
226             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
227             .iterator()
228             .next();
229     Assert.assertTrue(
230         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
231             .matcher(apiClientHeaderKey)
232             .matches());
233   }
234 
235   @Test
getInstanceExceptionTest()236   public void getInstanceExceptionTest() throws Exception {
237     ApiException exception =
238         ApiExceptionFactory.createException(
239             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
240     mockService.addException(exception);
241 
242     try {
243       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
244       client.getInstance(name);
245       Assert.fail("No exception raised");
246     } catch (InvalidArgumentException e) {
247       // Expected exception.
248     }
249   }
250 
251   @Test
getInstanceTest2()252   public void getInstanceTest2() throws Exception {
253     Instance expectedResponse =
254         Instance.newBuilder()
255             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
256             .setDisplayName("displayName1714148973")
257             .putAllLabels(new HashMap<String, String>())
258             .setAuthorizedNetwork("authorizedNetwork1515554835")
259             .addAllZones(new ArrayList<String>())
260             .setNodeCount(1539922066)
261             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
262             .setMemcacheVersion(MemcacheVersion.forNumber(0))
263             .setParameters(MemcacheParameters.newBuilder().build())
264             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
265             .setCreateTime(Timestamp.newBuilder().build())
266             .setUpdateTime(Timestamp.newBuilder().build())
267             .setMemcacheFullVersion("memcacheFullVersion976507452")
268             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
269             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
270             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
271             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
272             .build();
273     mockService.addResponse(expectedResponse);
274 
275     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
276 
277     Instance actualResponse = client.getInstance(name);
278     Assert.assertEquals(expectedResponse, actualResponse);
279 
280     List<String> actualRequests = mockService.getRequestPaths();
281     Assert.assertEquals(1, actualRequests.size());
282 
283     String apiClientHeaderKey =
284         mockService
285             .getRequestHeaders()
286             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
287             .iterator()
288             .next();
289     Assert.assertTrue(
290         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
291             .matcher(apiClientHeaderKey)
292             .matches());
293   }
294 
295   @Test
getInstanceExceptionTest2()296   public void getInstanceExceptionTest2() throws Exception {
297     ApiException exception =
298         ApiExceptionFactory.createException(
299             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
300     mockService.addException(exception);
301 
302     try {
303       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
304       client.getInstance(name);
305       Assert.fail("No exception raised");
306     } catch (InvalidArgumentException e) {
307       // Expected exception.
308     }
309   }
310 
311   @Test
createInstanceTest()312   public void createInstanceTest() throws Exception {
313     Instance expectedResponse =
314         Instance.newBuilder()
315             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
316             .setDisplayName("displayName1714148973")
317             .putAllLabels(new HashMap<String, String>())
318             .setAuthorizedNetwork("authorizedNetwork1515554835")
319             .addAllZones(new ArrayList<String>())
320             .setNodeCount(1539922066)
321             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
322             .setMemcacheVersion(MemcacheVersion.forNumber(0))
323             .setParameters(MemcacheParameters.newBuilder().build())
324             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
325             .setCreateTime(Timestamp.newBuilder().build())
326             .setUpdateTime(Timestamp.newBuilder().build())
327             .setMemcacheFullVersion("memcacheFullVersion976507452")
328             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
329             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
330             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
331             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
332             .build();
333     Operation resultOperation =
334         Operation.newBuilder()
335             .setName("createInstanceTest")
336             .setDone(true)
337             .setResponse(Any.pack(expectedResponse))
338             .build();
339     mockService.addResponse(resultOperation);
340 
341     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
342     Instance instance = Instance.newBuilder().build();
343     String instanceId = "instanceId902024336";
344 
345     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
346     Assert.assertEquals(expectedResponse, actualResponse);
347 
348     List<String> actualRequests = mockService.getRequestPaths();
349     Assert.assertEquals(1, actualRequests.size());
350 
351     String apiClientHeaderKey =
352         mockService
353             .getRequestHeaders()
354             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
355             .iterator()
356             .next();
357     Assert.assertTrue(
358         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
359             .matcher(apiClientHeaderKey)
360             .matches());
361   }
362 
363   @Test
createInstanceExceptionTest()364   public void createInstanceExceptionTest() throws Exception {
365     ApiException exception =
366         ApiExceptionFactory.createException(
367             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
368     mockService.addException(exception);
369 
370     try {
371       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
372       Instance instance = Instance.newBuilder().build();
373       String instanceId = "instanceId902024336";
374       client.createInstanceAsync(parent, instance, instanceId).get();
375       Assert.fail("No exception raised");
376     } catch (ExecutionException e) {
377     }
378   }
379 
380   @Test
createInstanceTest2()381   public void createInstanceTest2() throws Exception {
382     Instance expectedResponse =
383         Instance.newBuilder()
384             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
385             .setDisplayName("displayName1714148973")
386             .putAllLabels(new HashMap<String, String>())
387             .setAuthorizedNetwork("authorizedNetwork1515554835")
388             .addAllZones(new ArrayList<String>())
389             .setNodeCount(1539922066)
390             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
391             .setMemcacheVersion(MemcacheVersion.forNumber(0))
392             .setParameters(MemcacheParameters.newBuilder().build())
393             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
394             .setCreateTime(Timestamp.newBuilder().build())
395             .setUpdateTime(Timestamp.newBuilder().build())
396             .setMemcacheFullVersion("memcacheFullVersion976507452")
397             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
398             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
399             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
400             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
401             .build();
402     Operation resultOperation =
403         Operation.newBuilder()
404             .setName("createInstanceTest")
405             .setDone(true)
406             .setResponse(Any.pack(expectedResponse))
407             .build();
408     mockService.addResponse(resultOperation);
409 
410     String parent = "projects/project-5833/locations/location-5833";
411     Instance instance = Instance.newBuilder().build();
412     String instanceId = "instanceId902024336";
413 
414     Instance actualResponse = client.createInstanceAsync(parent, instance, instanceId).get();
415     Assert.assertEquals(expectedResponse, actualResponse);
416 
417     List<String> actualRequests = mockService.getRequestPaths();
418     Assert.assertEquals(1, actualRequests.size());
419 
420     String apiClientHeaderKey =
421         mockService
422             .getRequestHeaders()
423             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
424             .iterator()
425             .next();
426     Assert.assertTrue(
427         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
428             .matcher(apiClientHeaderKey)
429             .matches());
430   }
431 
432   @Test
createInstanceExceptionTest2()433   public void createInstanceExceptionTest2() throws Exception {
434     ApiException exception =
435         ApiExceptionFactory.createException(
436             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
437     mockService.addException(exception);
438 
439     try {
440       String parent = "projects/project-5833/locations/location-5833";
441       Instance instance = Instance.newBuilder().build();
442       String instanceId = "instanceId902024336";
443       client.createInstanceAsync(parent, instance, instanceId).get();
444       Assert.fail("No exception raised");
445     } catch (ExecutionException e) {
446     }
447   }
448 
449   @Test
updateInstanceTest()450   public void updateInstanceTest() throws Exception {
451     Instance expectedResponse =
452         Instance.newBuilder()
453             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
454             .setDisplayName("displayName1714148973")
455             .putAllLabels(new HashMap<String, String>())
456             .setAuthorizedNetwork("authorizedNetwork1515554835")
457             .addAllZones(new ArrayList<String>())
458             .setNodeCount(1539922066)
459             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
460             .setMemcacheVersion(MemcacheVersion.forNumber(0))
461             .setParameters(MemcacheParameters.newBuilder().build())
462             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
463             .setCreateTime(Timestamp.newBuilder().build())
464             .setUpdateTime(Timestamp.newBuilder().build())
465             .setMemcacheFullVersion("memcacheFullVersion976507452")
466             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
467             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
468             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
469             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
470             .build();
471     Operation resultOperation =
472         Operation.newBuilder()
473             .setName("updateInstanceTest")
474             .setDone(true)
475             .setResponse(Any.pack(expectedResponse))
476             .build();
477     mockService.addResponse(resultOperation);
478 
479     Instance instance =
480         Instance.newBuilder()
481             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
482             .setDisplayName("displayName1714148973")
483             .putAllLabels(new HashMap<String, String>())
484             .setAuthorizedNetwork("authorizedNetwork1515554835")
485             .addAllZones(new ArrayList<String>())
486             .setNodeCount(1539922066)
487             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
488             .setMemcacheVersion(MemcacheVersion.forNumber(0))
489             .setParameters(MemcacheParameters.newBuilder().build())
490             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
491             .setCreateTime(Timestamp.newBuilder().build())
492             .setUpdateTime(Timestamp.newBuilder().build())
493             .setMemcacheFullVersion("memcacheFullVersion976507452")
494             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
495             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
496             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
497             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
498             .build();
499     FieldMask updateMask = FieldMask.newBuilder().build();
500 
501     Instance actualResponse = client.updateInstanceAsync(instance, updateMask).get();
502     Assert.assertEquals(expectedResponse, actualResponse);
503 
504     List<String> actualRequests = mockService.getRequestPaths();
505     Assert.assertEquals(1, actualRequests.size());
506 
507     String apiClientHeaderKey =
508         mockService
509             .getRequestHeaders()
510             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
511             .iterator()
512             .next();
513     Assert.assertTrue(
514         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
515             .matcher(apiClientHeaderKey)
516             .matches());
517   }
518 
519   @Test
updateInstanceExceptionTest()520   public void updateInstanceExceptionTest() throws Exception {
521     ApiException exception =
522         ApiExceptionFactory.createException(
523             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
524     mockService.addException(exception);
525 
526     try {
527       Instance instance =
528           Instance.newBuilder()
529               .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
530               .setDisplayName("displayName1714148973")
531               .putAllLabels(new HashMap<String, String>())
532               .setAuthorizedNetwork("authorizedNetwork1515554835")
533               .addAllZones(new ArrayList<String>())
534               .setNodeCount(1539922066)
535               .setNodeConfig(Instance.NodeConfig.newBuilder().build())
536               .setMemcacheVersion(MemcacheVersion.forNumber(0))
537               .setParameters(MemcacheParameters.newBuilder().build())
538               .addAllMemcacheNodes(new ArrayList<Instance.Node>())
539               .setCreateTime(Timestamp.newBuilder().build())
540               .setUpdateTime(Timestamp.newBuilder().build())
541               .setMemcacheFullVersion("memcacheFullVersion976507452")
542               .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
543               .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
544               .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
545               .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
546               .build();
547       FieldMask updateMask = FieldMask.newBuilder().build();
548       client.updateInstanceAsync(instance, updateMask).get();
549       Assert.fail("No exception raised");
550     } catch (ExecutionException e) {
551     }
552   }
553 
554   @Test
updateParametersTest()555   public void updateParametersTest() throws Exception {
556     Instance expectedResponse =
557         Instance.newBuilder()
558             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
559             .setDisplayName("displayName1714148973")
560             .putAllLabels(new HashMap<String, String>())
561             .setAuthorizedNetwork("authorizedNetwork1515554835")
562             .addAllZones(new ArrayList<String>())
563             .setNodeCount(1539922066)
564             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
565             .setMemcacheVersion(MemcacheVersion.forNumber(0))
566             .setParameters(MemcacheParameters.newBuilder().build())
567             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
568             .setCreateTime(Timestamp.newBuilder().build())
569             .setUpdateTime(Timestamp.newBuilder().build())
570             .setMemcacheFullVersion("memcacheFullVersion976507452")
571             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
572             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
573             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
574             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
575             .build();
576     Operation resultOperation =
577         Operation.newBuilder()
578             .setName("updateParametersTest")
579             .setDone(true)
580             .setResponse(Any.pack(expectedResponse))
581             .build();
582     mockService.addResponse(resultOperation);
583 
584     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
585     FieldMask updateMask = FieldMask.newBuilder().build();
586     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
587 
588     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
589     Assert.assertEquals(expectedResponse, actualResponse);
590 
591     List<String> actualRequests = mockService.getRequestPaths();
592     Assert.assertEquals(1, actualRequests.size());
593 
594     String apiClientHeaderKey =
595         mockService
596             .getRequestHeaders()
597             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
598             .iterator()
599             .next();
600     Assert.assertTrue(
601         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
602             .matcher(apiClientHeaderKey)
603             .matches());
604   }
605 
606   @Test
updateParametersExceptionTest()607   public void updateParametersExceptionTest() throws Exception {
608     ApiException exception =
609         ApiExceptionFactory.createException(
610             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
611     mockService.addException(exception);
612 
613     try {
614       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
615       FieldMask updateMask = FieldMask.newBuilder().build();
616       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
617       client.updateParametersAsync(name, updateMask, parameters).get();
618       Assert.fail("No exception raised");
619     } catch (ExecutionException e) {
620     }
621   }
622 
623   @Test
updateParametersTest2()624   public void updateParametersTest2() throws Exception {
625     Instance expectedResponse =
626         Instance.newBuilder()
627             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
628             .setDisplayName("displayName1714148973")
629             .putAllLabels(new HashMap<String, String>())
630             .setAuthorizedNetwork("authorizedNetwork1515554835")
631             .addAllZones(new ArrayList<String>())
632             .setNodeCount(1539922066)
633             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
634             .setMemcacheVersion(MemcacheVersion.forNumber(0))
635             .setParameters(MemcacheParameters.newBuilder().build())
636             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
637             .setCreateTime(Timestamp.newBuilder().build())
638             .setUpdateTime(Timestamp.newBuilder().build())
639             .setMemcacheFullVersion("memcacheFullVersion976507452")
640             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
641             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
642             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
643             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
644             .build();
645     Operation resultOperation =
646         Operation.newBuilder()
647             .setName("updateParametersTest")
648             .setDone(true)
649             .setResponse(Any.pack(expectedResponse))
650             .build();
651     mockService.addResponse(resultOperation);
652 
653     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
654     FieldMask updateMask = FieldMask.newBuilder().build();
655     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
656 
657     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
658     Assert.assertEquals(expectedResponse, actualResponse);
659 
660     List<String> actualRequests = mockService.getRequestPaths();
661     Assert.assertEquals(1, actualRequests.size());
662 
663     String apiClientHeaderKey =
664         mockService
665             .getRequestHeaders()
666             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
667             .iterator()
668             .next();
669     Assert.assertTrue(
670         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
671             .matcher(apiClientHeaderKey)
672             .matches());
673   }
674 
675   @Test
updateParametersExceptionTest2()676   public void updateParametersExceptionTest2() throws Exception {
677     ApiException exception =
678         ApiExceptionFactory.createException(
679             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
680     mockService.addException(exception);
681 
682     try {
683       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
684       FieldMask updateMask = FieldMask.newBuilder().build();
685       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
686       client.updateParametersAsync(name, updateMask, parameters).get();
687       Assert.fail("No exception raised");
688     } catch (ExecutionException e) {
689     }
690   }
691 
692   @Test
deleteInstanceTest()693   public void deleteInstanceTest() throws Exception {
694     Empty expectedResponse = Empty.newBuilder().build();
695     Operation resultOperation =
696         Operation.newBuilder()
697             .setName("deleteInstanceTest")
698             .setDone(true)
699             .setResponse(Any.pack(expectedResponse))
700             .build();
701     mockService.addResponse(resultOperation);
702 
703     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
704 
705     client.deleteInstanceAsync(name).get();
706 
707     List<String> actualRequests = mockService.getRequestPaths();
708     Assert.assertEquals(1, actualRequests.size());
709 
710     String apiClientHeaderKey =
711         mockService
712             .getRequestHeaders()
713             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
714             .iterator()
715             .next();
716     Assert.assertTrue(
717         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
718             .matcher(apiClientHeaderKey)
719             .matches());
720   }
721 
722   @Test
deleteInstanceExceptionTest()723   public void deleteInstanceExceptionTest() throws Exception {
724     ApiException exception =
725         ApiExceptionFactory.createException(
726             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
727     mockService.addException(exception);
728 
729     try {
730       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
731       client.deleteInstanceAsync(name).get();
732       Assert.fail("No exception raised");
733     } catch (ExecutionException e) {
734     }
735   }
736 
737   @Test
deleteInstanceTest2()738   public void deleteInstanceTest2() throws Exception {
739     Empty expectedResponse = Empty.newBuilder().build();
740     Operation resultOperation =
741         Operation.newBuilder()
742             .setName("deleteInstanceTest")
743             .setDone(true)
744             .setResponse(Any.pack(expectedResponse))
745             .build();
746     mockService.addResponse(resultOperation);
747 
748     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
749 
750     client.deleteInstanceAsync(name).get();
751 
752     List<String> actualRequests = mockService.getRequestPaths();
753     Assert.assertEquals(1, actualRequests.size());
754 
755     String apiClientHeaderKey =
756         mockService
757             .getRequestHeaders()
758             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
759             .iterator()
760             .next();
761     Assert.assertTrue(
762         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
763             .matcher(apiClientHeaderKey)
764             .matches());
765   }
766 
767   @Test
deleteInstanceExceptionTest2()768   public void deleteInstanceExceptionTest2() throws Exception {
769     ApiException exception =
770         ApiExceptionFactory.createException(
771             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
772     mockService.addException(exception);
773 
774     try {
775       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
776       client.deleteInstanceAsync(name).get();
777       Assert.fail("No exception raised");
778     } catch (ExecutionException e) {
779     }
780   }
781 
782   @Test
applyParametersTest()783   public void applyParametersTest() throws Exception {
784     Instance expectedResponse =
785         Instance.newBuilder()
786             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
787             .setDisplayName("displayName1714148973")
788             .putAllLabels(new HashMap<String, String>())
789             .setAuthorizedNetwork("authorizedNetwork1515554835")
790             .addAllZones(new ArrayList<String>())
791             .setNodeCount(1539922066)
792             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
793             .setMemcacheVersion(MemcacheVersion.forNumber(0))
794             .setParameters(MemcacheParameters.newBuilder().build())
795             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
796             .setCreateTime(Timestamp.newBuilder().build())
797             .setUpdateTime(Timestamp.newBuilder().build())
798             .setMemcacheFullVersion("memcacheFullVersion976507452")
799             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
800             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
801             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
802             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
803             .build();
804     Operation resultOperation =
805         Operation.newBuilder()
806             .setName("applyParametersTest")
807             .setDone(true)
808             .setResponse(Any.pack(expectedResponse))
809             .build();
810     mockService.addResponse(resultOperation);
811 
812     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
813     List<String> nodeIds = new ArrayList<>();
814     boolean applyAll = true;
815 
816     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
817     Assert.assertEquals(expectedResponse, actualResponse);
818 
819     List<String> actualRequests = mockService.getRequestPaths();
820     Assert.assertEquals(1, actualRequests.size());
821 
822     String apiClientHeaderKey =
823         mockService
824             .getRequestHeaders()
825             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
826             .iterator()
827             .next();
828     Assert.assertTrue(
829         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
830             .matcher(apiClientHeaderKey)
831             .matches());
832   }
833 
834   @Test
applyParametersExceptionTest()835   public void applyParametersExceptionTest() throws Exception {
836     ApiException exception =
837         ApiExceptionFactory.createException(
838             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
839     mockService.addException(exception);
840 
841     try {
842       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
843       List<String> nodeIds = new ArrayList<>();
844       boolean applyAll = true;
845       client.applyParametersAsync(name, nodeIds, applyAll).get();
846       Assert.fail("No exception raised");
847     } catch (ExecutionException e) {
848     }
849   }
850 
851   @Test
applyParametersTest2()852   public void applyParametersTest2() 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("applyParametersTest")
876             .setDone(true)
877             .setResponse(Any.pack(expectedResponse))
878             .build();
879     mockService.addResponse(resultOperation);
880 
881     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
882     List<String> nodeIds = new ArrayList<>();
883     boolean applyAll = true;
884 
885     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
886     Assert.assertEquals(expectedResponse, actualResponse);
887 
888     List<String> actualRequests = mockService.getRequestPaths();
889     Assert.assertEquals(1, actualRequests.size());
890 
891     String apiClientHeaderKey =
892         mockService
893             .getRequestHeaders()
894             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
895             .iterator()
896             .next();
897     Assert.assertTrue(
898         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
899             .matcher(apiClientHeaderKey)
900             .matches());
901   }
902 
903   @Test
applyParametersExceptionTest2()904   public void applyParametersExceptionTest2() throws Exception {
905     ApiException exception =
906         ApiExceptionFactory.createException(
907             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
908     mockService.addException(exception);
909 
910     try {
911       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
912       List<String> nodeIds = new ArrayList<>();
913       boolean applyAll = true;
914       client.applyParametersAsync(name, nodeIds, applyAll).get();
915       Assert.fail("No exception raised");
916     } catch (ExecutionException e) {
917     }
918   }
919 
920   @Test
rescheduleMaintenanceTest()921   public void rescheduleMaintenanceTest() throws Exception {
922     Instance expectedResponse =
923         Instance.newBuilder()
924             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
925             .setDisplayName("displayName1714148973")
926             .putAllLabels(new HashMap<String, String>())
927             .setAuthorizedNetwork("authorizedNetwork1515554835")
928             .addAllZones(new ArrayList<String>())
929             .setNodeCount(1539922066)
930             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
931             .setMemcacheVersion(MemcacheVersion.forNumber(0))
932             .setParameters(MemcacheParameters.newBuilder().build())
933             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
934             .setCreateTime(Timestamp.newBuilder().build())
935             .setUpdateTime(Timestamp.newBuilder().build())
936             .setMemcacheFullVersion("memcacheFullVersion976507452")
937             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
938             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
939             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
940             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
941             .build();
942     Operation resultOperation =
943         Operation.newBuilder()
944             .setName("rescheduleMaintenanceTest")
945             .setDone(true)
946             .setResponse(Any.pack(expectedResponse))
947             .build();
948     mockService.addResponse(resultOperation);
949 
950     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
951     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
952         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
953     Timestamp scheduleTime = Timestamp.newBuilder().build();
954 
955     Instance actualResponse =
956         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
957     Assert.assertEquals(expectedResponse, actualResponse);
958 
959     List<String> actualRequests = mockService.getRequestPaths();
960     Assert.assertEquals(1, actualRequests.size());
961 
962     String apiClientHeaderKey =
963         mockService
964             .getRequestHeaders()
965             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
966             .iterator()
967             .next();
968     Assert.assertTrue(
969         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
970             .matcher(apiClientHeaderKey)
971             .matches());
972   }
973 
974   @Test
rescheduleMaintenanceExceptionTest()975   public void rescheduleMaintenanceExceptionTest() throws Exception {
976     ApiException exception =
977         ApiExceptionFactory.createException(
978             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
979     mockService.addException(exception);
980 
981     try {
982       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
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     }
990   }
991 
992   @Test
rescheduleMaintenanceTest2()993   public void rescheduleMaintenanceTest2() throws Exception {
994     Instance expectedResponse =
995         Instance.newBuilder()
996             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
997             .setDisplayName("displayName1714148973")
998             .putAllLabels(new HashMap<String, String>())
999             .setAuthorizedNetwork("authorizedNetwork1515554835")
1000             .addAllZones(new ArrayList<String>())
1001             .setNodeCount(1539922066)
1002             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1003             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1004             .setParameters(MemcacheParameters.newBuilder().build())
1005             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1006             .setCreateTime(Timestamp.newBuilder().build())
1007             .setUpdateTime(Timestamp.newBuilder().build())
1008             .setMemcacheFullVersion("memcacheFullVersion976507452")
1009             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1010             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1011             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1012             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1013             .build();
1014     Operation resultOperation =
1015         Operation.newBuilder()
1016             .setName("rescheduleMaintenanceTest")
1017             .setDone(true)
1018             .setResponse(Any.pack(expectedResponse))
1019             .build();
1020     mockService.addResponse(resultOperation);
1021 
1022     String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1023     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1024         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1025     Timestamp scheduleTime = Timestamp.newBuilder().build();
1026 
1027     Instance actualResponse =
1028         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1029     Assert.assertEquals(expectedResponse, actualResponse);
1030 
1031     List<String> actualRequests = mockService.getRequestPaths();
1032     Assert.assertEquals(1, actualRequests.size());
1033 
1034     String apiClientHeaderKey =
1035         mockService
1036             .getRequestHeaders()
1037             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1038             .iterator()
1039             .next();
1040     Assert.assertTrue(
1041         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1042             .matcher(apiClientHeaderKey)
1043             .matches());
1044   }
1045 
1046   @Test
rescheduleMaintenanceExceptionTest2()1047   public void rescheduleMaintenanceExceptionTest2() throws Exception {
1048     ApiException exception =
1049         ApiExceptionFactory.createException(
1050             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1051     mockService.addException(exception);
1052 
1053     try {
1054       String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1055       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1056           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1057       Timestamp scheduleTime = Timestamp.newBuilder().build();
1058       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1059       Assert.fail("No exception raised");
1060     } catch (ExecutionException e) {
1061     }
1062   }
1063 
1064   @Test
listLocationsTest()1065   public void listLocationsTest() throws Exception {
1066     Location responsesElement = Location.newBuilder().build();
1067     ListLocationsResponse expectedResponse =
1068         ListLocationsResponse.newBuilder()
1069             .setNextPageToken("")
1070             .addAllLocations(Arrays.asList(responsesElement))
1071             .build();
1072     mockService.addResponse(expectedResponse);
1073 
1074     ListLocationsRequest request =
1075         ListLocationsRequest.newBuilder()
1076             .setName("projects/project-3664")
1077             .setFilter("filter-1274492040")
1078             .setPageSize(883849137)
1079             .setPageToken("pageToken873572522")
1080             .build();
1081 
1082     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1083 
1084     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1085 
1086     Assert.assertEquals(1, resources.size());
1087     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1088 
1089     List<String> actualRequests = mockService.getRequestPaths();
1090     Assert.assertEquals(1, actualRequests.size());
1091 
1092     String apiClientHeaderKey =
1093         mockService
1094             .getRequestHeaders()
1095             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1096             .iterator()
1097             .next();
1098     Assert.assertTrue(
1099         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1100             .matcher(apiClientHeaderKey)
1101             .matches());
1102   }
1103 
1104   @Test
listLocationsExceptionTest()1105   public void listLocationsExceptionTest() throws Exception {
1106     ApiException exception =
1107         ApiExceptionFactory.createException(
1108             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1109     mockService.addException(exception);
1110 
1111     try {
1112       ListLocationsRequest request =
1113           ListLocationsRequest.newBuilder()
1114               .setName("projects/project-3664")
1115               .setFilter("filter-1274492040")
1116               .setPageSize(883849137)
1117               .setPageToken("pageToken873572522")
1118               .build();
1119       client.listLocations(request);
1120       Assert.fail("No exception raised");
1121     } catch (InvalidArgumentException e) {
1122       // Expected exception.
1123     }
1124   }
1125 
1126   @Test
getLocationTest()1127   public void getLocationTest() throws Exception {
1128     Location expectedResponse =
1129         Location.newBuilder()
1130             .setName("name3373707")
1131             .setLocationId("locationId1541836720")
1132             .setDisplayName("displayName1714148973")
1133             .putAllLabels(new HashMap<String, String>())
1134             .setMetadata(Any.newBuilder().build())
1135             .build();
1136     mockService.addResponse(expectedResponse);
1137 
1138     GetLocationRequest request =
1139         GetLocationRequest.newBuilder()
1140             .setName("projects/project-9062/locations/location-9062")
1141             .build();
1142 
1143     Location actualResponse = client.getLocation(request);
1144     Assert.assertEquals(expectedResponse, actualResponse);
1145 
1146     List<String> actualRequests = mockService.getRequestPaths();
1147     Assert.assertEquals(1, actualRequests.size());
1148 
1149     String apiClientHeaderKey =
1150         mockService
1151             .getRequestHeaders()
1152             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1153             .iterator()
1154             .next();
1155     Assert.assertTrue(
1156         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1157             .matcher(apiClientHeaderKey)
1158             .matches());
1159   }
1160 
1161   @Test
getLocationExceptionTest()1162   public void getLocationExceptionTest() throws Exception {
1163     ApiException exception =
1164         ApiExceptionFactory.createException(
1165             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1166     mockService.addException(exception);
1167 
1168     try {
1169       GetLocationRequest request =
1170           GetLocationRequest.newBuilder()
1171               .setName("projects/project-9062/locations/location-9062")
1172               .build();
1173       client.getLocation(request);
1174       Assert.fail("No exception raised");
1175     } catch (InvalidArgumentException e) {
1176       // Expected exception.
1177     }
1178   }
1179 }
1180