• 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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.ProjectsClient.GetXpnResourcesPagedResponse;
20 import static com.google.cloud.compute.v1.ProjectsClient.ListXpnHostsPagedResponse;
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.compute.v1.Operation.Status;
32 import com.google.cloud.compute.v1.stub.HttpJsonProjectsStub;
33 import com.google.common.collect.Lists;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.List;
38 import java.util.concurrent.ExecutionException;
39 import javax.annotation.Generated;
40 import org.junit.After;
41 import org.junit.AfterClass;
42 import org.junit.Assert;
43 import org.junit.Before;
44 import org.junit.BeforeClass;
45 import org.junit.Test;
46 
47 @Generated("by gapic-generator-java")
48 public class ProjectsClientTest {
49   private static MockHttpService mockService;
50   private static ProjectsClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonProjectsStub.getMethodDescriptors(), ProjectsSettings.getDefaultEndpoint());
57     ProjectsSettings settings =
58         ProjectsSettings.newBuilder()
59             .setTransportChannelProvider(
60                 ProjectsSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = ProjectsClient.create(settings);
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     client.close();
71   }
72 
73   @Before
setUp()74   public void setUp() {}
75 
76   @After
tearDown()77   public void tearDown() throws Exception {
78     mockService.reset();
79   }
80 
81   @Test
disableXpnHostTest()82   public void disableXpnHostTest() throws Exception {
83     Operation expectedResponse =
84         Operation.newBuilder()
85             .setClientOperationId("clientOperationId-1230366697")
86             .setCreationTimestamp("creationTimestamp-370203401")
87             .setDescription("description-1724546052")
88             .setEndTime("endTime-1607243192")
89             .setError(Error.newBuilder().build())
90             .setHttpErrorMessage("httpErrorMessage1577303431")
91             .setHttpErrorStatusCode(0)
92             .setId(3355)
93             .setInsertTime("insertTime966165798")
94             .setKind("kind3292052")
95             .setName("name3373707")
96             .setOperationGroupId("operationGroupId1716161683")
97             .setOperationType("operationType91999553")
98             .setProgress(-1001078227)
99             .setRegion("region-934795532")
100             .setSelfLink("selfLink1191800166")
101             .setStartTime("startTime-2129294769")
102             .setStatus(Status.DONE)
103             .setStatusMessage("statusMessage-958704715")
104             .setTargetId(-815576439)
105             .setTargetLink("targetLink486368555")
106             .setUser("user3599307")
107             .addAllWarnings(new ArrayList<Warnings>())
108             .setZone("zone3744684")
109             .build();
110     mockService.addResponse(expectedResponse);
111 
112     String project = "project-6911";
113 
114     Operation actualResponse = client.disableXpnHostAsync(project).get();
115     Assert.assertEquals(expectedResponse, actualResponse);
116 
117     List<String> actualRequests = mockService.getRequestPaths();
118     Assert.assertEquals(1, actualRequests.size());
119 
120     String apiClientHeaderKey =
121         mockService
122             .getRequestHeaders()
123             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
124             .iterator()
125             .next();
126     Assert.assertTrue(
127         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
128             .matcher(apiClientHeaderKey)
129             .matches());
130   }
131 
132   @Test
disableXpnHostExceptionTest()133   public void disableXpnHostExceptionTest() throws Exception {
134     ApiException exception =
135         ApiExceptionFactory.createException(
136             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
137     mockService.addException(exception);
138 
139     try {
140       String project = "project-6911";
141       client.disableXpnHostAsync(project).get();
142       Assert.fail("No exception raised");
143     } catch (ExecutionException e) {
144     }
145   }
146 
147   @Test
disableXpnResourceTest()148   public void disableXpnResourceTest() throws Exception {
149     Operation expectedResponse =
150         Operation.newBuilder()
151             .setClientOperationId("clientOperationId-1230366697")
152             .setCreationTimestamp("creationTimestamp-370203401")
153             .setDescription("description-1724546052")
154             .setEndTime("endTime-1607243192")
155             .setError(Error.newBuilder().build())
156             .setHttpErrorMessage("httpErrorMessage1577303431")
157             .setHttpErrorStatusCode(0)
158             .setId(3355)
159             .setInsertTime("insertTime966165798")
160             .setKind("kind3292052")
161             .setName("name3373707")
162             .setOperationGroupId("operationGroupId1716161683")
163             .setOperationType("operationType91999553")
164             .setProgress(-1001078227)
165             .setRegion("region-934795532")
166             .setSelfLink("selfLink1191800166")
167             .setStartTime("startTime-2129294769")
168             .setStatus(Status.DONE)
169             .setStatusMessage("statusMessage-958704715")
170             .setTargetId(-815576439)
171             .setTargetLink("targetLink486368555")
172             .setUser("user3599307")
173             .addAllWarnings(new ArrayList<Warnings>())
174             .setZone("zone3744684")
175             .build();
176     mockService.addResponse(expectedResponse);
177 
178     String project = "project-6911";
179     ProjectsDisableXpnResourceRequest projectsDisableXpnResourceRequestResource =
180         ProjectsDisableXpnResourceRequest.newBuilder().build();
181 
182     Operation actualResponse =
183         client.disableXpnResourceAsync(project, projectsDisableXpnResourceRequestResource).get();
184     Assert.assertEquals(expectedResponse, actualResponse);
185 
186     List<String> actualRequests = mockService.getRequestPaths();
187     Assert.assertEquals(1, actualRequests.size());
188 
189     String apiClientHeaderKey =
190         mockService
191             .getRequestHeaders()
192             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
193             .iterator()
194             .next();
195     Assert.assertTrue(
196         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
197             .matcher(apiClientHeaderKey)
198             .matches());
199   }
200 
201   @Test
disableXpnResourceExceptionTest()202   public void disableXpnResourceExceptionTest() throws Exception {
203     ApiException exception =
204         ApiExceptionFactory.createException(
205             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
206     mockService.addException(exception);
207 
208     try {
209       String project = "project-6911";
210       ProjectsDisableXpnResourceRequest projectsDisableXpnResourceRequestResource =
211           ProjectsDisableXpnResourceRequest.newBuilder().build();
212       client.disableXpnResourceAsync(project, projectsDisableXpnResourceRequestResource).get();
213       Assert.fail("No exception raised");
214     } catch (ExecutionException e) {
215     }
216   }
217 
218   @Test
enableXpnHostTest()219   public void enableXpnHostTest() throws Exception {
220     Operation expectedResponse =
221         Operation.newBuilder()
222             .setClientOperationId("clientOperationId-1230366697")
223             .setCreationTimestamp("creationTimestamp-370203401")
224             .setDescription("description-1724546052")
225             .setEndTime("endTime-1607243192")
226             .setError(Error.newBuilder().build())
227             .setHttpErrorMessage("httpErrorMessage1577303431")
228             .setHttpErrorStatusCode(0)
229             .setId(3355)
230             .setInsertTime("insertTime966165798")
231             .setKind("kind3292052")
232             .setName("name3373707")
233             .setOperationGroupId("operationGroupId1716161683")
234             .setOperationType("operationType91999553")
235             .setProgress(-1001078227)
236             .setRegion("region-934795532")
237             .setSelfLink("selfLink1191800166")
238             .setStartTime("startTime-2129294769")
239             .setStatus(Status.DONE)
240             .setStatusMessage("statusMessage-958704715")
241             .setTargetId(-815576439)
242             .setTargetLink("targetLink486368555")
243             .setUser("user3599307")
244             .addAllWarnings(new ArrayList<Warnings>())
245             .setZone("zone3744684")
246             .build();
247     mockService.addResponse(expectedResponse);
248 
249     String project = "project-6911";
250 
251     Operation actualResponse = client.enableXpnHostAsync(project).get();
252     Assert.assertEquals(expectedResponse, actualResponse);
253 
254     List<String> actualRequests = mockService.getRequestPaths();
255     Assert.assertEquals(1, actualRequests.size());
256 
257     String apiClientHeaderKey =
258         mockService
259             .getRequestHeaders()
260             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
261             .iterator()
262             .next();
263     Assert.assertTrue(
264         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
265             .matcher(apiClientHeaderKey)
266             .matches());
267   }
268 
269   @Test
enableXpnHostExceptionTest()270   public void enableXpnHostExceptionTest() throws Exception {
271     ApiException exception =
272         ApiExceptionFactory.createException(
273             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
274     mockService.addException(exception);
275 
276     try {
277       String project = "project-6911";
278       client.enableXpnHostAsync(project).get();
279       Assert.fail("No exception raised");
280     } catch (ExecutionException e) {
281     }
282   }
283 
284   @Test
enableXpnResourceTest()285   public void enableXpnResourceTest() throws Exception {
286     Operation expectedResponse =
287         Operation.newBuilder()
288             .setClientOperationId("clientOperationId-1230366697")
289             .setCreationTimestamp("creationTimestamp-370203401")
290             .setDescription("description-1724546052")
291             .setEndTime("endTime-1607243192")
292             .setError(Error.newBuilder().build())
293             .setHttpErrorMessage("httpErrorMessage1577303431")
294             .setHttpErrorStatusCode(0)
295             .setId(3355)
296             .setInsertTime("insertTime966165798")
297             .setKind("kind3292052")
298             .setName("name3373707")
299             .setOperationGroupId("operationGroupId1716161683")
300             .setOperationType("operationType91999553")
301             .setProgress(-1001078227)
302             .setRegion("region-934795532")
303             .setSelfLink("selfLink1191800166")
304             .setStartTime("startTime-2129294769")
305             .setStatus(Status.DONE)
306             .setStatusMessage("statusMessage-958704715")
307             .setTargetId(-815576439)
308             .setTargetLink("targetLink486368555")
309             .setUser("user3599307")
310             .addAllWarnings(new ArrayList<Warnings>())
311             .setZone("zone3744684")
312             .build();
313     mockService.addResponse(expectedResponse);
314 
315     String project = "project-6911";
316     ProjectsEnableXpnResourceRequest projectsEnableXpnResourceRequestResource =
317         ProjectsEnableXpnResourceRequest.newBuilder().build();
318 
319     Operation actualResponse =
320         client.enableXpnResourceAsync(project, projectsEnableXpnResourceRequestResource).get();
321     Assert.assertEquals(expectedResponse, actualResponse);
322 
323     List<String> actualRequests = mockService.getRequestPaths();
324     Assert.assertEquals(1, actualRequests.size());
325 
326     String apiClientHeaderKey =
327         mockService
328             .getRequestHeaders()
329             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
330             .iterator()
331             .next();
332     Assert.assertTrue(
333         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
334             .matcher(apiClientHeaderKey)
335             .matches());
336   }
337 
338   @Test
enableXpnResourceExceptionTest()339   public void enableXpnResourceExceptionTest() throws Exception {
340     ApiException exception =
341         ApiExceptionFactory.createException(
342             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
343     mockService.addException(exception);
344 
345     try {
346       String project = "project-6911";
347       ProjectsEnableXpnResourceRequest projectsEnableXpnResourceRequestResource =
348           ProjectsEnableXpnResourceRequest.newBuilder().build();
349       client.enableXpnResourceAsync(project, projectsEnableXpnResourceRequestResource).get();
350       Assert.fail("No exception raised");
351     } catch (ExecutionException e) {
352     }
353   }
354 
355   @Test
getTest()356   public void getTest() throws Exception {
357     Project expectedResponse =
358         Project.newBuilder()
359             .setCommonInstanceMetadata(Metadata.newBuilder().build())
360             .setCreationTimestamp("creationTimestamp-370203401")
361             .setDefaultNetworkTier("defaultNetworkTier-836540369")
362             .setDefaultServiceAccount("defaultServiceAccount2129949273")
363             .setDescription("description-1724546052")
364             .addAllEnabledFeatures(new ArrayList<String>())
365             .setId(3355)
366             .setKind("kind3292052")
367             .setName("name3373707")
368             .addAllQuotas(new ArrayList<Quota>())
369             .setSelfLink("selfLink1191800166")
370             .setUsageExportLocation(UsageExportLocation.newBuilder().build())
371             .setVmDnsSetting("vmDnsSetting233497342")
372             .setXpnProjectStatus("xpnProjectStatus-52109419")
373             .build();
374     mockService.addResponse(expectedResponse);
375 
376     String project = "project-6911";
377 
378     Project actualResponse = client.get(project);
379     Assert.assertEquals(expectedResponse, actualResponse);
380 
381     List<String> actualRequests = mockService.getRequestPaths();
382     Assert.assertEquals(1, actualRequests.size());
383 
384     String apiClientHeaderKey =
385         mockService
386             .getRequestHeaders()
387             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
388             .iterator()
389             .next();
390     Assert.assertTrue(
391         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
392             .matcher(apiClientHeaderKey)
393             .matches());
394   }
395 
396   @Test
getExceptionTest()397   public void getExceptionTest() throws Exception {
398     ApiException exception =
399         ApiExceptionFactory.createException(
400             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
401     mockService.addException(exception);
402 
403     try {
404       String project = "project-6911";
405       client.get(project);
406       Assert.fail("No exception raised");
407     } catch (InvalidArgumentException e) {
408       // Expected exception.
409     }
410   }
411 
412   @Test
getXpnHostTest()413   public void getXpnHostTest() throws Exception {
414     Project expectedResponse =
415         Project.newBuilder()
416             .setCommonInstanceMetadata(Metadata.newBuilder().build())
417             .setCreationTimestamp("creationTimestamp-370203401")
418             .setDefaultNetworkTier("defaultNetworkTier-836540369")
419             .setDefaultServiceAccount("defaultServiceAccount2129949273")
420             .setDescription("description-1724546052")
421             .addAllEnabledFeatures(new ArrayList<String>())
422             .setId(3355)
423             .setKind("kind3292052")
424             .setName("name3373707")
425             .addAllQuotas(new ArrayList<Quota>())
426             .setSelfLink("selfLink1191800166")
427             .setUsageExportLocation(UsageExportLocation.newBuilder().build())
428             .setVmDnsSetting("vmDnsSetting233497342")
429             .setXpnProjectStatus("xpnProjectStatus-52109419")
430             .build();
431     mockService.addResponse(expectedResponse);
432 
433     String project = "project-6911";
434 
435     Project actualResponse = client.getXpnHost(project);
436     Assert.assertEquals(expectedResponse, actualResponse);
437 
438     List<String> actualRequests = mockService.getRequestPaths();
439     Assert.assertEquals(1, actualRequests.size());
440 
441     String apiClientHeaderKey =
442         mockService
443             .getRequestHeaders()
444             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
445             .iterator()
446             .next();
447     Assert.assertTrue(
448         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
449             .matcher(apiClientHeaderKey)
450             .matches());
451   }
452 
453   @Test
getXpnHostExceptionTest()454   public void getXpnHostExceptionTest() throws Exception {
455     ApiException exception =
456         ApiExceptionFactory.createException(
457             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
458     mockService.addException(exception);
459 
460     try {
461       String project = "project-6911";
462       client.getXpnHost(project);
463       Assert.fail("No exception raised");
464     } catch (InvalidArgumentException e) {
465       // Expected exception.
466     }
467   }
468 
469   @Test
getXpnResourcesTest()470   public void getXpnResourcesTest() throws Exception {
471     XpnResourceId responsesElement = XpnResourceId.newBuilder().build();
472     ProjectsGetXpnResources expectedResponse =
473         ProjectsGetXpnResources.newBuilder()
474             .setNextPageToken("")
475             .addAllResources(Arrays.asList(responsesElement))
476             .build();
477     mockService.addResponse(expectedResponse);
478 
479     String project = "project-6911";
480 
481     GetXpnResourcesPagedResponse pagedListResponse = client.getXpnResources(project);
482 
483     List<XpnResourceId> resources = Lists.newArrayList(pagedListResponse.iterateAll());
484 
485     Assert.assertEquals(1, resources.size());
486     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
487 
488     List<String> actualRequests = mockService.getRequestPaths();
489     Assert.assertEquals(1, actualRequests.size());
490 
491     String apiClientHeaderKey =
492         mockService
493             .getRequestHeaders()
494             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
495             .iterator()
496             .next();
497     Assert.assertTrue(
498         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
499             .matcher(apiClientHeaderKey)
500             .matches());
501   }
502 
503   @Test
getXpnResourcesExceptionTest()504   public void getXpnResourcesExceptionTest() throws Exception {
505     ApiException exception =
506         ApiExceptionFactory.createException(
507             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
508     mockService.addException(exception);
509 
510     try {
511       String project = "project-6911";
512       client.getXpnResources(project);
513       Assert.fail("No exception raised");
514     } catch (InvalidArgumentException e) {
515       // Expected exception.
516     }
517   }
518 
519   @Test
listXpnHostsTest()520   public void listXpnHostsTest() throws Exception {
521     Project responsesElement = Project.newBuilder().build();
522     XpnHostList expectedResponse =
523         XpnHostList.newBuilder()
524             .setNextPageToken("")
525             .addAllItems(Arrays.asList(responsesElement))
526             .build();
527     mockService.addResponse(expectedResponse);
528 
529     String project = "project-6911";
530     ProjectsListXpnHostsRequest projectsListXpnHostsRequestResource =
531         ProjectsListXpnHostsRequest.newBuilder().build();
532 
533     ListXpnHostsPagedResponse pagedListResponse =
534         client.listXpnHosts(project, projectsListXpnHostsRequestResource);
535 
536     List<Project> resources = Lists.newArrayList(pagedListResponse.iterateAll());
537 
538     Assert.assertEquals(1, resources.size());
539     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
540 
541     List<String> actualRequests = mockService.getRequestPaths();
542     Assert.assertEquals(1, actualRequests.size());
543 
544     String apiClientHeaderKey =
545         mockService
546             .getRequestHeaders()
547             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
548             .iterator()
549             .next();
550     Assert.assertTrue(
551         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
552             .matcher(apiClientHeaderKey)
553             .matches());
554   }
555 
556   @Test
listXpnHostsExceptionTest()557   public void listXpnHostsExceptionTest() throws Exception {
558     ApiException exception =
559         ApiExceptionFactory.createException(
560             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
561     mockService.addException(exception);
562 
563     try {
564       String project = "project-6911";
565       ProjectsListXpnHostsRequest projectsListXpnHostsRequestResource =
566           ProjectsListXpnHostsRequest.newBuilder().build();
567       client.listXpnHosts(project, projectsListXpnHostsRequestResource);
568       Assert.fail("No exception raised");
569     } catch (InvalidArgumentException e) {
570       // Expected exception.
571     }
572   }
573 
574   @Test
moveDiskTest()575   public void moveDiskTest() throws Exception {
576     Operation expectedResponse =
577         Operation.newBuilder()
578             .setClientOperationId("clientOperationId-1230366697")
579             .setCreationTimestamp("creationTimestamp-370203401")
580             .setDescription("description-1724546052")
581             .setEndTime("endTime-1607243192")
582             .setError(Error.newBuilder().build())
583             .setHttpErrorMessage("httpErrorMessage1577303431")
584             .setHttpErrorStatusCode(0)
585             .setId(3355)
586             .setInsertTime("insertTime966165798")
587             .setKind("kind3292052")
588             .setName("name3373707")
589             .setOperationGroupId("operationGroupId1716161683")
590             .setOperationType("operationType91999553")
591             .setProgress(-1001078227)
592             .setRegion("region-934795532")
593             .setSelfLink("selfLink1191800166")
594             .setStartTime("startTime-2129294769")
595             .setStatus(Status.DONE)
596             .setStatusMessage("statusMessage-958704715")
597             .setTargetId(-815576439)
598             .setTargetLink("targetLink486368555")
599             .setUser("user3599307")
600             .addAllWarnings(new ArrayList<Warnings>())
601             .setZone("zone3744684")
602             .build();
603     mockService.addResponse(expectedResponse);
604 
605     String project = "project-6911";
606     DiskMoveRequest diskMoveRequestResource = DiskMoveRequest.newBuilder().build();
607 
608     Operation actualResponse = client.moveDiskAsync(project, diskMoveRequestResource).get();
609     Assert.assertEquals(expectedResponse, actualResponse);
610 
611     List<String> actualRequests = mockService.getRequestPaths();
612     Assert.assertEquals(1, actualRequests.size());
613 
614     String apiClientHeaderKey =
615         mockService
616             .getRequestHeaders()
617             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
618             .iterator()
619             .next();
620     Assert.assertTrue(
621         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
622             .matcher(apiClientHeaderKey)
623             .matches());
624   }
625 
626   @Test
moveDiskExceptionTest()627   public void moveDiskExceptionTest() throws Exception {
628     ApiException exception =
629         ApiExceptionFactory.createException(
630             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
631     mockService.addException(exception);
632 
633     try {
634       String project = "project-6911";
635       DiskMoveRequest diskMoveRequestResource = DiskMoveRequest.newBuilder().build();
636       client.moveDiskAsync(project, diskMoveRequestResource).get();
637       Assert.fail("No exception raised");
638     } catch (ExecutionException e) {
639     }
640   }
641 
642   @Test
moveInstanceTest()643   public void moveInstanceTest() throws Exception {
644     Operation expectedResponse =
645         Operation.newBuilder()
646             .setClientOperationId("clientOperationId-1230366697")
647             .setCreationTimestamp("creationTimestamp-370203401")
648             .setDescription("description-1724546052")
649             .setEndTime("endTime-1607243192")
650             .setError(Error.newBuilder().build())
651             .setHttpErrorMessage("httpErrorMessage1577303431")
652             .setHttpErrorStatusCode(0)
653             .setId(3355)
654             .setInsertTime("insertTime966165798")
655             .setKind("kind3292052")
656             .setName("name3373707")
657             .setOperationGroupId("operationGroupId1716161683")
658             .setOperationType("operationType91999553")
659             .setProgress(-1001078227)
660             .setRegion("region-934795532")
661             .setSelfLink("selfLink1191800166")
662             .setStartTime("startTime-2129294769")
663             .setStatus(Status.DONE)
664             .setStatusMessage("statusMessage-958704715")
665             .setTargetId(-815576439)
666             .setTargetLink("targetLink486368555")
667             .setUser("user3599307")
668             .addAllWarnings(new ArrayList<Warnings>())
669             .setZone("zone3744684")
670             .build();
671     mockService.addResponse(expectedResponse);
672 
673     String project = "project-6911";
674     InstanceMoveRequest instanceMoveRequestResource = InstanceMoveRequest.newBuilder().build();
675 
676     Operation actualResponse = client.moveInstanceAsync(project, instanceMoveRequestResource).get();
677     Assert.assertEquals(expectedResponse, actualResponse);
678 
679     List<String> actualRequests = mockService.getRequestPaths();
680     Assert.assertEquals(1, actualRequests.size());
681 
682     String apiClientHeaderKey =
683         mockService
684             .getRequestHeaders()
685             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
686             .iterator()
687             .next();
688     Assert.assertTrue(
689         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
690             .matcher(apiClientHeaderKey)
691             .matches());
692   }
693 
694   @Test
moveInstanceExceptionTest()695   public void moveInstanceExceptionTest() throws Exception {
696     ApiException exception =
697         ApiExceptionFactory.createException(
698             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
699     mockService.addException(exception);
700 
701     try {
702       String project = "project-6911";
703       InstanceMoveRequest instanceMoveRequestResource = InstanceMoveRequest.newBuilder().build();
704       client.moveInstanceAsync(project, instanceMoveRequestResource).get();
705       Assert.fail("No exception raised");
706     } catch (ExecutionException e) {
707     }
708   }
709 
710   @Test
setCommonInstanceMetadataTest()711   public void setCommonInstanceMetadataTest() throws Exception {
712     Operation expectedResponse =
713         Operation.newBuilder()
714             .setClientOperationId("clientOperationId-1230366697")
715             .setCreationTimestamp("creationTimestamp-370203401")
716             .setDescription("description-1724546052")
717             .setEndTime("endTime-1607243192")
718             .setError(Error.newBuilder().build())
719             .setHttpErrorMessage("httpErrorMessage1577303431")
720             .setHttpErrorStatusCode(0)
721             .setId(3355)
722             .setInsertTime("insertTime966165798")
723             .setKind("kind3292052")
724             .setName("name3373707")
725             .setOperationGroupId("operationGroupId1716161683")
726             .setOperationType("operationType91999553")
727             .setProgress(-1001078227)
728             .setRegion("region-934795532")
729             .setSelfLink("selfLink1191800166")
730             .setStartTime("startTime-2129294769")
731             .setStatus(Status.DONE)
732             .setStatusMessage("statusMessage-958704715")
733             .setTargetId(-815576439)
734             .setTargetLink("targetLink486368555")
735             .setUser("user3599307")
736             .addAllWarnings(new ArrayList<Warnings>())
737             .setZone("zone3744684")
738             .build();
739     mockService.addResponse(expectedResponse);
740 
741     String project = "project-6911";
742     Metadata metadataResource = Metadata.newBuilder().build();
743 
744     Operation actualResponse =
745         client.setCommonInstanceMetadataAsync(project, metadataResource).get();
746     Assert.assertEquals(expectedResponse, actualResponse);
747 
748     List<String> actualRequests = mockService.getRequestPaths();
749     Assert.assertEquals(1, actualRequests.size());
750 
751     String apiClientHeaderKey =
752         mockService
753             .getRequestHeaders()
754             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
755             .iterator()
756             .next();
757     Assert.assertTrue(
758         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
759             .matcher(apiClientHeaderKey)
760             .matches());
761   }
762 
763   @Test
setCommonInstanceMetadataExceptionTest()764   public void setCommonInstanceMetadataExceptionTest() throws Exception {
765     ApiException exception =
766         ApiExceptionFactory.createException(
767             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
768     mockService.addException(exception);
769 
770     try {
771       String project = "project-6911";
772       Metadata metadataResource = Metadata.newBuilder().build();
773       client.setCommonInstanceMetadataAsync(project, metadataResource).get();
774       Assert.fail("No exception raised");
775     } catch (ExecutionException e) {
776     }
777   }
778 
779   @Test
setDefaultNetworkTierTest()780   public void setDefaultNetworkTierTest() throws Exception {
781     Operation expectedResponse =
782         Operation.newBuilder()
783             .setClientOperationId("clientOperationId-1230366697")
784             .setCreationTimestamp("creationTimestamp-370203401")
785             .setDescription("description-1724546052")
786             .setEndTime("endTime-1607243192")
787             .setError(Error.newBuilder().build())
788             .setHttpErrorMessage("httpErrorMessage1577303431")
789             .setHttpErrorStatusCode(0)
790             .setId(3355)
791             .setInsertTime("insertTime966165798")
792             .setKind("kind3292052")
793             .setName("name3373707")
794             .setOperationGroupId("operationGroupId1716161683")
795             .setOperationType("operationType91999553")
796             .setProgress(-1001078227)
797             .setRegion("region-934795532")
798             .setSelfLink("selfLink1191800166")
799             .setStartTime("startTime-2129294769")
800             .setStatus(Status.DONE)
801             .setStatusMessage("statusMessage-958704715")
802             .setTargetId(-815576439)
803             .setTargetLink("targetLink486368555")
804             .setUser("user3599307")
805             .addAllWarnings(new ArrayList<Warnings>())
806             .setZone("zone3744684")
807             .build();
808     mockService.addResponse(expectedResponse);
809 
810     String project = "project-6911";
811     ProjectsSetDefaultNetworkTierRequest projectsSetDefaultNetworkTierRequestResource =
812         ProjectsSetDefaultNetworkTierRequest.newBuilder().build();
813 
814     Operation actualResponse =
815         client
816             .setDefaultNetworkTierAsync(project, projectsSetDefaultNetworkTierRequestResource)
817             .get();
818     Assert.assertEquals(expectedResponse, actualResponse);
819 
820     List<String> actualRequests = mockService.getRequestPaths();
821     Assert.assertEquals(1, actualRequests.size());
822 
823     String apiClientHeaderKey =
824         mockService
825             .getRequestHeaders()
826             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
827             .iterator()
828             .next();
829     Assert.assertTrue(
830         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
831             .matcher(apiClientHeaderKey)
832             .matches());
833   }
834 
835   @Test
setDefaultNetworkTierExceptionTest()836   public void setDefaultNetworkTierExceptionTest() throws Exception {
837     ApiException exception =
838         ApiExceptionFactory.createException(
839             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
840     mockService.addException(exception);
841 
842     try {
843       String project = "project-6911";
844       ProjectsSetDefaultNetworkTierRequest projectsSetDefaultNetworkTierRequestResource =
845           ProjectsSetDefaultNetworkTierRequest.newBuilder().build();
846       client
847           .setDefaultNetworkTierAsync(project, projectsSetDefaultNetworkTierRequestResource)
848           .get();
849       Assert.fail("No exception raised");
850     } catch (ExecutionException e) {
851     }
852   }
853 
854   @Test
setUsageExportBucketTest()855   public void setUsageExportBucketTest() throws Exception {
856     Operation expectedResponse =
857         Operation.newBuilder()
858             .setClientOperationId("clientOperationId-1230366697")
859             .setCreationTimestamp("creationTimestamp-370203401")
860             .setDescription("description-1724546052")
861             .setEndTime("endTime-1607243192")
862             .setError(Error.newBuilder().build())
863             .setHttpErrorMessage("httpErrorMessage1577303431")
864             .setHttpErrorStatusCode(0)
865             .setId(3355)
866             .setInsertTime("insertTime966165798")
867             .setKind("kind3292052")
868             .setName("name3373707")
869             .setOperationGroupId("operationGroupId1716161683")
870             .setOperationType("operationType91999553")
871             .setProgress(-1001078227)
872             .setRegion("region-934795532")
873             .setSelfLink("selfLink1191800166")
874             .setStartTime("startTime-2129294769")
875             .setStatus(Status.DONE)
876             .setStatusMessage("statusMessage-958704715")
877             .setTargetId(-815576439)
878             .setTargetLink("targetLink486368555")
879             .setUser("user3599307")
880             .addAllWarnings(new ArrayList<Warnings>())
881             .setZone("zone3744684")
882             .build();
883     mockService.addResponse(expectedResponse);
884 
885     String project = "project-6911";
886     UsageExportLocation usageExportLocationResource = UsageExportLocation.newBuilder().build();
887 
888     Operation actualResponse =
889         client.setUsageExportBucketAsync(project, usageExportLocationResource).get();
890     Assert.assertEquals(expectedResponse, actualResponse);
891 
892     List<String> actualRequests = mockService.getRequestPaths();
893     Assert.assertEquals(1, actualRequests.size());
894 
895     String apiClientHeaderKey =
896         mockService
897             .getRequestHeaders()
898             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
899             .iterator()
900             .next();
901     Assert.assertTrue(
902         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
903             .matcher(apiClientHeaderKey)
904             .matches());
905   }
906 
907   @Test
setUsageExportBucketExceptionTest()908   public void setUsageExportBucketExceptionTest() throws Exception {
909     ApiException exception =
910         ApiExceptionFactory.createException(
911             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
912     mockService.addException(exception);
913 
914     try {
915       String project = "project-6911";
916       UsageExportLocation usageExportLocationResource = UsageExportLocation.newBuilder().build();
917       client.setUsageExportBucketAsync(project, usageExportLocationResource).get();
918       Assert.fail("No exception raised");
919     } catch (ExecutionException e) {
920     }
921   }
922 }
923