• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.memcache.v1beta2;
18 
19 import static com.google.cloud.memcache.v1beta2.CloudMemcacheClient.ListInstancesPagedResponse;
20 import static com.google.cloud.memcache.v1beta2.CloudMemcacheClient.ListLocationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.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.v1beta2.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             .addAllResources(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.getResourcesList().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             .addAllResources(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.getResourcesList().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             .setUpdateAvailable(true)
211             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
212             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
213             .build();
214     mockService.addResponse(expectedResponse);
215 
216     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
217 
218     Instance actualResponse = client.getInstance(name);
219     Assert.assertEquals(expectedResponse, actualResponse);
220 
221     List<String> actualRequests = mockService.getRequestPaths();
222     Assert.assertEquals(1, actualRequests.size());
223 
224     String apiClientHeaderKey =
225         mockService
226             .getRequestHeaders()
227             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
228             .iterator()
229             .next();
230     Assert.assertTrue(
231         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
232             .matcher(apiClientHeaderKey)
233             .matches());
234   }
235 
236   @Test
getInstanceExceptionTest()237   public void getInstanceExceptionTest() throws Exception {
238     ApiException exception =
239         ApiExceptionFactory.createException(
240             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
241     mockService.addException(exception);
242 
243     try {
244       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
245       client.getInstance(name);
246       Assert.fail("No exception raised");
247     } catch (InvalidArgumentException e) {
248       // Expected exception.
249     }
250   }
251 
252   @Test
getInstanceTest2()253   public void getInstanceTest2() throws Exception {
254     Instance expectedResponse =
255         Instance.newBuilder()
256             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
257             .setDisplayName("displayName1714148973")
258             .putAllLabels(new HashMap<String, String>())
259             .setAuthorizedNetwork("authorizedNetwork1515554835")
260             .addAllZones(new ArrayList<String>())
261             .setNodeCount(1539922066)
262             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
263             .setMemcacheVersion(MemcacheVersion.forNumber(0))
264             .setParameters(MemcacheParameters.newBuilder().build())
265             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
266             .setCreateTime(Timestamp.newBuilder().build())
267             .setUpdateTime(Timestamp.newBuilder().build())
268             .setMemcacheFullVersion("memcacheFullVersion976507452")
269             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
270             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
271             .setUpdateAvailable(true)
272             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
273             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
274             .build();
275     mockService.addResponse(expectedResponse);
276 
277     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
278 
279     Instance actualResponse = client.getInstance(name);
280     Assert.assertEquals(expectedResponse, actualResponse);
281 
282     List<String> actualRequests = mockService.getRequestPaths();
283     Assert.assertEquals(1, actualRequests.size());
284 
285     String apiClientHeaderKey =
286         mockService
287             .getRequestHeaders()
288             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
289             .iterator()
290             .next();
291     Assert.assertTrue(
292         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
293             .matcher(apiClientHeaderKey)
294             .matches());
295   }
296 
297   @Test
getInstanceExceptionTest2()298   public void getInstanceExceptionTest2() throws Exception {
299     ApiException exception =
300         ApiExceptionFactory.createException(
301             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
302     mockService.addException(exception);
303 
304     try {
305       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
306       client.getInstance(name);
307       Assert.fail("No exception raised");
308     } catch (InvalidArgumentException e) {
309       // Expected exception.
310     }
311   }
312 
313   @Test
createInstanceTest()314   public void createInstanceTest() throws Exception {
315     Instance expectedResponse =
316         Instance.newBuilder()
317             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
318             .setDisplayName("displayName1714148973")
319             .putAllLabels(new HashMap<String, String>())
320             .setAuthorizedNetwork("authorizedNetwork1515554835")
321             .addAllZones(new ArrayList<String>())
322             .setNodeCount(1539922066)
323             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
324             .setMemcacheVersion(MemcacheVersion.forNumber(0))
325             .setParameters(MemcacheParameters.newBuilder().build())
326             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
327             .setCreateTime(Timestamp.newBuilder().build())
328             .setUpdateTime(Timestamp.newBuilder().build())
329             .setMemcacheFullVersion("memcacheFullVersion976507452")
330             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
331             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
332             .setUpdateAvailable(true)
333             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
334             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
335             .build();
336     Operation resultOperation =
337         Operation.newBuilder()
338             .setName("createInstanceTest")
339             .setDone(true)
340             .setResponse(Any.pack(expectedResponse))
341             .build();
342     mockService.addResponse(resultOperation);
343 
344     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
345     String instanceId = "instanceId902024336";
346     Instance resource = Instance.newBuilder().build();
347 
348     Instance actualResponse = client.createInstanceAsync(parent, instanceId, resource).get();
349     Assert.assertEquals(expectedResponse, actualResponse);
350 
351     List<String> actualRequests = mockService.getRequestPaths();
352     Assert.assertEquals(1, actualRequests.size());
353 
354     String apiClientHeaderKey =
355         mockService
356             .getRequestHeaders()
357             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
358             .iterator()
359             .next();
360     Assert.assertTrue(
361         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
362             .matcher(apiClientHeaderKey)
363             .matches());
364   }
365 
366   @Test
createInstanceExceptionTest()367   public void createInstanceExceptionTest() throws Exception {
368     ApiException exception =
369         ApiExceptionFactory.createException(
370             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
371     mockService.addException(exception);
372 
373     try {
374       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
375       String instanceId = "instanceId902024336";
376       Instance resource = Instance.newBuilder().build();
377       client.createInstanceAsync(parent, instanceId, resource).get();
378       Assert.fail("No exception raised");
379     } catch (ExecutionException e) {
380     }
381   }
382 
383   @Test
createInstanceTest2()384   public void createInstanceTest2() throws Exception {
385     Instance expectedResponse =
386         Instance.newBuilder()
387             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
388             .setDisplayName("displayName1714148973")
389             .putAllLabels(new HashMap<String, String>())
390             .setAuthorizedNetwork("authorizedNetwork1515554835")
391             .addAllZones(new ArrayList<String>())
392             .setNodeCount(1539922066)
393             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
394             .setMemcacheVersion(MemcacheVersion.forNumber(0))
395             .setParameters(MemcacheParameters.newBuilder().build())
396             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
397             .setCreateTime(Timestamp.newBuilder().build())
398             .setUpdateTime(Timestamp.newBuilder().build())
399             .setMemcacheFullVersion("memcacheFullVersion976507452")
400             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
401             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
402             .setUpdateAvailable(true)
403             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
404             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
405             .build();
406     Operation resultOperation =
407         Operation.newBuilder()
408             .setName("createInstanceTest")
409             .setDone(true)
410             .setResponse(Any.pack(expectedResponse))
411             .build();
412     mockService.addResponse(resultOperation);
413 
414     String parent = "projects/project-5833/locations/location-5833";
415     String instanceId = "instanceId902024336";
416     Instance resource = Instance.newBuilder().build();
417 
418     Instance actualResponse = client.createInstanceAsync(parent, instanceId, resource).get();
419     Assert.assertEquals(expectedResponse, actualResponse);
420 
421     List<String> actualRequests = mockService.getRequestPaths();
422     Assert.assertEquals(1, actualRequests.size());
423 
424     String apiClientHeaderKey =
425         mockService
426             .getRequestHeaders()
427             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
428             .iterator()
429             .next();
430     Assert.assertTrue(
431         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
432             .matcher(apiClientHeaderKey)
433             .matches());
434   }
435 
436   @Test
createInstanceExceptionTest2()437   public void createInstanceExceptionTest2() throws Exception {
438     ApiException exception =
439         ApiExceptionFactory.createException(
440             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
441     mockService.addException(exception);
442 
443     try {
444       String parent = "projects/project-5833/locations/location-5833";
445       String instanceId = "instanceId902024336";
446       Instance resource = Instance.newBuilder().build();
447       client.createInstanceAsync(parent, instanceId, resource).get();
448       Assert.fail("No exception raised");
449     } catch (ExecutionException e) {
450     }
451   }
452 
453   @Test
updateInstanceTest()454   public void updateInstanceTest() throws Exception {
455     Instance expectedResponse =
456         Instance.newBuilder()
457             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
458             .setDisplayName("displayName1714148973")
459             .putAllLabels(new HashMap<String, String>())
460             .setAuthorizedNetwork("authorizedNetwork1515554835")
461             .addAllZones(new ArrayList<String>())
462             .setNodeCount(1539922066)
463             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
464             .setMemcacheVersion(MemcacheVersion.forNumber(0))
465             .setParameters(MemcacheParameters.newBuilder().build())
466             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
467             .setCreateTime(Timestamp.newBuilder().build())
468             .setUpdateTime(Timestamp.newBuilder().build())
469             .setMemcacheFullVersion("memcacheFullVersion976507452")
470             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
471             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
472             .setUpdateAvailable(true)
473             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
474             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
475             .build();
476     Operation resultOperation =
477         Operation.newBuilder()
478             .setName("updateInstanceTest")
479             .setDone(true)
480             .setResponse(Any.pack(expectedResponse))
481             .build();
482     mockService.addResponse(resultOperation);
483 
484     FieldMask updateMask = FieldMask.newBuilder().build();
485     Instance resource =
486         Instance.newBuilder()
487             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
488             .setDisplayName("displayName1714148973")
489             .putAllLabels(new HashMap<String, String>())
490             .setAuthorizedNetwork("authorizedNetwork1515554835")
491             .addAllZones(new ArrayList<String>())
492             .setNodeCount(1539922066)
493             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
494             .setMemcacheVersion(MemcacheVersion.forNumber(0))
495             .setParameters(MemcacheParameters.newBuilder().build())
496             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
497             .setCreateTime(Timestamp.newBuilder().build())
498             .setUpdateTime(Timestamp.newBuilder().build())
499             .setMemcacheFullVersion("memcacheFullVersion976507452")
500             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
501             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
502             .setUpdateAvailable(true)
503             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
504             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
505             .build();
506 
507     Instance actualResponse = client.updateInstanceAsync(updateMask, resource).get();
508     Assert.assertEquals(expectedResponse, actualResponse);
509 
510     List<String> actualRequests = mockService.getRequestPaths();
511     Assert.assertEquals(1, actualRequests.size());
512 
513     String apiClientHeaderKey =
514         mockService
515             .getRequestHeaders()
516             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
517             .iterator()
518             .next();
519     Assert.assertTrue(
520         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
521             .matcher(apiClientHeaderKey)
522             .matches());
523   }
524 
525   @Test
updateInstanceExceptionTest()526   public void updateInstanceExceptionTest() throws Exception {
527     ApiException exception =
528         ApiExceptionFactory.createException(
529             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
530     mockService.addException(exception);
531 
532     try {
533       FieldMask updateMask = FieldMask.newBuilder().build();
534       Instance resource =
535           Instance.newBuilder()
536               .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
537               .setDisplayName("displayName1714148973")
538               .putAllLabels(new HashMap<String, String>())
539               .setAuthorizedNetwork("authorizedNetwork1515554835")
540               .addAllZones(new ArrayList<String>())
541               .setNodeCount(1539922066)
542               .setNodeConfig(Instance.NodeConfig.newBuilder().build())
543               .setMemcacheVersion(MemcacheVersion.forNumber(0))
544               .setParameters(MemcacheParameters.newBuilder().build())
545               .addAllMemcacheNodes(new ArrayList<Instance.Node>())
546               .setCreateTime(Timestamp.newBuilder().build())
547               .setUpdateTime(Timestamp.newBuilder().build())
548               .setMemcacheFullVersion("memcacheFullVersion976507452")
549               .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
550               .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
551               .setUpdateAvailable(true)
552               .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
553               .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
554               .build();
555       client.updateInstanceAsync(updateMask, resource).get();
556       Assert.fail("No exception raised");
557     } catch (ExecutionException e) {
558     }
559   }
560 
561   @Test
updateParametersTest()562   public void updateParametersTest() throws Exception {
563     Instance expectedResponse =
564         Instance.newBuilder()
565             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
566             .setDisplayName("displayName1714148973")
567             .putAllLabels(new HashMap<String, String>())
568             .setAuthorizedNetwork("authorizedNetwork1515554835")
569             .addAllZones(new ArrayList<String>())
570             .setNodeCount(1539922066)
571             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
572             .setMemcacheVersion(MemcacheVersion.forNumber(0))
573             .setParameters(MemcacheParameters.newBuilder().build())
574             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
575             .setCreateTime(Timestamp.newBuilder().build())
576             .setUpdateTime(Timestamp.newBuilder().build())
577             .setMemcacheFullVersion("memcacheFullVersion976507452")
578             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
579             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
580             .setUpdateAvailable(true)
581             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
582             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
583             .build();
584     Operation resultOperation =
585         Operation.newBuilder()
586             .setName("updateParametersTest")
587             .setDone(true)
588             .setResponse(Any.pack(expectedResponse))
589             .build();
590     mockService.addResponse(resultOperation);
591 
592     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
593     FieldMask updateMask = FieldMask.newBuilder().build();
594     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
595 
596     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
597     Assert.assertEquals(expectedResponse, actualResponse);
598 
599     List<String> actualRequests = mockService.getRequestPaths();
600     Assert.assertEquals(1, actualRequests.size());
601 
602     String apiClientHeaderKey =
603         mockService
604             .getRequestHeaders()
605             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
606             .iterator()
607             .next();
608     Assert.assertTrue(
609         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
610             .matcher(apiClientHeaderKey)
611             .matches());
612   }
613 
614   @Test
updateParametersExceptionTest()615   public void updateParametersExceptionTest() throws Exception {
616     ApiException exception =
617         ApiExceptionFactory.createException(
618             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
619     mockService.addException(exception);
620 
621     try {
622       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
623       FieldMask updateMask = FieldMask.newBuilder().build();
624       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
625       client.updateParametersAsync(name, updateMask, parameters).get();
626       Assert.fail("No exception raised");
627     } catch (ExecutionException e) {
628     }
629   }
630 
631   @Test
updateParametersTest2()632   public void updateParametersTest2() throws Exception {
633     Instance expectedResponse =
634         Instance.newBuilder()
635             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
636             .setDisplayName("displayName1714148973")
637             .putAllLabels(new HashMap<String, String>())
638             .setAuthorizedNetwork("authorizedNetwork1515554835")
639             .addAllZones(new ArrayList<String>())
640             .setNodeCount(1539922066)
641             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
642             .setMemcacheVersion(MemcacheVersion.forNumber(0))
643             .setParameters(MemcacheParameters.newBuilder().build())
644             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
645             .setCreateTime(Timestamp.newBuilder().build())
646             .setUpdateTime(Timestamp.newBuilder().build())
647             .setMemcacheFullVersion("memcacheFullVersion976507452")
648             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
649             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
650             .setUpdateAvailable(true)
651             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
652             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
653             .build();
654     Operation resultOperation =
655         Operation.newBuilder()
656             .setName("updateParametersTest")
657             .setDone(true)
658             .setResponse(Any.pack(expectedResponse))
659             .build();
660     mockService.addResponse(resultOperation);
661 
662     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
663     FieldMask updateMask = FieldMask.newBuilder().build();
664     MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
665 
666     Instance actualResponse = client.updateParametersAsync(name, updateMask, parameters).get();
667     Assert.assertEquals(expectedResponse, actualResponse);
668 
669     List<String> actualRequests = mockService.getRequestPaths();
670     Assert.assertEquals(1, actualRequests.size());
671 
672     String apiClientHeaderKey =
673         mockService
674             .getRequestHeaders()
675             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
676             .iterator()
677             .next();
678     Assert.assertTrue(
679         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
680             .matcher(apiClientHeaderKey)
681             .matches());
682   }
683 
684   @Test
updateParametersExceptionTest2()685   public void updateParametersExceptionTest2() throws Exception {
686     ApiException exception =
687         ApiExceptionFactory.createException(
688             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
689     mockService.addException(exception);
690 
691     try {
692       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
693       FieldMask updateMask = FieldMask.newBuilder().build();
694       MemcacheParameters parameters = MemcacheParameters.newBuilder().build();
695       client.updateParametersAsync(name, updateMask, parameters).get();
696       Assert.fail("No exception raised");
697     } catch (ExecutionException e) {
698     }
699   }
700 
701   @Test
deleteInstanceTest()702   public void deleteInstanceTest() throws Exception {
703     Empty expectedResponse = Empty.newBuilder().build();
704     Operation resultOperation =
705         Operation.newBuilder()
706             .setName("deleteInstanceTest")
707             .setDone(true)
708             .setResponse(Any.pack(expectedResponse))
709             .build();
710     mockService.addResponse(resultOperation);
711 
712     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
713 
714     client.deleteInstanceAsync(name).get();
715 
716     List<String> actualRequests = mockService.getRequestPaths();
717     Assert.assertEquals(1, actualRequests.size());
718 
719     String apiClientHeaderKey =
720         mockService
721             .getRequestHeaders()
722             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
723             .iterator()
724             .next();
725     Assert.assertTrue(
726         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
727             .matcher(apiClientHeaderKey)
728             .matches());
729   }
730 
731   @Test
deleteInstanceExceptionTest()732   public void deleteInstanceExceptionTest() throws Exception {
733     ApiException exception =
734         ApiExceptionFactory.createException(
735             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
736     mockService.addException(exception);
737 
738     try {
739       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
740       client.deleteInstanceAsync(name).get();
741       Assert.fail("No exception raised");
742     } catch (ExecutionException e) {
743     }
744   }
745 
746   @Test
deleteInstanceTest2()747   public void deleteInstanceTest2() throws Exception {
748     Empty expectedResponse = Empty.newBuilder().build();
749     Operation resultOperation =
750         Operation.newBuilder()
751             .setName("deleteInstanceTest")
752             .setDone(true)
753             .setResponse(Any.pack(expectedResponse))
754             .build();
755     mockService.addResponse(resultOperation);
756 
757     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
758 
759     client.deleteInstanceAsync(name).get();
760 
761     List<String> actualRequests = mockService.getRequestPaths();
762     Assert.assertEquals(1, actualRequests.size());
763 
764     String apiClientHeaderKey =
765         mockService
766             .getRequestHeaders()
767             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
768             .iterator()
769             .next();
770     Assert.assertTrue(
771         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
772             .matcher(apiClientHeaderKey)
773             .matches());
774   }
775 
776   @Test
deleteInstanceExceptionTest2()777   public void deleteInstanceExceptionTest2() throws Exception {
778     ApiException exception =
779         ApiExceptionFactory.createException(
780             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
781     mockService.addException(exception);
782 
783     try {
784       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
785       client.deleteInstanceAsync(name).get();
786       Assert.fail("No exception raised");
787     } catch (ExecutionException e) {
788     }
789   }
790 
791   @Test
applyParametersTest()792   public void applyParametersTest() throws Exception {
793     Instance expectedResponse =
794         Instance.newBuilder()
795             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
796             .setDisplayName("displayName1714148973")
797             .putAllLabels(new HashMap<String, String>())
798             .setAuthorizedNetwork("authorizedNetwork1515554835")
799             .addAllZones(new ArrayList<String>())
800             .setNodeCount(1539922066)
801             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
802             .setMemcacheVersion(MemcacheVersion.forNumber(0))
803             .setParameters(MemcacheParameters.newBuilder().build())
804             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
805             .setCreateTime(Timestamp.newBuilder().build())
806             .setUpdateTime(Timestamp.newBuilder().build())
807             .setMemcacheFullVersion("memcacheFullVersion976507452")
808             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
809             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
810             .setUpdateAvailable(true)
811             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
812             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
813             .build();
814     Operation resultOperation =
815         Operation.newBuilder()
816             .setName("applyParametersTest")
817             .setDone(true)
818             .setResponse(Any.pack(expectedResponse))
819             .build();
820     mockService.addResponse(resultOperation);
821 
822     InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
823     List<String> nodeIds = new ArrayList<>();
824     boolean applyAll = true;
825 
826     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
827     Assert.assertEquals(expectedResponse, actualResponse);
828 
829     List<String> actualRequests = mockService.getRequestPaths();
830     Assert.assertEquals(1, actualRequests.size());
831 
832     String apiClientHeaderKey =
833         mockService
834             .getRequestHeaders()
835             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
836             .iterator()
837             .next();
838     Assert.assertTrue(
839         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
840             .matcher(apiClientHeaderKey)
841             .matches());
842   }
843 
844   @Test
applyParametersExceptionTest()845   public void applyParametersExceptionTest() throws Exception {
846     ApiException exception =
847         ApiExceptionFactory.createException(
848             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
849     mockService.addException(exception);
850 
851     try {
852       InstanceName name = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
853       List<String> nodeIds = new ArrayList<>();
854       boolean applyAll = true;
855       client.applyParametersAsync(name, nodeIds, applyAll).get();
856       Assert.fail("No exception raised");
857     } catch (ExecutionException e) {
858     }
859   }
860 
861   @Test
applyParametersTest2()862   public void applyParametersTest2() throws Exception {
863     Instance expectedResponse =
864         Instance.newBuilder()
865             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
866             .setDisplayName("displayName1714148973")
867             .putAllLabels(new HashMap<String, String>())
868             .setAuthorizedNetwork("authorizedNetwork1515554835")
869             .addAllZones(new ArrayList<String>())
870             .setNodeCount(1539922066)
871             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
872             .setMemcacheVersion(MemcacheVersion.forNumber(0))
873             .setParameters(MemcacheParameters.newBuilder().build())
874             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
875             .setCreateTime(Timestamp.newBuilder().build())
876             .setUpdateTime(Timestamp.newBuilder().build())
877             .setMemcacheFullVersion("memcacheFullVersion976507452")
878             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
879             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
880             .setUpdateAvailable(true)
881             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
882             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
883             .build();
884     Operation resultOperation =
885         Operation.newBuilder()
886             .setName("applyParametersTest")
887             .setDone(true)
888             .setResponse(Any.pack(expectedResponse))
889             .build();
890     mockService.addResponse(resultOperation);
891 
892     String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
893     List<String> nodeIds = new ArrayList<>();
894     boolean applyAll = true;
895 
896     Instance actualResponse = client.applyParametersAsync(name, nodeIds, applyAll).get();
897     Assert.assertEquals(expectedResponse, actualResponse);
898 
899     List<String> actualRequests = mockService.getRequestPaths();
900     Assert.assertEquals(1, actualRequests.size());
901 
902     String apiClientHeaderKey =
903         mockService
904             .getRequestHeaders()
905             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
906             .iterator()
907             .next();
908     Assert.assertTrue(
909         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
910             .matcher(apiClientHeaderKey)
911             .matches());
912   }
913 
914   @Test
applyParametersExceptionTest2()915   public void applyParametersExceptionTest2() throws Exception {
916     ApiException exception =
917         ApiExceptionFactory.createException(
918             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
919     mockService.addException(exception);
920 
921     try {
922       String name = "projects/project-9412/locations/location-9412/instances/instance-9412";
923       List<String> nodeIds = new ArrayList<>();
924       boolean applyAll = true;
925       client.applyParametersAsync(name, nodeIds, applyAll).get();
926       Assert.fail("No exception raised");
927     } catch (ExecutionException e) {
928     }
929   }
930 
931   @Test
applySoftwareUpdateTest()932   public void applySoftwareUpdateTest() throws Exception {
933     Instance expectedResponse =
934         Instance.newBuilder()
935             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
936             .setDisplayName("displayName1714148973")
937             .putAllLabels(new HashMap<String, String>())
938             .setAuthorizedNetwork("authorizedNetwork1515554835")
939             .addAllZones(new ArrayList<String>())
940             .setNodeCount(1539922066)
941             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
942             .setMemcacheVersion(MemcacheVersion.forNumber(0))
943             .setParameters(MemcacheParameters.newBuilder().build())
944             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
945             .setCreateTime(Timestamp.newBuilder().build())
946             .setUpdateTime(Timestamp.newBuilder().build())
947             .setMemcacheFullVersion("memcacheFullVersion976507452")
948             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
949             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
950             .setUpdateAvailable(true)
951             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
952             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
953             .build();
954     Operation resultOperation =
955         Operation.newBuilder()
956             .setName("applySoftwareUpdateTest")
957             .setDone(true)
958             .setResponse(Any.pack(expectedResponse))
959             .build();
960     mockService.addResponse(resultOperation);
961 
962     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
963     List<String> nodeIds = new ArrayList<>();
964     boolean applyAll = true;
965 
966     Instance actualResponse = client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
967     Assert.assertEquals(expectedResponse, actualResponse);
968 
969     List<String> actualRequests = mockService.getRequestPaths();
970     Assert.assertEquals(1, actualRequests.size());
971 
972     String apiClientHeaderKey =
973         mockService
974             .getRequestHeaders()
975             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
976             .iterator()
977             .next();
978     Assert.assertTrue(
979         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
980             .matcher(apiClientHeaderKey)
981             .matches());
982   }
983 
984   @Test
applySoftwareUpdateExceptionTest()985   public void applySoftwareUpdateExceptionTest() throws Exception {
986     ApiException exception =
987         ApiExceptionFactory.createException(
988             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
989     mockService.addException(exception);
990 
991     try {
992       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
993       List<String> nodeIds = new ArrayList<>();
994       boolean applyAll = true;
995       client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
996       Assert.fail("No exception raised");
997     } catch (ExecutionException e) {
998     }
999   }
1000 
1001   @Test
applySoftwareUpdateTest2()1002   public void applySoftwareUpdateTest2() throws Exception {
1003     Instance expectedResponse =
1004         Instance.newBuilder()
1005             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1006             .setDisplayName("displayName1714148973")
1007             .putAllLabels(new HashMap<String, String>())
1008             .setAuthorizedNetwork("authorizedNetwork1515554835")
1009             .addAllZones(new ArrayList<String>())
1010             .setNodeCount(1539922066)
1011             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1012             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1013             .setParameters(MemcacheParameters.newBuilder().build())
1014             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1015             .setCreateTime(Timestamp.newBuilder().build())
1016             .setUpdateTime(Timestamp.newBuilder().build())
1017             .setMemcacheFullVersion("memcacheFullVersion976507452")
1018             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1019             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1020             .setUpdateAvailable(true)
1021             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1022             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1023             .build();
1024     Operation resultOperation =
1025         Operation.newBuilder()
1026             .setName("applySoftwareUpdateTest")
1027             .setDone(true)
1028             .setResponse(Any.pack(expectedResponse))
1029             .build();
1030     mockService.addResponse(resultOperation);
1031 
1032     String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1033     List<String> nodeIds = new ArrayList<>();
1034     boolean applyAll = true;
1035 
1036     Instance actualResponse = client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
1037     Assert.assertEquals(expectedResponse, actualResponse);
1038 
1039     List<String> actualRequests = mockService.getRequestPaths();
1040     Assert.assertEquals(1, actualRequests.size());
1041 
1042     String apiClientHeaderKey =
1043         mockService
1044             .getRequestHeaders()
1045             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1046             .iterator()
1047             .next();
1048     Assert.assertTrue(
1049         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1050             .matcher(apiClientHeaderKey)
1051             .matches());
1052   }
1053 
1054   @Test
applySoftwareUpdateExceptionTest2()1055   public void applySoftwareUpdateExceptionTest2() throws Exception {
1056     ApiException exception =
1057         ApiExceptionFactory.createException(
1058             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1059     mockService.addException(exception);
1060 
1061     try {
1062       String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1063       List<String> nodeIds = new ArrayList<>();
1064       boolean applyAll = true;
1065       client.applySoftwareUpdateAsync(instance, nodeIds, applyAll).get();
1066       Assert.fail("No exception raised");
1067     } catch (ExecutionException e) {
1068     }
1069   }
1070 
1071   @Test
rescheduleMaintenanceTest()1072   public void rescheduleMaintenanceTest() throws Exception {
1073     Instance expectedResponse =
1074         Instance.newBuilder()
1075             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1076             .setDisplayName("displayName1714148973")
1077             .putAllLabels(new HashMap<String, String>())
1078             .setAuthorizedNetwork("authorizedNetwork1515554835")
1079             .addAllZones(new ArrayList<String>())
1080             .setNodeCount(1539922066)
1081             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1082             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1083             .setParameters(MemcacheParameters.newBuilder().build())
1084             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1085             .setCreateTime(Timestamp.newBuilder().build())
1086             .setUpdateTime(Timestamp.newBuilder().build())
1087             .setMemcacheFullVersion("memcacheFullVersion976507452")
1088             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1089             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1090             .setUpdateAvailable(true)
1091             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1092             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1093             .build();
1094     Operation resultOperation =
1095         Operation.newBuilder()
1096             .setName("rescheduleMaintenanceTest")
1097             .setDone(true)
1098             .setResponse(Any.pack(expectedResponse))
1099             .build();
1100     mockService.addResponse(resultOperation);
1101 
1102     InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1103     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1104         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1105     Timestamp scheduleTime = Timestamp.newBuilder().build();
1106 
1107     Instance actualResponse =
1108         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1109     Assert.assertEquals(expectedResponse, actualResponse);
1110 
1111     List<String> actualRequests = mockService.getRequestPaths();
1112     Assert.assertEquals(1, actualRequests.size());
1113 
1114     String apiClientHeaderKey =
1115         mockService
1116             .getRequestHeaders()
1117             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1118             .iterator()
1119             .next();
1120     Assert.assertTrue(
1121         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1122             .matcher(apiClientHeaderKey)
1123             .matches());
1124   }
1125 
1126   @Test
rescheduleMaintenanceExceptionTest()1127   public void rescheduleMaintenanceExceptionTest() throws Exception {
1128     ApiException exception =
1129         ApiExceptionFactory.createException(
1130             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1131     mockService.addException(exception);
1132 
1133     try {
1134       InstanceName instance = InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]");
1135       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1136           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1137       Timestamp scheduleTime = Timestamp.newBuilder().build();
1138       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1139       Assert.fail("No exception raised");
1140     } catch (ExecutionException e) {
1141     }
1142   }
1143 
1144   @Test
rescheduleMaintenanceTest2()1145   public void rescheduleMaintenanceTest2() throws Exception {
1146     Instance expectedResponse =
1147         Instance.newBuilder()
1148             .setName(InstanceName.of("[PROJECT]", "[LOCATION]", "[INSTANCE]").toString())
1149             .setDisplayName("displayName1714148973")
1150             .putAllLabels(new HashMap<String, String>())
1151             .setAuthorizedNetwork("authorizedNetwork1515554835")
1152             .addAllZones(new ArrayList<String>())
1153             .setNodeCount(1539922066)
1154             .setNodeConfig(Instance.NodeConfig.newBuilder().build())
1155             .setMemcacheVersion(MemcacheVersion.forNumber(0))
1156             .setParameters(MemcacheParameters.newBuilder().build())
1157             .addAllMemcacheNodes(new ArrayList<Instance.Node>())
1158             .setCreateTime(Timestamp.newBuilder().build())
1159             .setUpdateTime(Timestamp.newBuilder().build())
1160             .setMemcacheFullVersion("memcacheFullVersion976507452")
1161             .addAllInstanceMessages(new ArrayList<Instance.InstanceMessage>())
1162             .setDiscoveryEndpoint("discoveryEndpoint-1155573915")
1163             .setUpdateAvailable(true)
1164             .setMaintenancePolicy(MaintenancePolicy.newBuilder().build())
1165             .setMaintenanceSchedule(MaintenanceSchedule.newBuilder().build())
1166             .build();
1167     Operation resultOperation =
1168         Operation.newBuilder()
1169             .setName("rescheduleMaintenanceTest")
1170             .setDone(true)
1171             .setResponse(Any.pack(expectedResponse))
1172             .build();
1173     mockService.addResponse(resultOperation);
1174 
1175     String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1176     RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1177         RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1178     Timestamp scheduleTime = Timestamp.newBuilder().build();
1179 
1180     Instance actualResponse =
1181         client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1182     Assert.assertEquals(expectedResponse, actualResponse);
1183 
1184     List<String> actualRequests = mockService.getRequestPaths();
1185     Assert.assertEquals(1, actualRequests.size());
1186 
1187     String apiClientHeaderKey =
1188         mockService
1189             .getRequestHeaders()
1190             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1191             .iterator()
1192             .next();
1193     Assert.assertTrue(
1194         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1195             .matcher(apiClientHeaderKey)
1196             .matches());
1197   }
1198 
1199   @Test
rescheduleMaintenanceExceptionTest2()1200   public void rescheduleMaintenanceExceptionTest2() throws Exception {
1201     ApiException exception =
1202         ApiExceptionFactory.createException(
1203             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1204     mockService.addException(exception);
1205 
1206     try {
1207       String instance = "projects/project-2526/locations/location-2526/instances/instance-2526";
1208       RescheduleMaintenanceRequest.RescheduleType rescheduleType =
1209           RescheduleMaintenanceRequest.RescheduleType.forNumber(0);
1210       Timestamp scheduleTime = Timestamp.newBuilder().build();
1211       client.rescheduleMaintenanceAsync(instance, rescheduleType, scheduleTime).get();
1212       Assert.fail("No exception raised");
1213     } catch (ExecutionException e) {
1214     }
1215   }
1216 
1217   @Test
listLocationsTest()1218   public void listLocationsTest() throws Exception {
1219     Location responsesElement = Location.newBuilder().build();
1220     ListLocationsResponse expectedResponse =
1221         ListLocationsResponse.newBuilder()
1222             .setNextPageToken("")
1223             .addAllLocations(Arrays.asList(responsesElement))
1224             .build();
1225     mockService.addResponse(expectedResponse);
1226 
1227     ListLocationsRequest request =
1228         ListLocationsRequest.newBuilder()
1229             .setName("projects/project-3664")
1230             .setFilter("filter-1274492040")
1231             .setPageSize(883849137)
1232             .setPageToken("pageToken873572522")
1233             .build();
1234 
1235     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1236 
1237     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1238 
1239     Assert.assertEquals(1, resources.size());
1240     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1241 
1242     List<String> actualRequests = mockService.getRequestPaths();
1243     Assert.assertEquals(1, actualRequests.size());
1244 
1245     String apiClientHeaderKey =
1246         mockService
1247             .getRequestHeaders()
1248             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1249             .iterator()
1250             .next();
1251     Assert.assertTrue(
1252         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1253             .matcher(apiClientHeaderKey)
1254             .matches());
1255   }
1256 
1257   @Test
listLocationsExceptionTest()1258   public void listLocationsExceptionTest() throws Exception {
1259     ApiException exception =
1260         ApiExceptionFactory.createException(
1261             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1262     mockService.addException(exception);
1263 
1264     try {
1265       ListLocationsRequest request =
1266           ListLocationsRequest.newBuilder()
1267               .setName("projects/project-3664")
1268               .setFilter("filter-1274492040")
1269               .setPageSize(883849137)
1270               .setPageToken("pageToken873572522")
1271               .build();
1272       client.listLocations(request);
1273       Assert.fail("No exception raised");
1274     } catch (InvalidArgumentException e) {
1275       // Expected exception.
1276     }
1277   }
1278 
1279   @Test
getLocationTest()1280   public void getLocationTest() throws Exception {
1281     Location expectedResponse =
1282         Location.newBuilder()
1283             .setName("name3373707")
1284             .setLocationId("locationId1541836720")
1285             .setDisplayName("displayName1714148973")
1286             .putAllLabels(new HashMap<String, String>())
1287             .setMetadata(Any.newBuilder().build())
1288             .build();
1289     mockService.addResponse(expectedResponse);
1290 
1291     GetLocationRequest request =
1292         GetLocationRequest.newBuilder()
1293             .setName("projects/project-9062/locations/location-9062")
1294             .build();
1295 
1296     Location actualResponse = client.getLocation(request);
1297     Assert.assertEquals(expectedResponse, actualResponse);
1298 
1299     List<String> actualRequests = mockService.getRequestPaths();
1300     Assert.assertEquals(1, actualRequests.size());
1301 
1302     String apiClientHeaderKey =
1303         mockService
1304             .getRequestHeaders()
1305             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1306             .iterator()
1307             .next();
1308     Assert.assertTrue(
1309         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1310             .matcher(apiClientHeaderKey)
1311             .matches());
1312   }
1313 
1314   @Test
getLocationExceptionTest()1315   public void getLocationExceptionTest() throws Exception {
1316     ApiException exception =
1317         ApiExceptionFactory.createException(
1318             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1319     mockService.addException(exception);
1320 
1321     try {
1322       GetLocationRequest request =
1323           GetLocationRequest.newBuilder()
1324               .setName("projects/project-9062/locations/location-9062")
1325               .build();
1326       client.getLocation(request);
1327       Assert.fail("No exception raised");
1328     } catch (InvalidArgumentException e) {
1329       // Expected exception.
1330     }
1331   }
1332 }
1333