• 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.vmmigration.v1;
18 
19 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListCloneJobsPagedResponse;
20 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListCutoverJobsPagedResponse;
21 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListDatacenterConnectorsPagedResponse;
22 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListGroupsPagedResponse;
23 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListLocationsPagedResponse;
24 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListMigratingVmsPagedResponse;
25 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListReplicationCyclesPagedResponse;
26 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListSourcesPagedResponse;
27 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListTargetProjectsPagedResponse;
28 import static com.google.cloud.vmmigration.v1.VmMigrationClient.ListUtilizationReportsPagedResponse;
29 
30 import com.google.api.gax.core.NoCredentialsProvider;
31 import com.google.api.gax.grpc.GaxGrpcProperties;
32 import com.google.api.gax.grpc.testing.LocalChannelProvider;
33 import com.google.api.gax.grpc.testing.MockGrpcService;
34 import com.google.api.gax.grpc.testing.MockServiceHelper;
35 import com.google.api.gax.rpc.ApiClientHeaderProvider;
36 import com.google.api.gax.rpc.InvalidArgumentException;
37 import com.google.api.gax.rpc.StatusCode;
38 import com.google.cloud.location.GetLocationRequest;
39 import com.google.cloud.location.ListLocationsRequest;
40 import com.google.cloud.location.ListLocationsResponse;
41 import com.google.cloud.location.Location;
42 import com.google.common.collect.Lists;
43 import com.google.longrunning.Operation;
44 import com.google.protobuf.AbstractMessage;
45 import com.google.protobuf.Any;
46 import com.google.protobuf.Duration;
47 import com.google.protobuf.Empty;
48 import com.google.protobuf.FieldMask;
49 import com.google.protobuf.Timestamp;
50 import com.google.rpc.Status;
51 import io.grpc.StatusRuntimeException;
52 import java.io.IOException;
53 import java.util.ArrayList;
54 import java.util.Arrays;
55 import java.util.HashMap;
56 import java.util.List;
57 import java.util.UUID;
58 import java.util.concurrent.ExecutionException;
59 import javax.annotation.Generated;
60 import org.junit.After;
61 import org.junit.AfterClass;
62 import org.junit.Assert;
63 import org.junit.Before;
64 import org.junit.BeforeClass;
65 import org.junit.Test;
66 
67 @Generated("by gapic-generator-java")
68 public class VmMigrationClientTest {
69   private static MockIAMPolicy mockIAMPolicy;
70   private static MockLocations mockLocations;
71   private static MockServiceHelper mockServiceHelper;
72   private static MockVmMigration mockVmMigration;
73   private LocalChannelProvider channelProvider;
74   private VmMigrationClient client;
75 
76   @BeforeClass
startStaticServer()77   public static void startStaticServer() {
78     mockVmMigration = new MockVmMigration();
79     mockLocations = new MockLocations();
80     mockIAMPolicy = new MockIAMPolicy();
81     mockServiceHelper =
82         new MockServiceHelper(
83             UUID.randomUUID().toString(),
84             Arrays.<MockGrpcService>asList(mockVmMigration, mockLocations, mockIAMPolicy));
85     mockServiceHelper.start();
86   }
87 
88   @AfterClass
stopServer()89   public static void stopServer() {
90     mockServiceHelper.stop();
91   }
92 
93   @Before
setUp()94   public void setUp() throws IOException {
95     mockServiceHelper.reset();
96     channelProvider = mockServiceHelper.createChannelProvider();
97     VmMigrationSettings settings =
98         VmMigrationSettings.newBuilder()
99             .setTransportChannelProvider(channelProvider)
100             .setCredentialsProvider(NoCredentialsProvider.create())
101             .build();
102     client = VmMigrationClient.create(settings);
103   }
104 
105   @After
tearDown()106   public void tearDown() throws Exception {
107     client.close();
108   }
109 
110   @Test
listSourcesTest()111   public void listSourcesTest() throws Exception {
112     Source responsesElement = Source.newBuilder().build();
113     ListSourcesResponse expectedResponse =
114         ListSourcesResponse.newBuilder()
115             .setNextPageToken("")
116             .addAllSources(Arrays.asList(responsesElement))
117             .build();
118     mockVmMigration.addResponse(expectedResponse);
119 
120     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
121 
122     ListSourcesPagedResponse pagedListResponse = client.listSources(parent);
123 
124     List<Source> resources = Lists.newArrayList(pagedListResponse.iterateAll());
125 
126     Assert.assertEquals(1, resources.size());
127     Assert.assertEquals(expectedResponse.getSourcesList().get(0), resources.get(0));
128 
129     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
130     Assert.assertEquals(1, actualRequests.size());
131     ListSourcesRequest actualRequest = ((ListSourcesRequest) actualRequests.get(0));
132 
133     Assert.assertEquals(parent.toString(), actualRequest.getParent());
134     Assert.assertTrue(
135         channelProvider.isHeaderSent(
136             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
137             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
138   }
139 
140   @Test
listSourcesExceptionTest()141   public void listSourcesExceptionTest() throws Exception {
142     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
143     mockVmMigration.addException(exception);
144 
145     try {
146       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
147       client.listSources(parent);
148       Assert.fail("No exception raised");
149     } catch (InvalidArgumentException e) {
150       // Expected exception.
151     }
152   }
153 
154   @Test
listSourcesTest2()155   public void listSourcesTest2() throws Exception {
156     Source responsesElement = Source.newBuilder().build();
157     ListSourcesResponse expectedResponse =
158         ListSourcesResponse.newBuilder()
159             .setNextPageToken("")
160             .addAllSources(Arrays.asList(responsesElement))
161             .build();
162     mockVmMigration.addResponse(expectedResponse);
163 
164     String parent = "parent-995424086";
165 
166     ListSourcesPagedResponse pagedListResponse = client.listSources(parent);
167 
168     List<Source> resources = Lists.newArrayList(pagedListResponse.iterateAll());
169 
170     Assert.assertEquals(1, resources.size());
171     Assert.assertEquals(expectedResponse.getSourcesList().get(0), resources.get(0));
172 
173     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
174     Assert.assertEquals(1, actualRequests.size());
175     ListSourcesRequest actualRequest = ((ListSourcesRequest) actualRequests.get(0));
176 
177     Assert.assertEquals(parent, actualRequest.getParent());
178     Assert.assertTrue(
179         channelProvider.isHeaderSent(
180             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
181             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
182   }
183 
184   @Test
listSourcesExceptionTest2()185   public void listSourcesExceptionTest2() throws Exception {
186     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
187     mockVmMigration.addException(exception);
188 
189     try {
190       String parent = "parent-995424086";
191       client.listSources(parent);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
getSourceTest()199   public void getSourceTest() throws Exception {
200     Source expectedResponse =
201         Source.newBuilder()
202             .setName(SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]").toString())
203             .setCreateTime(Timestamp.newBuilder().build())
204             .setUpdateTime(Timestamp.newBuilder().build())
205             .putAllLabels(new HashMap<String, String>())
206             .setDescription("description-1724546052")
207             .build();
208     mockVmMigration.addResponse(expectedResponse);
209 
210     SourceName name = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
211 
212     Source actualResponse = client.getSource(name);
213     Assert.assertEquals(expectedResponse, actualResponse);
214 
215     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
216     Assert.assertEquals(1, actualRequests.size());
217     GetSourceRequest actualRequest = ((GetSourceRequest) actualRequests.get(0));
218 
219     Assert.assertEquals(name.toString(), actualRequest.getName());
220     Assert.assertTrue(
221         channelProvider.isHeaderSent(
222             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
223             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
224   }
225 
226   @Test
getSourceExceptionTest()227   public void getSourceExceptionTest() throws Exception {
228     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
229     mockVmMigration.addException(exception);
230 
231     try {
232       SourceName name = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
233       client.getSource(name);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
getSourceTest2()241   public void getSourceTest2() throws Exception {
242     Source expectedResponse =
243         Source.newBuilder()
244             .setName(SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]").toString())
245             .setCreateTime(Timestamp.newBuilder().build())
246             .setUpdateTime(Timestamp.newBuilder().build())
247             .putAllLabels(new HashMap<String, String>())
248             .setDescription("description-1724546052")
249             .build();
250     mockVmMigration.addResponse(expectedResponse);
251 
252     String name = "name3373707";
253 
254     Source actualResponse = client.getSource(name);
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
258     Assert.assertEquals(1, actualRequests.size());
259     GetSourceRequest actualRequest = ((GetSourceRequest) actualRequests.get(0));
260 
261     Assert.assertEquals(name, actualRequest.getName());
262     Assert.assertTrue(
263         channelProvider.isHeaderSent(
264             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
265             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
266   }
267 
268   @Test
getSourceExceptionTest2()269   public void getSourceExceptionTest2() throws Exception {
270     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
271     mockVmMigration.addException(exception);
272 
273     try {
274       String name = "name3373707";
275       client.getSource(name);
276       Assert.fail("No exception raised");
277     } catch (InvalidArgumentException e) {
278       // Expected exception.
279     }
280   }
281 
282   @Test
createSourceTest()283   public void createSourceTest() throws Exception {
284     Source expectedResponse =
285         Source.newBuilder()
286             .setName(SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]").toString())
287             .setCreateTime(Timestamp.newBuilder().build())
288             .setUpdateTime(Timestamp.newBuilder().build())
289             .putAllLabels(new HashMap<String, String>())
290             .setDescription("description-1724546052")
291             .build();
292     Operation resultOperation =
293         Operation.newBuilder()
294             .setName("createSourceTest")
295             .setDone(true)
296             .setResponse(Any.pack(expectedResponse))
297             .build();
298     mockVmMigration.addResponse(resultOperation);
299 
300     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
301     Source source = Source.newBuilder().build();
302     String sourceId = "sourceId1746327190";
303 
304     Source actualResponse = client.createSourceAsync(parent, source, sourceId).get();
305     Assert.assertEquals(expectedResponse, actualResponse);
306 
307     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
308     Assert.assertEquals(1, actualRequests.size());
309     CreateSourceRequest actualRequest = ((CreateSourceRequest) actualRequests.get(0));
310 
311     Assert.assertEquals(parent.toString(), actualRequest.getParent());
312     Assert.assertEquals(source, actualRequest.getSource());
313     Assert.assertEquals(sourceId, actualRequest.getSourceId());
314     Assert.assertTrue(
315         channelProvider.isHeaderSent(
316             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
317             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
318   }
319 
320   @Test
createSourceExceptionTest()321   public void createSourceExceptionTest() throws Exception {
322     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
323     mockVmMigration.addException(exception);
324 
325     try {
326       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
327       Source source = Source.newBuilder().build();
328       String sourceId = "sourceId1746327190";
329       client.createSourceAsync(parent, source, sourceId).get();
330       Assert.fail("No exception raised");
331     } catch (ExecutionException e) {
332       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
333       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
334       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
335     }
336   }
337 
338   @Test
createSourceTest2()339   public void createSourceTest2() throws Exception {
340     Source expectedResponse =
341         Source.newBuilder()
342             .setName(SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]").toString())
343             .setCreateTime(Timestamp.newBuilder().build())
344             .setUpdateTime(Timestamp.newBuilder().build())
345             .putAllLabels(new HashMap<String, String>())
346             .setDescription("description-1724546052")
347             .build();
348     Operation resultOperation =
349         Operation.newBuilder()
350             .setName("createSourceTest")
351             .setDone(true)
352             .setResponse(Any.pack(expectedResponse))
353             .build();
354     mockVmMigration.addResponse(resultOperation);
355 
356     String parent = "parent-995424086";
357     Source source = Source.newBuilder().build();
358     String sourceId = "sourceId1746327190";
359 
360     Source actualResponse = client.createSourceAsync(parent, source, sourceId).get();
361     Assert.assertEquals(expectedResponse, actualResponse);
362 
363     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
364     Assert.assertEquals(1, actualRequests.size());
365     CreateSourceRequest actualRequest = ((CreateSourceRequest) actualRequests.get(0));
366 
367     Assert.assertEquals(parent, actualRequest.getParent());
368     Assert.assertEquals(source, actualRequest.getSource());
369     Assert.assertEquals(sourceId, actualRequest.getSourceId());
370     Assert.assertTrue(
371         channelProvider.isHeaderSent(
372             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
373             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
374   }
375 
376   @Test
createSourceExceptionTest2()377   public void createSourceExceptionTest2() throws Exception {
378     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
379     mockVmMigration.addException(exception);
380 
381     try {
382       String parent = "parent-995424086";
383       Source source = Source.newBuilder().build();
384       String sourceId = "sourceId1746327190";
385       client.createSourceAsync(parent, source, sourceId).get();
386       Assert.fail("No exception raised");
387     } catch (ExecutionException e) {
388       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
389       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
390       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
391     }
392   }
393 
394   @Test
updateSourceTest()395   public void updateSourceTest() throws Exception {
396     Source expectedResponse =
397         Source.newBuilder()
398             .setName(SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]").toString())
399             .setCreateTime(Timestamp.newBuilder().build())
400             .setUpdateTime(Timestamp.newBuilder().build())
401             .putAllLabels(new HashMap<String, String>())
402             .setDescription("description-1724546052")
403             .build();
404     Operation resultOperation =
405         Operation.newBuilder()
406             .setName("updateSourceTest")
407             .setDone(true)
408             .setResponse(Any.pack(expectedResponse))
409             .build();
410     mockVmMigration.addResponse(resultOperation);
411 
412     Source source = Source.newBuilder().build();
413     FieldMask updateMask = FieldMask.newBuilder().build();
414 
415     Source actualResponse = client.updateSourceAsync(source, updateMask).get();
416     Assert.assertEquals(expectedResponse, actualResponse);
417 
418     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
419     Assert.assertEquals(1, actualRequests.size());
420     UpdateSourceRequest actualRequest = ((UpdateSourceRequest) actualRequests.get(0));
421 
422     Assert.assertEquals(source, actualRequest.getSource());
423     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
424     Assert.assertTrue(
425         channelProvider.isHeaderSent(
426             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
427             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
428   }
429 
430   @Test
updateSourceExceptionTest()431   public void updateSourceExceptionTest() throws Exception {
432     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
433     mockVmMigration.addException(exception);
434 
435     try {
436       Source source = Source.newBuilder().build();
437       FieldMask updateMask = FieldMask.newBuilder().build();
438       client.updateSourceAsync(source, updateMask).get();
439       Assert.fail("No exception raised");
440     } catch (ExecutionException e) {
441       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
442       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
443       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
444     }
445   }
446 
447   @Test
deleteSourceTest()448   public void deleteSourceTest() throws Exception {
449     Empty expectedResponse = Empty.newBuilder().build();
450     Operation resultOperation =
451         Operation.newBuilder()
452             .setName("deleteSourceTest")
453             .setDone(true)
454             .setResponse(Any.pack(expectedResponse))
455             .build();
456     mockVmMigration.addResponse(resultOperation);
457 
458     SourceName name = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
459 
460     client.deleteSourceAsync(name).get();
461 
462     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
463     Assert.assertEquals(1, actualRequests.size());
464     DeleteSourceRequest actualRequest = ((DeleteSourceRequest) actualRequests.get(0));
465 
466     Assert.assertEquals(name.toString(), actualRequest.getName());
467     Assert.assertTrue(
468         channelProvider.isHeaderSent(
469             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
470             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
471   }
472 
473   @Test
deleteSourceExceptionTest()474   public void deleteSourceExceptionTest() throws Exception {
475     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
476     mockVmMigration.addException(exception);
477 
478     try {
479       SourceName name = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
480       client.deleteSourceAsync(name).get();
481       Assert.fail("No exception raised");
482     } catch (ExecutionException e) {
483       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
484       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
485       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
486     }
487   }
488 
489   @Test
deleteSourceTest2()490   public void deleteSourceTest2() throws Exception {
491     Empty expectedResponse = Empty.newBuilder().build();
492     Operation resultOperation =
493         Operation.newBuilder()
494             .setName("deleteSourceTest")
495             .setDone(true)
496             .setResponse(Any.pack(expectedResponse))
497             .build();
498     mockVmMigration.addResponse(resultOperation);
499 
500     String name = "name3373707";
501 
502     client.deleteSourceAsync(name).get();
503 
504     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
505     Assert.assertEquals(1, actualRequests.size());
506     DeleteSourceRequest actualRequest = ((DeleteSourceRequest) actualRequests.get(0));
507 
508     Assert.assertEquals(name, actualRequest.getName());
509     Assert.assertTrue(
510         channelProvider.isHeaderSent(
511             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
512             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
513   }
514 
515   @Test
deleteSourceExceptionTest2()516   public void deleteSourceExceptionTest2() throws Exception {
517     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
518     mockVmMigration.addException(exception);
519 
520     try {
521       String name = "name3373707";
522       client.deleteSourceAsync(name).get();
523       Assert.fail("No exception raised");
524     } catch (ExecutionException e) {
525       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
526       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
527       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
528     }
529   }
530 
531   @Test
fetchInventoryTest()532   public void fetchInventoryTest() throws Exception {
533     FetchInventoryResponse expectedResponse =
534         FetchInventoryResponse.newBuilder().setUpdateTime(Timestamp.newBuilder().build()).build();
535     mockVmMigration.addResponse(expectedResponse);
536 
537     SourceName source = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
538 
539     FetchInventoryResponse actualResponse = client.fetchInventory(source);
540     Assert.assertEquals(expectedResponse, actualResponse);
541 
542     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
543     Assert.assertEquals(1, actualRequests.size());
544     FetchInventoryRequest actualRequest = ((FetchInventoryRequest) actualRequests.get(0));
545 
546     Assert.assertEquals(source.toString(), actualRequest.getSource());
547     Assert.assertTrue(
548         channelProvider.isHeaderSent(
549             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
550             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
551   }
552 
553   @Test
fetchInventoryExceptionTest()554   public void fetchInventoryExceptionTest() throws Exception {
555     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
556     mockVmMigration.addException(exception);
557 
558     try {
559       SourceName source = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
560       client.fetchInventory(source);
561       Assert.fail("No exception raised");
562     } catch (InvalidArgumentException e) {
563       // Expected exception.
564     }
565   }
566 
567   @Test
fetchInventoryTest2()568   public void fetchInventoryTest2() throws Exception {
569     FetchInventoryResponse expectedResponse =
570         FetchInventoryResponse.newBuilder().setUpdateTime(Timestamp.newBuilder().build()).build();
571     mockVmMigration.addResponse(expectedResponse);
572 
573     String source = "source-896505829";
574 
575     FetchInventoryResponse actualResponse = client.fetchInventory(source);
576     Assert.assertEquals(expectedResponse, actualResponse);
577 
578     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
579     Assert.assertEquals(1, actualRequests.size());
580     FetchInventoryRequest actualRequest = ((FetchInventoryRequest) actualRequests.get(0));
581 
582     Assert.assertEquals(source, actualRequest.getSource());
583     Assert.assertTrue(
584         channelProvider.isHeaderSent(
585             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
586             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
587   }
588 
589   @Test
fetchInventoryExceptionTest2()590   public void fetchInventoryExceptionTest2() throws Exception {
591     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
592     mockVmMigration.addException(exception);
593 
594     try {
595       String source = "source-896505829";
596       client.fetchInventory(source);
597       Assert.fail("No exception raised");
598     } catch (InvalidArgumentException e) {
599       // Expected exception.
600     }
601   }
602 
603   @Test
listUtilizationReportsTest()604   public void listUtilizationReportsTest() throws Exception {
605     UtilizationReport responsesElement = UtilizationReport.newBuilder().build();
606     ListUtilizationReportsResponse expectedResponse =
607         ListUtilizationReportsResponse.newBuilder()
608             .setNextPageToken("")
609             .addAllUtilizationReports(Arrays.asList(responsesElement))
610             .build();
611     mockVmMigration.addResponse(expectedResponse);
612 
613     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
614 
615     ListUtilizationReportsPagedResponse pagedListResponse = client.listUtilizationReports(parent);
616 
617     List<UtilizationReport> resources = Lists.newArrayList(pagedListResponse.iterateAll());
618 
619     Assert.assertEquals(1, resources.size());
620     Assert.assertEquals(expectedResponse.getUtilizationReportsList().get(0), resources.get(0));
621 
622     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
623     Assert.assertEquals(1, actualRequests.size());
624     ListUtilizationReportsRequest actualRequest =
625         ((ListUtilizationReportsRequest) actualRequests.get(0));
626 
627     Assert.assertEquals(parent.toString(), actualRequest.getParent());
628     Assert.assertTrue(
629         channelProvider.isHeaderSent(
630             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
631             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
632   }
633 
634   @Test
listUtilizationReportsExceptionTest()635   public void listUtilizationReportsExceptionTest() throws Exception {
636     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
637     mockVmMigration.addException(exception);
638 
639     try {
640       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
641       client.listUtilizationReports(parent);
642       Assert.fail("No exception raised");
643     } catch (InvalidArgumentException e) {
644       // Expected exception.
645     }
646   }
647 
648   @Test
listUtilizationReportsTest2()649   public void listUtilizationReportsTest2() throws Exception {
650     UtilizationReport responsesElement = UtilizationReport.newBuilder().build();
651     ListUtilizationReportsResponse expectedResponse =
652         ListUtilizationReportsResponse.newBuilder()
653             .setNextPageToken("")
654             .addAllUtilizationReports(Arrays.asList(responsesElement))
655             .build();
656     mockVmMigration.addResponse(expectedResponse);
657 
658     String parent = "parent-995424086";
659 
660     ListUtilizationReportsPagedResponse pagedListResponse = client.listUtilizationReports(parent);
661 
662     List<UtilizationReport> resources = Lists.newArrayList(pagedListResponse.iterateAll());
663 
664     Assert.assertEquals(1, resources.size());
665     Assert.assertEquals(expectedResponse.getUtilizationReportsList().get(0), resources.get(0));
666 
667     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
668     Assert.assertEquals(1, actualRequests.size());
669     ListUtilizationReportsRequest actualRequest =
670         ((ListUtilizationReportsRequest) actualRequests.get(0));
671 
672     Assert.assertEquals(parent, actualRequest.getParent());
673     Assert.assertTrue(
674         channelProvider.isHeaderSent(
675             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
676             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
677   }
678 
679   @Test
listUtilizationReportsExceptionTest2()680   public void listUtilizationReportsExceptionTest2() throws Exception {
681     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
682     mockVmMigration.addException(exception);
683 
684     try {
685       String parent = "parent-995424086";
686       client.listUtilizationReports(parent);
687       Assert.fail("No exception raised");
688     } catch (InvalidArgumentException e) {
689       // Expected exception.
690     }
691   }
692 
693   @Test
getUtilizationReportTest()694   public void getUtilizationReportTest() throws Exception {
695     UtilizationReport expectedResponse =
696         UtilizationReport.newBuilder()
697             .setName(
698                 UtilizationReportName.of(
699                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]")
700                     .toString())
701             .setDisplayName("displayName1714148973")
702             .setStateTime(Timestamp.newBuilder().build())
703             .setError(Status.newBuilder().build())
704             .setCreateTime(Timestamp.newBuilder().build())
705             .setFrameEndTime(Timestamp.newBuilder().build())
706             .setVmCount(261463431)
707             .addAllVms(new ArrayList<VmUtilizationInfo>())
708             .build();
709     mockVmMigration.addResponse(expectedResponse);
710 
711     UtilizationReportName name =
712         UtilizationReportName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]");
713 
714     UtilizationReport actualResponse = client.getUtilizationReport(name);
715     Assert.assertEquals(expectedResponse, actualResponse);
716 
717     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
718     Assert.assertEquals(1, actualRequests.size());
719     GetUtilizationReportRequest actualRequest =
720         ((GetUtilizationReportRequest) actualRequests.get(0));
721 
722     Assert.assertEquals(name.toString(), actualRequest.getName());
723     Assert.assertTrue(
724         channelProvider.isHeaderSent(
725             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
726             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
727   }
728 
729   @Test
getUtilizationReportExceptionTest()730   public void getUtilizationReportExceptionTest() throws Exception {
731     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
732     mockVmMigration.addException(exception);
733 
734     try {
735       UtilizationReportName name =
736           UtilizationReportName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]");
737       client.getUtilizationReport(name);
738       Assert.fail("No exception raised");
739     } catch (InvalidArgumentException e) {
740       // Expected exception.
741     }
742   }
743 
744   @Test
getUtilizationReportTest2()745   public void getUtilizationReportTest2() throws Exception {
746     UtilizationReport expectedResponse =
747         UtilizationReport.newBuilder()
748             .setName(
749                 UtilizationReportName.of(
750                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]")
751                     .toString())
752             .setDisplayName("displayName1714148973")
753             .setStateTime(Timestamp.newBuilder().build())
754             .setError(Status.newBuilder().build())
755             .setCreateTime(Timestamp.newBuilder().build())
756             .setFrameEndTime(Timestamp.newBuilder().build())
757             .setVmCount(261463431)
758             .addAllVms(new ArrayList<VmUtilizationInfo>())
759             .build();
760     mockVmMigration.addResponse(expectedResponse);
761 
762     String name = "name3373707";
763 
764     UtilizationReport actualResponse = client.getUtilizationReport(name);
765     Assert.assertEquals(expectedResponse, actualResponse);
766 
767     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
768     Assert.assertEquals(1, actualRequests.size());
769     GetUtilizationReportRequest actualRequest =
770         ((GetUtilizationReportRequest) actualRequests.get(0));
771 
772     Assert.assertEquals(name, actualRequest.getName());
773     Assert.assertTrue(
774         channelProvider.isHeaderSent(
775             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
776             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
777   }
778 
779   @Test
getUtilizationReportExceptionTest2()780   public void getUtilizationReportExceptionTest2() throws Exception {
781     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
782     mockVmMigration.addException(exception);
783 
784     try {
785       String name = "name3373707";
786       client.getUtilizationReport(name);
787       Assert.fail("No exception raised");
788     } catch (InvalidArgumentException e) {
789       // Expected exception.
790     }
791   }
792 
793   @Test
createUtilizationReportTest()794   public void createUtilizationReportTest() throws Exception {
795     UtilizationReport expectedResponse =
796         UtilizationReport.newBuilder()
797             .setName(
798                 UtilizationReportName.of(
799                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]")
800                     .toString())
801             .setDisplayName("displayName1714148973")
802             .setStateTime(Timestamp.newBuilder().build())
803             .setError(Status.newBuilder().build())
804             .setCreateTime(Timestamp.newBuilder().build())
805             .setFrameEndTime(Timestamp.newBuilder().build())
806             .setVmCount(261463431)
807             .addAllVms(new ArrayList<VmUtilizationInfo>())
808             .build();
809     Operation resultOperation =
810         Operation.newBuilder()
811             .setName("createUtilizationReportTest")
812             .setDone(true)
813             .setResponse(Any.pack(expectedResponse))
814             .build();
815     mockVmMigration.addResponse(resultOperation);
816 
817     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
818     UtilizationReport utilizationReport = UtilizationReport.newBuilder().build();
819     String utilizationReportId = "utilizationReportId1215771057";
820 
821     UtilizationReport actualResponse =
822         client.createUtilizationReportAsync(parent, utilizationReport, utilizationReportId).get();
823     Assert.assertEquals(expectedResponse, actualResponse);
824 
825     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
826     Assert.assertEquals(1, actualRequests.size());
827     CreateUtilizationReportRequest actualRequest =
828         ((CreateUtilizationReportRequest) actualRequests.get(0));
829 
830     Assert.assertEquals(parent.toString(), actualRequest.getParent());
831     Assert.assertEquals(utilizationReport, actualRequest.getUtilizationReport());
832     Assert.assertEquals(utilizationReportId, actualRequest.getUtilizationReportId());
833     Assert.assertTrue(
834         channelProvider.isHeaderSent(
835             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
836             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
837   }
838 
839   @Test
createUtilizationReportExceptionTest()840   public void createUtilizationReportExceptionTest() throws Exception {
841     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
842     mockVmMigration.addException(exception);
843 
844     try {
845       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
846       UtilizationReport utilizationReport = UtilizationReport.newBuilder().build();
847       String utilizationReportId = "utilizationReportId1215771057";
848       client.createUtilizationReportAsync(parent, utilizationReport, utilizationReportId).get();
849       Assert.fail("No exception raised");
850     } catch (ExecutionException e) {
851       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
852       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
853       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
854     }
855   }
856 
857   @Test
createUtilizationReportTest2()858   public void createUtilizationReportTest2() throws Exception {
859     UtilizationReport expectedResponse =
860         UtilizationReport.newBuilder()
861             .setName(
862                 UtilizationReportName.of(
863                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]")
864                     .toString())
865             .setDisplayName("displayName1714148973")
866             .setStateTime(Timestamp.newBuilder().build())
867             .setError(Status.newBuilder().build())
868             .setCreateTime(Timestamp.newBuilder().build())
869             .setFrameEndTime(Timestamp.newBuilder().build())
870             .setVmCount(261463431)
871             .addAllVms(new ArrayList<VmUtilizationInfo>())
872             .build();
873     Operation resultOperation =
874         Operation.newBuilder()
875             .setName("createUtilizationReportTest")
876             .setDone(true)
877             .setResponse(Any.pack(expectedResponse))
878             .build();
879     mockVmMigration.addResponse(resultOperation);
880 
881     String parent = "parent-995424086";
882     UtilizationReport utilizationReport = UtilizationReport.newBuilder().build();
883     String utilizationReportId = "utilizationReportId1215771057";
884 
885     UtilizationReport actualResponse =
886         client.createUtilizationReportAsync(parent, utilizationReport, utilizationReportId).get();
887     Assert.assertEquals(expectedResponse, actualResponse);
888 
889     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
890     Assert.assertEquals(1, actualRequests.size());
891     CreateUtilizationReportRequest actualRequest =
892         ((CreateUtilizationReportRequest) actualRequests.get(0));
893 
894     Assert.assertEquals(parent, actualRequest.getParent());
895     Assert.assertEquals(utilizationReport, actualRequest.getUtilizationReport());
896     Assert.assertEquals(utilizationReportId, actualRequest.getUtilizationReportId());
897     Assert.assertTrue(
898         channelProvider.isHeaderSent(
899             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
900             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
901   }
902 
903   @Test
createUtilizationReportExceptionTest2()904   public void createUtilizationReportExceptionTest2() throws Exception {
905     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
906     mockVmMigration.addException(exception);
907 
908     try {
909       String parent = "parent-995424086";
910       UtilizationReport utilizationReport = UtilizationReport.newBuilder().build();
911       String utilizationReportId = "utilizationReportId1215771057";
912       client.createUtilizationReportAsync(parent, utilizationReport, utilizationReportId).get();
913       Assert.fail("No exception raised");
914     } catch (ExecutionException e) {
915       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
916       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
917       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
918     }
919   }
920 
921   @Test
deleteUtilizationReportTest()922   public void deleteUtilizationReportTest() throws Exception {
923     Empty expectedResponse = Empty.newBuilder().build();
924     Operation resultOperation =
925         Operation.newBuilder()
926             .setName("deleteUtilizationReportTest")
927             .setDone(true)
928             .setResponse(Any.pack(expectedResponse))
929             .build();
930     mockVmMigration.addResponse(resultOperation);
931 
932     UtilizationReportName name =
933         UtilizationReportName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]");
934 
935     client.deleteUtilizationReportAsync(name).get();
936 
937     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
938     Assert.assertEquals(1, actualRequests.size());
939     DeleteUtilizationReportRequest actualRequest =
940         ((DeleteUtilizationReportRequest) actualRequests.get(0));
941 
942     Assert.assertEquals(name.toString(), actualRequest.getName());
943     Assert.assertTrue(
944         channelProvider.isHeaderSent(
945             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
946             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
947   }
948 
949   @Test
deleteUtilizationReportExceptionTest()950   public void deleteUtilizationReportExceptionTest() throws Exception {
951     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
952     mockVmMigration.addException(exception);
953 
954     try {
955       UtilizationReportName name =
956           UtilizationReportName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[UTILIZATION_REPORT]");
957       client.deleteUtilizationReportAsync(name).get();
958       Assert.fail("No exception raised");
959     } catch (ExecutionException e) {
960       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
961       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
962       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
963     }
964   }
965 
966   @Test
deleteUtilizationReportTest2()967   public void deleteUtilizationReportTest2() throws Exception {
968     Empty expectedResponse = Empty.newBuilder().build();
969     Operation resultOperation =
970         Operation.newBuilder()
971             .setName("deleteUtilizationReportTest")
972             .setDone(true)
973             .setResponse(Any.pack(expectedResponse))
974             .build();
975     mockVmMigration.addResponse(resultOperation);
976 
977     String name = "name3373707";
978 
979     client.deleteUtilizationReportAsync(name).get();
980 
981     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
982     Assert.assertEquals(1, actualRequests.size());
983     DeleteUtilizationReportRequest actualRequest =
984         ((DeleteUtilizationReportRequest) actualRequests.get(0));
985 
986     Assert.assertEquals(name, actualRequest.getName());
987     Assert.assertTrue(
988         channelProvider.isHeaderSent(
989             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
990             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
991   }
992 
993   @Test
deleteUtilizationReportExceptionTest2()994   public void deleteUtilizationReportExceptionTest2() throws Exception {
995     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
996     mockVmMigration.addException(exception);
997 
998     try {
999       String name = "name3373707";
1000       client.deleteUtilizationReportAsync(name).get();
1001       Assert.fail("No exception raised");
1002     } catch (ExecutionException e) {
1003       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1004       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1005       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1006     }
1007   }
1008 
1009   @Test
listDatacenterConnectorsTest()1010   public void listDatacenterConnectorsTest() throws Exception {
1011     DatacenterConnector responsesElement = DatacenterConnector.newBuilder().build();
1012     ListDatacenterConnectorsResponse expectedResponse =
1013         ListDatacenterConnectorsResponse.newBuilder()
1014             .setNextPageToken("")
1015             .addAllDatacenterConnectors(Arrays.asList(responsesElement))
1016             .build();
1017     mockVmMigration.addResponse(expectedResponse);
1018 
1019     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1020 
1021     ListDatacenterConnectorsPagedResponse pagedListResponse =
1022         client.listDatacenterConnectors(parent);
1023 
1024     List<DatacenterConnector> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1025 
1026     Assert.assertEquals(1, resources.size());
1027     Assert.assertEquals(expectedResponse.getDatacenterConnectorsList().get(0), resources.get(0));
1028 
1029     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1030     Assert.assertEquals(1, actualRequests.size());
1031     ListDatacenterConnectorsRequest actualRequest =
1032         ((ListDatacenterConnectorsRequest) actualRequests.get(0));
1033 
1034     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1035     Assert.assertTrue(
1036         channelProvider.isHeaderSent(
1037             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1038             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1039   }
1040 
1041   @Test
listDatacenterConnectorsExceptionTest()1042   public void listDatacenterConnectorsExceptionTest() throws Exception {
1043     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1044     mockVmMigration.addException(exception);
1045 
1046     try {
1047       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1048       client.listDatacenterConnectors(parent);
1049       Assert.fail("No exception raised");
1050     } catch (InvalidArgumentException e) {
1051       // Expected exception.
1052     }
1053   }
1054 
1055   @Test
listDatacenterConnectorsTest2()1056   public void listDatacenterConnectorsTest2() throws Exception {
1057     DatacenterConnector responsesElement = DatacenterConnector.newBuilder().build();
1058     ListDatacenterConnectorsResponse expectedResponse =
1059         ListDatacenterConnectorsResponse.newBuilder()
1060             .setNextPageToken("")
1061             .addAllDatacenterConnectors(Arrays.asList(responsesElement))
1062             .build();
1063     mockVmMigration.addResponse(expectedResponse);
1064 
1065     String parent = "parent-995424086";
1066 
1067     ListDatacenterConnectorsPagedResponse pagedListResponse =
1068         client.listDatacenterConnectors(parent);
1069 
1070     List<DatacenterConnector> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1071 
1072     Assert.assertEquals(1, resources.size());
1073     Assert.assertEquals(expectedResponse.getDatacenterConnectorsList().get(0), resources.get(0));
1074 
1075     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1076     Assert.assertEquals(1, actualRequests.size());
1077     ListDatacenterConnectorsRequest actualRequest =
1078         ((ListDatacenterConnectorsRequest) actualRequests.get(0));
1079 
1080     Assert.assertEquals(parent, actualRequest.getParent());
1081     Assert.assertTrue(
1082         channelProvider.isHeaderSent(
1083             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1084             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1085   }
1086 
1087   @Test
listDatacenterConnectorsExceptionTest2()1088   public void listDatacenterConnectorsExceptionTest2() throws Exception {
1089     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1090     mockVmMigration.addException(exception);
1091 
1092     try {
1093       String parent = "parent-995424086";
1094       client.listDatacenterConnectors(parent);
1095       Assert.fail("No exception raised");
1096     } catch (InvalidArgumentException e) {
1097       // Expected exception.
1098     }
1099   }
1100 
1101   @Test
getDatacenterConnectorTest()1102   public void getDatacenterConnectorTest() throws Exception {
1103     DatacenterConnector expectedResponse =
1104         DatacenterConnector.newBuilder()
1105             .setCreateTime(Timestamp.newBuilder().build())
1106             .setUpdateTime(Timestamp.newBuilder().build())
1107             .setName(
1108                 DatacenterConnectorName.of(
1109                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1110                     .toString())
1111             .setRegistrationId("registrationId-567498828")
1112             .setServiceAccount("serviceAccount1079137720")
1113             .setVersion("version351608024")
1114             .setBucket("bucket-1378203158")
1115             .setStateTime(Timestamp.newBuilder().build())
1116             .setError(Status.newBuilder().build())
1117             .setApplianceInfrastructureVersion("applianceInfrastructureVersion560843272")
1118             .setApplianceSoftwareVersion("applianceSoftwareVersion-1982719036")
1119             .setAvailableVersions(AvailableUpdates.newBuilder().build())
1120             .setUpgradeStatus(UpgradeStatus.newBuilder().build())
1121             .build();
1122     mockVmMigration.addResponse(expectedResponse);
1123 
1124     DatacenterConnectorName name =
1125         DatacenterConnectorName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]");
1126 
1127     DatacenterConnector actualResponse = client.getDatacenterConnector(name);
1128     Assert.assertEquals(expectedResponse, actualResponse);
1129 
1130     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1131     Assert.assertEquals(1, actualRequests.size());
1132     GetDatacenterConnectorRequest actualRequest =
1133         ((GetDatacenterConnectorRequest) actualRequests.get(0));
1134 
1135     Assert.assertEquals(name.toString(), actualRequest.getName());
1136     Assert.assertTrue(
1137         channelProvider.isHeaderSent(
1138             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1139             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1140   }
1141 
1142   @Test
getDatacenterConnectorExceptionTest()1143   public void getDatacenterConnectorExceptionTest() throws Exception {
1144     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1145     mockVmMigration.addException(exception);
1146 
1147     try {
1148       DatacenterConnectorName name =
1149           DatacenterConnectorName.of(
1150               "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]");
1151       client.getDatacenterConnector(name);
1152       Assert.fail("No exception raised");
1153     } catch (InvalidArgumentException e) {
1154       // Expected exception.
1155     }
1156   }
1157 
1158   @Test
getDatacenterConnectorTest2()1159   public void getDatacenterConnectorTest2() throws Exception {
1160     DatacenterConnector expectedResponse =
1161         DatacenterConnector.newBuilder()
1162             .setCreateTime(Timestamp.newBuilder().build())
1163             .setUpdateTime(Timestamp.newBuilder().build())
1164             .setName(
1165                 DatacenterConnectorName.of(
1166                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1167                     .toString())
1168             .setRegistrationId("registrationId-567498828")
1169             .setServiceAccount("serviceAccount1079137720")
1170             .setVersion("version351608024")
1171             .setBucket("bucket-1378203158")
1172             .setStateTime(Timestamp.newBuilder().build())
1173             .setError(Status.newBuilder().build())
1174             .setApplianceInfrastructureVersion("applianceInfrastructureVersion560843272")
1175             .setApplianceSoftwareVersion("applianceSoftwareVersion-1982719036")
1176             .setAvailableVersions(AvailableUpdates.newBuilder().build())
1177             .setUpgradeStatus(UpgradeStatus.newBuilder().build())
1178             .build();
1179     mockVmMigration.addResponse(expectedResponse);
1180 
1181     String name = "name3373707";
1182 
1183     DatacenterConnector actualResponse = client.getDatacenterConnector(name);
1184     Assert.assertEquals(expectedResponse, actualResponse);
1185 
1186     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1187     Assert.assertEquals(1, actualRequests.size());
1188     GetDatacenterConnectorRequest actualRequest =
1189         ((GetDatacenterConnectorRequest) actualRequests.get(0));
1190 
1191     Assert.assertEquals(name, actualRequest.getName());
1192     Assert.assertTrue(
1193         channelProvider.isHeaderSent(
1194             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1195             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1196   }
1197 
1198   @Test
getDatacenterConnectorExceptionTest2()1199   public void getDatacenterConnectorExceptionTest2() throws Exception {
1200     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1201     mockVmMigration.addException(exception);
1202 
1203     try {
1204       String name = "name3373707";
1205       client.getDatacenterConnector(name);
1206       Assert.fail("No exception raised");
1207     } catch (InvalidArgumentException e) {
1208       // Expected exception.
1209     }
1210   }
1211 
1212   @Test
createDatacenterConnectorTest()1213   public void createDatacenterConnectorTest() throws Exception {
1214     DatacenterConnector expectedResponse =
1215         DatacenterConnector.newBuilder()
1216             .setCreateTime(Timestamp.newBuilder().build())
1217             .setUpdateTime(Timestamp.newBuilder().build())
1218             .setName(
1219                 DatacenterConnectorName.of(
1220                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1221                     .toString())
1222             .setRegistrationId("registrationId-567498828")
1223             .setServiceAccount("serviceAccount1079137720")
1224             .setVersion("version351608024")
1225             .setBucket("bucket-1378203158")
1226             .setStateTime(Timestamp.newBuilder().build())
1227             .setError(Status.newBuilder().build())
1228             .setApplianceInfrastructureVersion("applianceInfrastructureVersion560843272")
1229             .setApplianceSoftwareVersion("applianceSoftwareVersion-1982719036")
1230             .setAvailableVersions(AvailableUpdates.newBuilder().build())
1231             .setUpgradeStatus(UpgradeStatus.newBuilder().build())
1232             .build();
1233     Operation resultOperation =
1234         Operation.newBuilder()
1235             .setName("createDatacenterConnectorTest")
1236             .setDone(true)
1237             .setResponse(Any.pack(expectedResponse))
1238             .build();
1239     mockVmMigration.addResponse(resultOperation);
1240 
1241     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1242     DatacenterConnector datacenterConnector = DatacenterConnector.newBuilder().build();
1243     String datacenterConnectorId = "datacenterConnectorId-761889719";
1244 
1245     DatacenterConnector actualResponse =
1246         client
1247             .createDatacenterConnectorAsync(parent, datacenterConnector, datacenterConnectorId)
1248             .get();
1249     Assert.assertEquals(expectedResponse, actualResponse);
1250 
1251     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1252     Assert.assertEquals(1, actualRequests.size());
1253     CreateDatacenterConnectorRequest actualRequest =
1254         ((CreateDatacenterConnectorRequest) actualRequests.get(0));
1255 
1256     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1257     Assert.assertEquals(datacenterConnector, actualRequest.getDatacenterConnector());
1258     Assert.assertEquals(datacenterConnectorId, actualRequest.getDatacenterConnectorId());
1259     Assert.assertTrue(
1260         channelProvider.isHeaderSent(
1261             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1262             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1263   }
1264 
1265   @Test
createDatacenterConnectorExceptionTest()1266   public void createDatacenterConnectorExceptionTest() throws Exception {
1267     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1268     mockVmMigration.addException(exception);
1269 
1270     try {
1271       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1272       DatacenterConnector datacenterConnector = DatacenterConnector.newBuilder().build();
1273       String datacenterConnectorId = "datacenterConnectorId-761889719";
1274       client
1275           .createDatacenterConnectorAsync(parent, datacenterConnector, datacenterConnectorId)
1276           .get();
1277       Assert.fail("No exception raised");
1278     } catch (ExecutionException e) {
1279       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1280       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1281       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1282     }
1283   }
1284 
1285   @Test
createDatacenterConnectorTest2()1286   public void createDatacenterConnectorTest2() throws Exception {
1287     DatacenterConnector expectedResponse =
1288         DatacenterConnector.newBuilder()
1289             .setCreateTime(Timestamp.newBuilder().build())
1290             .setUpdateTime(Timestamp.newBuilder().build())
1291             .setName(
1292                 DatacenterConnectorName.of(
1293                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1294                     .toString())
1295             .setRegistrationId("registrationId-567498828")
1296             .setServiceAccount("serviceAccount1079137720")
1297             .setVersion("version351608024")
1298             .setBucket("bucket-1378203158")
1299             .setStateTime(Timestamp.newBuilder().build())
1300             .setError(Status.newBuilder().build())
1301             .setApplianceInfrastructureVersion("applianceInfrastructureVersion560843272")
1302             .setApplianceSoftwareVersion("applianceSoftwareVersion-1982719036")
1303             .setAvailableVersions(AvailableUpdates.newBuilder().build())
1304             .setUpgradeStatus(UpgradeStatus.newBuilder().build())
1305             .build();
1306     Operation resultOperation =
1307         Operation.newBuilder()
1308             .setName("createDatacenterConnectorTest")
1309             .setDone(true)
1310             .setResponse(Any.pack(expectedResponse))
1311             .build();
1312     mockVmMigration.addResponse(resultOperation);
1313 
1314     String parent = "parent-995424086";
1315     DatacenterConnector datacenterConnector = DatacenterConnector.newBuilder().build();
1316     String datacenterConnectorId = "datacenterConnectorId-761889719";
1317 
1318     DatacenterConnector actualResponse =
1319         client
1320             .createDatacenterConnectorAsync(parent, datacenterConnector, datacenterConnectorId)
1321             .get();
1322     Assert.assertEquals(expectedResponse, actualResponse);
1323 
1324     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1325     Assert.assertEquals(1, actualRequests.size());
1326     CreateDatacenterConnectorRequest actualRequest =
1327         ((CreateDatacenterConnectorRequest) actualRequests.get(0));
1328 
1329     Assert.assertEquals(parent, actualRequest.getParent());
1330     Assert.assertEquals(datacenterConnector, actualRequest.getDatacenterConnector());
1331     Assert.assertEquals(datacenterConnectorId, actualRequest.getDatacenterConnectorId());
1332     Assert.assertTrue(
1333         channelProvider.isHeaderSent(
1334             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1335             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1336   }
1337 
1338   @Test
createDatacenterConnectorExceptionTest2()1339   public void createDatacenterConnectorExceptionTest2() throws Exception {
1340     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1341     mockVmMigration.addException(exception);
1342 
1343     try {
1344       String parent = "parent-995424086";
1345       DatacenterConnector datacenterConnector = DatacenterConnector.newBuilder().build();
1346       String datacenterConnectorId = "datacenterConnectorId-761889719";
1347       client
1348           .createDatacenterConnectorAsync(parent, datacenterConnector, datacenterConnectorId)
1349           .get();
1350       Assert.fail("No exception raised");
1351     } catch (ExecutionException e) {
1352       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1353       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1354       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1355     }
1356   }
1357 
1358   @Test
deleteDatacenterConnectorTest()1359   public void deleteDatacenterConnectorTest() throws Exception {
1360     Empty expectedResponse = Empty.newBuilder().build();
1361     Operation resultOperation =
1362         Operation.newBuilder()
1363             .setName("deleteDatacenterConnectorTest")
1364             .setDone(true)
1365             .setResponse(Any.pack(expectedResponse))
1366             .build();
1367     mockVmMigration.addResponse(resultOperation);
1368 
1369     DatacenterConnectorName name =
1370         DatacenterConnectorName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]");
1371 
1372     client.deleteDatacenterConnectorAsync(name).get();
1373 
1374     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1375     Assert.assertEquals(1, actualRequests.size());
1376     DeleteDatacenterConnectorRequest actualRequest =
1377         ((DeleteDatacenterConnectorRequest) actualRequests.get(0));
1378 
1379     Assert.assertEquals(name.toString(), actualRequest.getName());
1380     Assert.assertTrue(
1381         channelProvider.isHeaderSent(
1382             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1383             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1384   }
1385 
1386   @Test
deleteDatacenterConnectorExceptionTest()1387   public void deleteDatacenterConnectorExceptionTest() throws Exception {
1388     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1389     mockVmMigration.addException(exception);
1390 
1391     try {
1392       DatacenterConnectorName name =
1393           DatacenterConnectorName.of(
1394               "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]");
1395       client.deleteDatacenterConnectorAsync(name).get();
1396       Assert.fail("No exception raised");
1397     } catch (ExecutionException e) {
1398       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1399       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1400       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1401     }
1402   }
1403 
1404   @Test
deleteDatacenterConnectorTest2()1405   public void deleteDatacenterConnectorTest2() throws Exception {
1406     Empty expectedResponse = Empty.newBuilder().build();
1407     Operation resultOperation =
1408         Operation.newBuilder()
1409             .setName("deleteDatacenterConnectorTest")
1410             .setDone(true)
1411             .setResponse(Any.pack(expectedResponse))
1412             .build();
1413     mockVmMigration.addResponse(resultOperation);
1414 
1415     String name = "name3373707";
1416 
1417     client.deleteDatacenterConnectorAsync(name).get();
1418 
1419     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1420     Assert.assertEquals(1, actualRequests.size());
1421     DeleteDatacenterConnectorRequest actualRequest =
1422         ((DeleteDatacenterConnectorRequest) actualRequests.get(0));
1423 
1424     Assert.assertEquals(name, actualRequest.getName());
1425     Assert.assertTrue(
1426         channelProvider.isHeaderSent(
1427             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1428             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1429   }
1430 
1431   @Test
deleteDatacenterConnectorExceptionTest2()1432   public void deleteDatacenterConnectorExceptionTest2() throws Exception {
1433     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1434     mockVmMigration.addException(exception);
1435 
1436     try {
1437       String name = "name3373707";
1438       client.deleteDatacenterConnectorAsync(name).get();
1439       Assert.fail("No exception raised");
1440     } catch (ExecutionException e) {
1441       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1442       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1443       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1444     }
1445   }
1446 
1447   @Test
upgradeApplianceTest()1448   public void upgradeApplianceTest() throws Exception {
1449     UpgradeApplianceResponse expectedResponse = UpgradeApplianceResponse.newBuilder().build();
1450     Operation resultOperation =
1451         Operation.newBuilder()
1452             .setName("upgradeApplianceTest")
1453             .setDone(true)
1454             .setResponse(Any.pack(expectedResponse))
1455             .build();
1456     mockVmMigration.addResponse(resultOperation);
1457 
1458     UpgradeApplianceRequest request =
1459         UpgradeApplianceRequest.newBuilder()
1460             .setDatacenterConnector(
1461                 DatacenterConnectorName.of(
1462                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1463                     .toString())
1464             .setRequestId("requestId693933066")
1465             .build();
1466 
1467     UpgradeApplianceResponse actualResponse = client.upgradeApplianceAsync(request).get();
1468     Assert.assertEquals(expectedResponse, actualResponse);
1469 
1470     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1471     Assert.assertEquals(1, actualRequests.size());
1472     UpgradeApplianceRequest actualRequest = ((UpgradeApplianceRequest) actualRequests.get(0));
1473 
1474     Assert.assertEquals(request.getDatacenterConnector(), actualRequest.getDatacenterConnector());
1475     Assert.assertEquals(request.getRequestId(), actualRequest.getRequestId());
1476     Assert.assertTrue(
1477         channelProvider.isHeaderSent(
1478             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1479             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1480   }
1481 
1482   @Test
upgradeApplianceExceptionTest()1483   public void upgradeApplianceExceptionTest() throws Exception {
1484     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1485     mockVmMigration.addException(exception);
1486 
1487     try {
1488       UpgradeApplianceRequest request =
1489           UpgradeApplianceRequest.newBuilder()
1490               .setDatacenterConnector(
1491                   DatacenterConnectorName.of(
1492                           "[PROJECT]", "[LOCATION]", "[SOURCE]", "[DATACENTER_CONNECTOR]")
1493                       .toString())
1494               .setRequestId("requestId693933066")
1495               .build();
1496       client.upgradeApplianceAsync(request).get();
1497       Assert.fail("No exception raised");
1498     } catch (ExecutionException e) {
1499       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1500       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1501       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1502     }
1503   }
1504 
1505   @Test
createMigratingVmTest()1506   public void createMigratingVmTest() throws Exception {
1507     MigratingVm expectedResponse =
1508         MigratingVm.newBuilder()
1509             .setName(
1510                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
1511                     .toString())
1512             .setSourceVmId("sourceVmId-1111384851")
1513             .setDisplayName("displayName1714148973")
1514             .setDescription("description-1724546052")
1515             .setPolicy(SchedulePolicy.newBuilder().build())
1516             .setCreateTime(Timestamp.newBuilder().build())
1517             .setUpdateTime(Timestamp.newBuilder().build())
1518             .setLastSync(ReplicationSync.newBuilder().build())
1519             .setStateTime(Timestamp.newBuilder().build())
1520             .setCurrentSyncInfo(ReplicationCycle.newBuilder().build())
1521             .setGroup(LocationName.of("[PROJECT]", "[LOCATION]").toString())
1522             .putAllLabels(new HashMap<String, String>())
1523             .addAllRecentCloneJobs(new ArrayList<CloneJob>())
1524             .setError(Status.newBuilder().build())
1525             .addAllRecentCutoverJobs(new ArrayList<CutoverJob>())
1526             .build();
1527     Operation resultOperation =
1528         Operation.newBuilder()
1529             .setName("createMigratingVmTest")
1530             .setDone(true)
1531             .setResponse(Any.pack(expectedResponse))
1532             .build();
1533     mockVmMigration.addResponse(resultOperation);
1534 
1535     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1536     MigratingVm migratingVm = MigratingVm.newBuilder().build();
1537     String migratingVmId = "migratingVmId441244154";
1538 
1539     MigratingVm actualResponse =
1540         client.createMigratingVmAsync(parent, migratingVm, migratingVmId).get();
1541     Assert.assertEquals(expectedResponse, actualResponse);
1542 
1543     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1544     Assert.assertEquals(1, actualRequests.size());
1545     CreateMigratingVmRequest actualRequest = ((CreateMigratingVmRequest) actualRequests.get(0));
1546 
1547     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1548     Assert.assertEquals(migratingVm, actualRequest.getMigratingVm());
1549     Assert.assertEquals(migratingVmId, actualRequest.getMigratingVmId());
1550     Assert.assertTrue(
1551         channelProvider.isHeaderSent(
1552             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1553             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1554   }
1555 
1556   @Test
createMigratingVmExceptionTest()1557   public void createMigratingVmExceptionTest() throws Exception {
1558     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1559     mockVmMigration.addException(exception);
1560 
1561     try {
1562       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1563       MigratingVm migratingVm = MigratingVm.newBuilder().build();
1564       String migratingVmId = "migratingVmId441244154";
1565       client.createMigratingVmAsync(parent, migratingVm, migratingVmId).get();
1566       Assert.fail("No exception raised");
1567     } catch (ExecutionException e) {
1568       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1569       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1570       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1571     }
1572   }
1573 
1574   @Test
createMigratingVmTest2()1575   public void createMigratingVmTest2() throws Exception {
1576     MigratingVm expectedResponse =
1577         MigratingVm.newBuilder()
1578             .setName(
1579                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
1580                     .toString())
1581             .setSourceVmId("sourceVmId-1111384851")
1582             .setDisplayName("displayName1714148973")
1583             .setDescription("description-1724546052")
1584             .setPolicy(SchedulePolicy.newBuilder().build())
1585             .setCreateTime(Timestamp.newBuilder().build())
1586             .setUpdateTime(Timestamp.newBuilder().build())
1587             .setLastSync(ReplicationSync.newBuilder().build())
1588             .setStateTime(Timestamp.newBuilder().build())
1589             .setCurrentSyncInfo(ReplicationCycle.newBuilder().build())
1590             .setGroup(LocationName.of("[PROJECT]", "[LOCATION]").toString())
1591             .putAllLabels(new HashMap<String, String>())
1592             .addAllRecentCloneJobs(new ArrayList<CloneJob>())
1593             .setError(Status.newBuilder().build())
1594             .addAllRecentCutoverJobs(new ArrayList<CutoverJob>())
1595             .build();
1596     Operation resultOperation =
1597         Operation.newBuilder()
1598             .setName("createMigratingVmTest")
1599             .setDone(true)
1600             .setResponse(Any.pack(expectedResponse))
1601             .build();
1602     mockVmMigration.addResponse(resultOperation);
1603 
1604     String parent = "parent-995424086";
1605     MigratingVm migratingVm = MigratingVm.newBuilder().build();
1606     String migratingVmId = "migratingVmId441244154";
1607 
1608     MigratingVm actualResponse =
1609         client.createMigratingVmAsync(parent, migratingVm, migratingVmId).get();
1610     Assert.assertEquals(expectedResponse, actualResponse);
1611 
1612     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1613     Assert.assertEquals(1, actualRequests.size());
1614     CreateMigratingVmRequest actualRequest = ((CreateMigratingVmRequest) actualRequests.get(0));
1615 
1616     Assert.assertEquals(parent, actualRequest.getParent());
1617     Assert.assertEquals(migratingVm, actualRequest.getMigratingVm());
1618     Assert.assertEquals(migratingVmId, actualRequest.getMigratingVmId());
1619     Assert.assertTrue(
1620         channelProvider.isHeaderSent(
1621             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1622             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1623   }
1624 
1625   @Test
createMigratingVmExceptionTest2()1626   public void createMigratingVmExceptionTest2() throws Exception {
1627     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1628     mockVmMigration.addException(exception);
1629 
1630     try {
1631       String parent = "parent-995424086";
1632       MigratingVm migratingVm = MigratingVm.newBuilder().build();
1633       String migratingVmId = "migratingVmId441244154";
1634       client.createMigratingVmAsync(parent, migratingVm, migratingVmId).get();
1635       Assert.fail("No exception raised");
1636     } catch (ExecutionException e) {
1637       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1638       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1639       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1640     }
1641   }
1642 
1643   @Test
listMigratingVmsTest()1644   public void listMigratingVmsTest() throws Exception {
1645     MigratingVm responsesElement = MigratingVm.newBuilder().build();
1646     ListMigratingVmsResponse expectedResponse =
1647         ListMigratingVmsResponse.newBuilder()
1648             .setNextPageToken("")
1649             .addAllMigratingVms(Arrays.asList(responsesElement))
1650             .build();
1651     mockVmMigration.addResponse(expectedResponse);
1652 
1653     SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1654 
1655     ListMigratingVmsPagedResponse pagedListResponse = client.listMigratingVms(parent);
1656 
1657     List<MigratingVm> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1658 
1659     Assert.assertEquals(1, resources.size());
1660     Assert.assertEquals(expectedResponse.getMigratingVmsList().get(0), resources.get(0));
1661 
1662     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1663     Assert.assertEquals(1, actualRequests.size());
1664     ListMigratingVmsRequest actualRequest = ((ListMigratingVmsRequest) actualRequests.get(0));
1665 
1666     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1667     Assert.assertTrue(
1668         channelProvider.isHeaderSent(
1669             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1670             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1671   }
1672 
1673   @Test
listMigratingVmsExceptionTest()1674   public void listMigratingVmsExceptionTest() throws Exception {
1675     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1676     mockVmMigration.addException(exception);
1677 
1678     try {
1679       SourceName parent = SourceName.of("[PROJECT]", "[LOCATION]", "[SOURCE]");
1680       client.listMigratingVms(parent);
1681       Assert.fail("No exception raised");
1682     } catch (InvalidArgumentException e) {
1683       // Expected exception.
1684     }
1685   }
1686 
1687   @Test
listMigratingVmsTest2()1688   public void listMigratingVmsTest2() throws Exception {
1689     MigratingVm responsesElement = MigratingVm.newBuilder().build();
1690     ListMigratingVmsResponse expectedResponse =
1691         ListMigratingVmsResponse.newBuilder()
1692             .setNextPageToken("")
1693             .addAllMigratingVms(Arrays.asList(responsesElement))
1694             .build();
1695     mockVmMigration.addResponse(expectedResponse);
1696 
1697     String parent = "parent-995424086";
1698 
1699     ListMigratingVmsPagedResponse pagedListResponse = client.listMigratingVms(parent);
1700 
1701     List<MigratingVm> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1702 
1703     Assert.assertEquals(1, resources.size());
1704     Assert.assertEquals(expectedResponse.getMigratingVmsList().get(0), resources.get(0));
1705 
1706     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1707     Assert.assertEquals(1, actualRequests.size());
1708     ListMigratingVmsRequest actualRequest = ((ListMigratingVmsRequest) actualRequests.get(0));
1709 
1710     Assert.assertEquals(parent, actualRequest.getParent());
1711     Assert.assertTrue(
1712         channelProvider.isHeaderSent(
1713             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1714             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1715   }
1716 
1717   @Test
listMigratingVmsExceptionTest2()1718   public void listMigratingVmsExceptionTest2() throws Exception {
1719     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1720     mockVmMigration.addException(exception);
1721 
1722     try {
1723       String parent = "parent-995424086";
1724       client.listMigratingVms(parent);
1725       Assert.fail("No exception raised");
1726     } catch (InvalidArgumentException e) {
1727       // Expected exception.
1728     }
1729   }
1730 
1731   @Test
getMigratingVmTest()1732   public void getMigratingVmTest() throws Exception {
1733     MigratingVm expectedResponse =
1734         MigratingVm.newBuilder()
1735             .setName(
1736                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
1737                     .toString())
1738             .setSourceVmId("sourceVmId-1111384851")
1739             .setDisplayName("displayName1714148973")
1740             .setDescription("description-1724546052")
1741             .setPolicy(SchedulePolicy.newBuilder().build())
1742             .setCreateTime(Timestamp.newBuilder().build())
1743             .setUpdateTime(Timestamp.newBuilder().build())
1744             .setLastSync(ReplicationSync.newBuilder().build())
1745             .setStateTime(Timestamp.newBuilder().build())
1746             .setCurrentSyncInfo(ReplicationCycle.newBuilder().build())
1747             .setGroup(LocationName.of("[PROJECT]", "[LOCATION]").toString())
1748             .putAllLabels(new HashMap<String, String>())
1749             .addAllRecentCloneJobs(new ArrayList<CloneJob>())
1750             .setError(Status.newBuilder().build())
1751             .addAllRecentCutoverJobs(new ArrayList<CutoverJob>())
1752             .build();
1753     mockVmMigration.addResponse(expectedResponse);
1754 
1755     MigratingVmName name =
1756         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
1757 
1758     MigratingVm actualResponse = client.getMigratingVm(name);
1759     Assert.assertEquals(expectedResponse, actualResponse);
1760 
1761     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1762     Assert.assertEquals(1, actualRequests.size());
1763     GetMigratingVmRequest actualRequest = ((GetMigratingVmRequest) actualRequests.get(0));
1764 
1765     Assert.assertEquals(name.toString(), actualRequest.getName());
1766     Assert.assertTrue(
1767         channelProvider.isHeaderSent(
1768             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1769             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1770   }
1771 
1772   @Test
getMigratingVmExceptionTest()1773   public void getMigratingVmExceptionTest() throws Exception {
1774     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1775     mockVmMigration.addException(exception);
1776 
1777     try {
1778       MigratingVmName name =
1779           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
1780       client.getMigratingVm(name);
1781       Assert.fail("No exception raised");
1782     } catch (InvalidArgumentException e) {
1783       // Expected exception.
1784     }
1785   }
1786 
1787   @Test
getMigratingVmTest2()1788   public void getMigratingVmTest2() throws Exception {
1789     MigratingVm expectedResponse =
1790         MigratingVm.newBuilder()
1791             .setName(
1792                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
1793                     .toString())
1794             .setSourceVmId("sourceVmId-1111384851")
1795             .setDisplayName("displayName1714148973")
1796             .setDescription("description-1724546052")
1797             .setPolicy(SchedulePolicy.newBuilder().build())
1798             .setCreateTime(Timestamp.newBuilder().build())
1799             .setUpdateTime(Timestamp.newBuilder().build())
1800             .setLastSync(ReplicationSync.newBuilder().build())
1801             .setStateTime(Timestamp.newBuilder().build())
1802             .setCurrentSyncInfo(ReplicationCycle.newBuilder().build())
1803             .setGroup(LocationName.of("[PROJECT]", "[LOCATION]").toString())
1804             .putAllLabels(new HashMap<String, String>())
1805             .addAllRecentCloneJobs(new ArrayList<CloneJob>())
1806             .setError(Status.newBuilder().build())
1807             .addAllRecentCutoverJobs(new ArrayList<CutoverJob>())
1808             .build();
1809     mockVmMigration.addResponse(expectedResponse);
1810 
1811     String name = "name3373707";
1812 
1813     MigratingVm actualResponse = client.getMigratingVm(name);
1814     Assert.assertEquals(expectedResponse, actualResponse);
1815 
1816     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1817     Assert.assertEquals(1, actualRequests.size());
1818     GetMigratingVmRequest actualRequest = ((GetMigratingVmRequest) actualRequests.get(0));
1819 
1820     Assert.assertEquals(name, actualRequest.getName());
1821     Assert.assertTrue(
1822         channelProvider.isHeaderSent(
1823             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1824             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1825   }
1826 
1827   @Test
getMigratingVmExceptionTest2()1828   public void getMigratingVmExceptionTest2() throws Exception {
1829     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1830     mockVmMigration.addException(exception);
1831 
1832     try {
1833       String name = "name3373707";
1834       client.getMigratingVm(name);
1835       Assert.fail("No exception raised");
1836     } catch (InvalidArgumentException e) {
1837       // Expected exception.
1838     }
1839   }
1840 
1841   @Test
updateMigratingVmTest()1842   public void updateMigratingVmTest() throws Exception {
1843     MigratingVm expectedResponse =
1844         MigratingVm.newBuilder()
1845             .setName(
1846                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
1847                     .toString())
1848             .setSourceVmId("sourceVmId-1111384851")
1849             .setDisplayName("displayName1714148973")
1850             .setDescription("description-1724546052")
1851             .setPolicy(SchedulePolicy.newBuilder().build())
1852             .setCreateTime(Timestamp.newBuilder().build())
1853             .setUpdateTime(Timestamp.newBuilder().build())
1854             .setLastSync(ReplicationSync.newBuilder().build())
1855             .setStateTime(Timestamp.newBuilder().build())
1856             .setCurrentSyncInfo(ReplicationCycle.newBuilder().build())
1857             .setGroup(LocationName.of("[PROJECT]", "[LOCATION]").toString())
1858             .putAllLabels(new HashMap<String, String>())
1859             .addAllRecentCloneJobs(new ArrayList<CloneJob>())
1860             .setError(Status.newBuilder().build())
1861             .addAllRecentCutoverJobs(new ArrayList<CutoverJob>())
1862             .build();
1863     Operation resultOperation =
1864         Operation.newBuilder()
1865             .setName("updateMigratingVmTest")
1866             .setDone(true)
1867             .setResponse(Any.pack(expectedResponse))
1868             .build();
1869     mockVmMigration.addResponse(resultOperation);
1870 
1871     MigratingVm migratingVm = MigratingVm.newBuilder().build();
1872     FieldMask updateMask = FieldMask.newBuilder().build();
1873 
1874     MigratingVm actualResponse = client.updateMigratingVmAsync(migratingVm, updateMask).get();
1875     Assert.assertEquals(expectedResponse, actualResponse);
1876 
1877     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1878     Assert.assertEquals(1, actualRequests.size());
1879     UpdateMigratingVmRequest actualRequest = ((UpdateMigratingVmRequest) actualRequests.get(0));
1880 
1881     Assert.assertEquals(migratingVm, actualRequest.getMigratingVm());
1882     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1883     Assert.assertTrue(
1884         channelProvider.isHeaderSent(
1885             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1886             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1887   }
1888 
1889   @Test
updateMigratingVmExceptionTest()1890   public void updateMigratingVmExceptionTest() throws Exception {
1891     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1892     mockVmMigration.addException(exception);
1893 
1894     try {
1895       MigratingVm migratingVm = MigratingVm.newBuilder().build();
1896       FieldMask updateMask = FieldMask.newBuilder().build();
1897       client.updateMigratingVmAsync(migratingVm, updateMask).get();
1898       Assert.fail("No exception raised");
1899     } catch (ExecutionException e) {
1900       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1901       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1902       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1903     }
1904   }
1905 
1906   @Test
deleteMigratingVmTest()1907   public void deleteMigratingVmTest() throws Exception {
1908     Empty expectedResponse = Empty.newBuilder().build();
1909     Operation resultOperation =
1910         Operation.newBuilder()
1911             .setName("deleteMigratingVmTest")
1912             .setDone(true)
1913             .setResponse(Any.pack(expectedResponse))
1914             .build();
1915     mockVmMigration.addResponse(resultOperation);
1916 
1917     MigratingVmName name =
1918         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
1919 
1920     client.deleteMigratingVmAsync(name).get();
1921 
1922     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1923     Assert.assertEquals(1, actualRequests.size());
1924     DeleteMigratingVmRequest actualRequest = ((DeleteMigratingVmRequest) actualRequests.get(0));
1925 
1926     Assert.assertEquals(name.toString(), actualRequest.getName());
1927     Assert.assertTrue(
1928         channelProvider.isHeaderSent(
1929             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1930             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1931   }
1932 
1933   @Test
deleteMigratingVmExceptionTest()1934   public void deleteMigratingVmExceptionTest() throws Exception {
1935     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1936     mockVmMigration.addException(exception);
1937 
1938     try {
1939       MigratingVmName name =
1940           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
1941       client.deleteMigratingVmAsync(name).get();
1942       Assert.fail("No exception raised");
1943     } catch (ExecutionException e) {
1944       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1945       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1946       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1947     }
1948   }
1949 
1950   @Test
deleteMigratingVmTest2()1951   public void deleteMigratingVmTest2() throws Exception {
1952     Empty expectedResponse = Empty.newBuilder().build();
1953     Operation resultOperation =
1954         Operation.newBuilder()
1955             .setName("deleteMigratingVmTest")
1956             .setDone(true)
1957             .setResponse(Any.pack(expectedResponse))
1958             .build();
1959     mockVmMigration.addResponse(resultOperation);
1960 
1961     String name = "name3373707";
1962 
1963     client.deleteMigratingVmAsync(name).get();
1964 
1965     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
1966     Assert.assertEquals(1, actualRequests.size());
1967     DeleteMigratingVmRequest actualRequest = ((DeleteMigratingVmRequest) actualRequests.get(0));
1968 
1969     Assert.assertEquals(name, actualRequest.getName());
1970     Assert.assertTrue(
1971         channelProvider.isHeaderSent(
1972             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1973             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1974   }
1975 
1976   @Test
deleteMigratingVmExceptionTest2()1977   public void deleteMigratingVmExceptionTest2() throws Exception {
1978     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1979     mockVmMigration.addException(exception);
1980 
1981     try {
1982       String name = "name3373707";
1983       client.deleteMigratingVmAsync(name).get();
1984       Assert.fail("No exception raised");
1985     } catch (ExecutionException e) {
1986       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1987       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1988       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1989     }
1990   }
1991 
1992   @Test
startMigrationTest()1993   public void startMigrationTest() throws Exception {
1994     StartMigrationResponse expectedResponse = StartMigrationResponse.newBuilder().build();
1995     Operation resultOperation =
1996         Operation.newBuilder()
1997             .setName("startMigrationTest")
1998             .setDone(true)
1999             .setResponse(Any.pack(expectedResponse))
2000             .build();
2001     mockVmMigration.addResponse(resultOperation);
2002 
2003     MigratingVmName migratingVm =
2004         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2005 
2006     StartMigrationResponse actualResponse = client.startMigrationAsync(migratingVm).get();
2007     Assert.assertEquals(expectedResponse, actualResponse);
2008 
2009     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2010     Assert.assertEquals(1, actualRequests.size());
2011     StartMigrationRequest actualRequest = ((StartMigrationRequest) actualRequests.get(0));
2012 
2013     Assert.assertEquals(migratingVm.toString(), actualRequest.getMigratingVm());
2014     Assert.assertTrue(
2015         channelProvider.isHeaderSent(
2016             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2017             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2018   }
2019 
2020   @Test
startMigrationExceptionTest()2021   public void startMigrationExceptionTest() throws Exception {
2022     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2023     mockVmMigration.addException(exception);
2024 
2025     try {
2026       MigratingVmName migratingVm =
2027           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2028       client.startMigrationAsync(migratingVm).get();
2029       Assert.fail("No exception raised");
2030     } catch (ExecutionException e) {
2031       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2032       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2033       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2034     }
2035   }
2036 
2037   @Test
startMigrationTest2()2038   public void startMigrationTest2() throws Exception {
2039     StartMigrationResponse expectedResponse = StartMigrationResponse.newBuilder().build();
2040     Operation resultOperation =
2041         Operation.newBuilder()
2042             .setName("startMigrationTest")
2043             .setDone(true)
2044             .setResponse(Any.pack(expectedResponse))
2045             .build();
2046     mockVmMigration.addResponse(resultOperation);
2047 
2048     String migratingVm = "migratingVm1484256383";
2049 
2050     StartMigrationResponse actualResponse = client.startMigrationAsync(migratingVm).get();
2051     Assert.assertEquals(expectedResponse, actualResponse);
2052 
2053     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2054     Assert.assertEquals(1, actualRequests.size());
2055     StartMigrationRequest actualRequest = ((StartMigrationRequest) actualRequests.get(0));
2056 
2057     Assert.assertEquals(migratingVm, actualRequest.getMigratingVm());
2058     Assert.assertTrue(
2059         channelProvider.isHeaderSent(
2060             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2061             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2062   }
2063 
2064   @Test
startMigrationExceptionTest2()2065   public void startMigrationExceptionTest2() throws Exception {
2066     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2067     mockVmMigration.addException(exception);
2068 
2069     try {
2070       String migratingVm = "migratingVm1484256383";
2071       client.startMigrationAsync(migratingVm).get();
2072       Assert.fail("No exception raised");
2073     } catch (ExecutionException e) {
2074       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2075       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2076       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2077     }
2078   }
2079 
2080   @Test
resumeMigrationTest()2081   public void resumeMigrationTest() throws Exception {
2082     ResumeMigrationResponse expectedResponse = ResumeMigrationResponse.newBuilder().build();
2083     Operation resultOperation =
2084         Operation.newBuilder()
2085             .setName("resumeMigrationTest")
2086             .setDone(true)
2087             .setResponse(Any.pack(expectedResponse))
2088             .build();
2089     mockVmMigration.addResponse(resultOperation);
2090 
2091     ResumeMigrationRequest request =
2092         ResumeMigrationRequest.newBuilder()
2093             .setMigratingVm(
2094                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
2095                     .toString())
2096             .build();
2097 
2098     ResumeMigrationResponse actualResponse = client.resumeMigrationAsync(request).get();
2099     Assert.assertEquals(expectedResponse, actualResponse);
2100 
2101     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2102     Assert.assertEquals(1, actualRequests.size());
2103     ResumeMigrationRequest actualRequest = ((ResumeMigrationRequest) actualRequests.get(0));
2104 
2105     Assert.assertEquals(request.getMigratingVm(), actualRequest.getMigratingVm());
2106     Assert.assertTrue(
2107         channelProvider.isHeaderSent(
2108             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2109             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2110   }
2111 
2112   @Test
resumeMigrationExceptionTest()2113   public void resumeMigrationExceptionTest() throws Exception {
2114     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2115     mockVmMigration.addException(exception);
2116 
2117     try {
2118       ResumeMigrationRequest request =
2119           ResumeMigrationRequest.newBuilder()
2120               .setMigratingVm(
2121                   MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
2122                       .toString())
2123               .build();
2124       client.resumeMigrationAsync(request).get();
2125       Assert.fail("No exception raised");
2126     } catch (ExecutionException e) {
2127       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2128       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2129       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2130     }
2131   }
2132 
2133   @Test
pauseMigrationTest()2134   public void pauseMigrationTest() throws Exception {
2135     PauseMigrationResponse expectedResponse = PauseMigrationResponse.newBuilder().build();
2136     Operation resultOperation =
2137         Operation.newBuilder()
2138             .setName("pauseMigrationTest")
2139             .setDone(true)
2140             .setResponse(Any.pack(expectedResponse))
2141             .build();
2142     mockVmMigration.addResponse(resultOperation);
2143 
2144     PauseMigrationRequest request =
2145         PauseMigrationRequest.newBuilder()
2146             .setMigratingVm(
2147                 MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
2148                     .toString())
2149             .build();
2150 
2151     PauseMigrationResponse actualResponse = client.pauseMigrationAsync(request).get();
2152     Assert.assertEquals(expectedResponse, actualResponse);
2153 
2154     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2155     Assert.assertEquals(1, actualRequests.size());
2156     PauseMigrationRequest actualRequest = ((PauseMigrationRequest) actualRequests.get(0));
2157 
2158     Assert.assertEquals(request.getMigratingVm(), actualRequest.getMigratingVm());
2159     Assert.assertTrue(
2160         channelProvider.isHeaderSent(
2161             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2162             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2163   }
2164 
2165   @Test
pauseMigrationExceptionTest()2166   public void pauseMigrationExceptionTest() throws Exception {
2167     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2168     mockVmMigration.addException(exception);
2169 
2170     try {
2171       PauseMigrationRequest request =
2172           PauseMigrationRequest.newBuilder()
2173               .setMigratingVm(
2174                   MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]")
2175                       .toString())
2176               .build();
2177       client.pauseMigrationAsync(request).get();
2178       Assert.fail("No exception raised");
2179     } catch (ExecutionException e) {
2180       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2181       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2182       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2183     }
2184   }
2185 
2186   @Test
finalizeMigrationTest()2187   public void finalizeMigrationTest() throws Exception {
2188     FinalizeMigrationResponse expectedResponse = FinalizeMigrationResponse.newBuilder().build();
2189     Operation resultOperation =
2190         Operation.newBuilder()
2191             .setName("finalizeMigrationTest")
2192             .setDone(true)
2193             .setResponse(Any.pack(expectedResponse))
2194             .build();
2195     mockVmMigration.addResponse(resultOperation);
2196 
2197     MigratingVmName migratingVm =
2198         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2199 
2200     FinalizeMigrationResponse actualResponse = client.finalizeMigrationAsync(migratingVm).get();
2201     Assert.assertEquals(expectedResponse, actualResponse);
2202 
2203     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2204     Assert.assertEquals(1, actualRequests.size());
2205     FinalizeMigrationRequest actualRequest = ((FinalizeMigrationRequest) actualRequests.get(0));
2206 
2207     Assert.assertEquals(migratingVm.toString(), actualRequest.getMigratingVm());
2208     Assert.assertTrue(
2209         channelProvider.isHeaderSent(
2210             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2211             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2212   }
2213 
2214   @Test
finalizeMigrationExceptionTest()2215   public void finalizeMigrationExceptionTest() throws Exception {
2216     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2217     mockVmMigration.addException(exception);
2218 
2219     try {
2220       MigratingVmName migratingVm =
2221           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2222       client.finalizeMigrationAsync(migratingVm).get();
2223       Assert.fail("No exception raised");
2224     } catch (ExecutionException e) {
2225       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2226       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2227       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2228     }
2229   }
2230 
2231   @Test
finalizeMigrationTest2()2232   public void finalizeMigrationTest2() throws Exception {
2233     FinalizeMigrationResponse expectedResponse = FinalizeMigrationResponse.newBuilder().build();
2234     Operation resultOperation =
2235         Operation.newBuilder()
2236             .setName("finalizeMigrationTest")
2237             .setDone(true)
2238             .setResponse(Any.pack(expectedResponse))
2239             .build();
2240     mockVmMigration.addResponse(resultOperation);
2241 
2242     String migratingVm = "migratingVm1484256383";
2243 
2244     FinalizeMigrationResponse actualResponse = client.finalizeMigrationAsync(migratingVm).get();
2245     Assert.assertEquals(expectedResponse, actualResponse);
2246 
2247     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2248     Assert.assertEquals(1, actualRequests.size());
2249     FinalizeMigrationRequest actualRequest = ((FinalizeMigrationRequest) actualRequests.get(0));
2250 
2251     Assert.assertEquals(migratingVm, actualRequest.getMigratingVm());
2252     Assert.assertTrue(
2253         channelProvider.isHeaderSent(
2254             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2255             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2256   }
2257 
2258   @Test
finalizeMigrationExceptionTest2()2259   public void finalizeMigrationExceptionTest2() throws Exception {
2260     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2261     mockVmMigration.addException(exception);
2262 
2263     try {
2264       String migratingVm = "migratingVm1484256383";
2265       client.finalizeMigrationAsync(migratingVm).get();
2266       Assert.fail("No exception raised");
2267     } catch (ExecutionException e) {
2268       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2269       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2270       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2271     }
2272   }
2273 
2274   @Test
createCloneJobTest()2275   public void createCloneJobTest() throws Exception {
2276     CloneJob expectedResponse =
2277         CloneJob.newBuilder()
2278             .setCreateTime(Timestamp.newBuilder().build())
2279             .setEndTime(Timestamp.newBuilder().build())
2280             .setName(
2281                 CloneJobName.of(
2282                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]")
2283                     .toString())
2284             .setStateTime(Timestamp.newBuilder().build())
2285             .setError(Status.newBuilder().build())
2286             .addAllSteps(new ArrayList<CloneStep>())
2287             .build();
2288     Operation resultOperation =
2289         Operation.newBuilder()
2290             .setName("createCloneJobTest")
2291             .setDone(true)
2292             .setResponse(Any.pack(expectedResponse))
2293             .build();
2294     mockVmMigration.addResponse(resultOperation);
2295 
2296     MigratingVmName parent =
2297         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2298     CloneJob cloneJob = CloneJob.newBuilder().build();
2299     String cloneJobId = "cloneJobId2071309915";
2300 
2301     CloneJob actualResponse = client.createCloneJobAsync(parent, cloneJob, cloneJobId).get();
2302     Assert.assertEquals(expectedResponse, actualResponse);
2303 
2304     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2305     Assert.assertEquals(1, actualRequests.size());
2306     CreateCloneJobRequest actualRequest = ((CreateCloneJobRequest) actualRequests.get(0));
2307 
2308     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2309     Assert.assertEquals(cloneJob, actualRequest.getCloneJob());
2310     Assert.assertEquals(cloneJobId, actualRequest.getCloneJobId());
2311     Assert.assertTrue(
2312         channelProvider.isHeaderSent(
2313             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2314             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2315   }
2316 
2317   @Test
createCloneJobExceptionTest()2318   public void createCloneJobExceptionTest() throws Exception {
2319     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2320     mockVmMigration.addException(exception);
2321 
2322     try {
2323       MigratingVmName parent =
2324           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2325       CloneJob cloneJob = CloneJob.newBuilder().build();
2326       String cloneJobId = "cloneJobId2071309915";
2327       client.createCloneJobAsync(parent, cloneJob, cloneJobId).get();
2328       Assert.fail("No exception raised");
2329     } catch (ExecutionException e) {
2330       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2331       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2332       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2333     }
2334   }
2335 
2336   @Test
createCloneJobTest2()2337   public void createCloneJobTest2() throws Exception {
2338     CloneJob expectedResponse =
2339         CloneJob.newBuilder()
2340             .setCreateTime(Timestamp.newBuilder().build())
2341             .setEndTime(Timestamp.newBuilder().build())
2342             .setName(
2343                 CloneJobName.of(
2344                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]")
2345                     .toString())
2346             .setStateTime(Timestamp.newBuilder().build())
2347             .setError(Status.newBuilder().build())
2348             .addAllSteps(new ArrayList<CloneStep>())
2349             .build();
2350     Operation resultOperation =
2351         Operation.newBuilder()
2352             .setName("createCloneJobTest")
2353             .setDone(true)
2354             .setResponse(Any.pack(expectedResponse))
2355             .build();
2356     mockVmMigration.addResponse(resultOperation);
2357 
2358     String parent = "parent-995424086";
2359     CloneJob cloneJob = CloneJob.newBuilder().build();
2360     String cloneJobId = "cloneJobId2071309915";
2361 
2362     CloneJob actualResponse = client.createCloneJobAsync(parent, cloneJob, cloneJobId).get();
2363     Assert.assertEquals(expectedResponse, actualResponse);
2364 
2365     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2366     Assert.assertEquals(1, actualRequests.size());
2367     CreateCloneJobRequest actualRequest = ((CreateCloneJobRequest) actualRequests.get(0));
2368 
2369     Assert.assertEquals(parent, actualRequest.getParent());
2370     Assert.assertEquals(cloneJob, actualRequest.getCloneJob());
2371     Assert.assertEquals(cloneJobId, actualRequest.getCloneJobId());
2372     Assert.assertTrue(
2373         channelProvider.isHeaderSent(
2374             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2375             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2376   }
2377 
2378   @Test
createCloneJobExceptionTest2()2379   public void createCloneJobExceptionTest2() throws Exception {
2380     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2381     mockVmMigration.addException(exception);
2382 
2383     try {
2384       String parent = "parent-995424086";
2385       CloneJob cloneJob = CloneJob.newBuilder().build();
2386       String cloneJobId = "cloneJobId2071309915";
2387       client.createCloneJobAsync(parent, cloneJob, cloneJobId).get();
2388       Assert.fail("No exception raised");
2389     } catch (ExecutionException e) {
2390       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2391       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2392       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2393     }
2394   }
2395 
2396   @Test
cancelCloneJobTest()2397   public void cancelCloneJobTest() throws Exception {
2398     CancelCloneJobResponse expectedResponse = CancelCloneJobResponse.newBuilder().build();
2399     Operation resultOperation =
2400         Operation.newBuilder()
2401             .setName("cancelCloneJobTest")
2402             .setDone(true)
2403             .setResponse(Any.pack(expectedResponse))
2404             .build();
2405     mockVmMigration.addResponse(resultOperation);
2406 
2407     CloneJobName name =
2408         CloneJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]");
2409 
2410     CancelCloneJobResponse actualResponse = client.cancelCloneJobAsync(name).get();
2411     Assert.assertEquals(expectedResponse, actualResponse);
2412 
2413     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2414     Assert.assertEquals(1, actualRequests.size());
2415     CancelCloneJobRequest actualRequest = ((CancelCloneJobRequest) actualRequests.get(0));
2416 
2417     Assert.assertEquals(name.toString(), actualRequest.getName());
2418     Assert.assertTrue(
2419         channelProvider.isHeaderSent(
2420             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2421             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2422   }
2423 
2424   @Test
cancelCloneJobExceptionTest()2425   public void cancelCloneJobExceptionTest() throws Exception {
2426     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2427     mockVmMigration.addException(exception);
2428 
2429     try {
2430       CloneJobName name =
2431           CloneJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]");
2432       client.cancelCloneJobAsync(name).get();
2433       Assert.fail("No exception raised");
2434     } catch (ExecutionException e) {
2435       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2436       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2437       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2438     }
2439   }
2440 
2441   @Test
cancelCloneJobTest2()2442   public void cancelCloneJobTest2() throws Exception {
2443     CancelCloneJobResponse expectedResponse = CancelCloneJobResponse.newBuilder().build();
2444     Operation resultOperation =
2445         Operation.newBuilder()
2446             .setName("cancelCloneJobTest")
2447             .setDone(true)
2448             .setResponse(Any.pack(expectedResponse))
2449             .build();
2450     mockVmMigration.addResponse(resultOperation);
2451 
2452     String name = "name3373707";
2453 
2454     CancelCloneJobResponse actualResponse = client.cancelCloneJobAsync(name).get();
2455     Assert.assertEquals(expectedResponse, actualResponse);
2456 
2457     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2458     Assert.assertEquals(1, actualRequests.size());
2459     CancelCloneJobRequest actualRequest = ((CancelCloneJobRequest) actualRequests.get(0));
2460 
2461     Assert.assertEquals(name, actualRequest.getName());
2462     Assert.assertTrue(
2463         channelProvider.isHeaderSent(
2464             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2465             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2466   }
2467 
2468   @Test
cancelCloneJobExceptionTest2()2469   public void cancelCloneJobExceptionTest2() throws Exception {
2470     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2471     mockVmMigration.addException(exception);
2472 
2473     try {
2474       String name = "name3373707";
2475       client.cancelCloneJobAsync(name).get();
2476       Assert.fail("No exception raised");
2477     } catch (ExecutionException e) {
2478       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2479       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2480       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2481     }
2482   }
2483 
2484   @Test
listCloneJobsTest()2485   public void listCloneJobsTest() throws Exception {
2486     CloneJob responsesElement = CloneJob.newBuilder().build();
2487     ListCloneJobsResponse expectedResponse =
2488         ListCloneJobsResponse.newBuilder()
2489             .setNextPageToken("")
2490             .addAllCloneJobs(Arrays.asList(responsesElement))
2491             .build();
2492     mockVmMigration.addResponse(expectedResponse);
2493 
2494     MigratingVmName parent =
2495         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2496 
2497     ListCloneJobsPagedResponse pagedListResponse = client.listCloneJobs(parent);
2498 
2499     List<CloneJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2500 
2501     Assert.assertEquals(1, resources.size());
2502     Assert.assertEquals(expectedResponse.getCloneJobsList().get(0), resources.get(0));
2503 
2504     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2505     Assert.assertEquals(1, actualRequests.size());
2506     ListCloneJobsRequest actualRequest = ((ListCloneJobsRequest) actualRequests.get(0));
2507 
2508     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2509     Assert.assertTrue(
2510         channelProvider.isHeaderSent(
2511             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2512             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2513   }
2514 
2515   @Test
listCloneJobsExceptionTest()2516   public void listCloneJobsExceptionTest() throws Exception {
2517     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2518     mockVmMigration.addException(exception);
2519 
2520     try {
2521       MigratingVmName parent =
2522           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2523       client.listCloneJobs(parent);
2524       Assert.fail("No exception raised");
2525     } catch (InvalidArgumentException e) {
2526       // Expected exception.
2527     }
2528   }
2529 
2530   @Test
listCloneJobsTest2()2531   public void listCloneJobsTest2() throws Exception {
2532     CloneJob responsesElement = CloneJob.newBuilder().build();
2533     ListCloneJobsResponse expectedResponse =
2534         ListCloneJobsResponse.newBuilder()
2535             .setNextPageToken("")
2536             .addAllCloneJobs(Arrays.asList(responsesElement))
2537             .build();
2538     mockVmMigration.addResponse(expectedResponse);
2539 
2540     String parent = "parent-995424086";
2541 
2542     ListCloneJobsPagedResponse pagedListResponse = client.listCloneJobs(parent);
2543 
2544     List<CloneJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2545 
2546     Assert.assertEquals(1, resources.size());
2547     Assert.assertEquals(expectedResponse.getCloneJobsList().get(0), resources.get(0));
2548 
2549     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2550     Assert.assertEquals(1, actualRequests.size());
2551     ListCloneJobsRequest actualRequest = ((ListCloneJobsRequest) actualRequests.get(0));
2552 
2553     Assert.assertEquals(parent, actualRequest.getParent());
2554     Assert.assertTrue(
2555         channelProvider.isHeaderSent(
2556             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2557             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2558   }
2559 
2560   @Test
listCloneJobsExceptionTest2()2561   public void listCloneJobsExceptionTest2() throws Exception {
2562     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2563     mockVmMigration.addException(exception);
2564 
2565     try {
2566       String parent = "parent-995424086";
2567       client.listCloneJobs(parent);
2568       Assert.fail("No exception raised");
2569     } catch (InvalidArgumentException e) {
2570       // Expected exception.
2571     }
2572   }
2573 
2574   @Test
getCloneJobTest()2575   public void getCloneJobTest() throws Exception {
2576     CloneJob expectedResponse =
2577         CloneJob.newBuilder()
2578             .setCreateTime(Timestamp.newBuilder().build())
2579             .setEndTime(Timestamp.newBuilder().build())
2580             .setName(
2581                 CloneJobName.of(
2582                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]")
2583                     .toString())
2584             .setStateTime(Timestamp.newBuilder().build())
2585             .setError(Status.newBuilder().build())
2586             .addAllSteps(new ArrayList<CloneStep>())
2587             .build();
2588     mockVmMigration.addResponse(expectedResponse);
2589 
2590     CloneJobName name =
2591         CloneJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]");
2592 
2593     CloneJob actualResponse = client.getCloneJob(name);
2594     Assert.assertEquals(expectedResponse, actualResponse);
2595 
2596     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2597     Assert.assertEquals(1, actualRequests.size());
2598     GetCloneJobRequest actualRequest = ((GetCloneJobRequest) actualRequests.get(0));
2599 
2600     Assert.assertEquals(name.toString(), actualRequest.getName());
2601     Assert.assertTrue(
2602         channelProvider.isHeaderSent(
2603             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2604             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2605   }
2606 
2607   @Test
getCloneJobExceptionTest()2608   public void getCloneJobExceptionTest() throws Exception {
2609     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2610     mockVmMigration.addException(exception);
2611 
2612     try {
2613       CloneJobName name =
2614           CloneJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]");
2615       client.getCloneJob(name);
2616       Assert.fail("No exception raised");
2617     } catch (InvalidArgumentException e) {
2618       // Expected exception.
2619     }
2620   }
2621 
2622   @Test
getCloneJobTest2()2623   public void getCloneJobTest2() throws Exception {
2624     CloneJob expectedResponse =
2625         CloneJob.newBuilder()
2626             .setCreateTime(Timestamp.newBuilder().build())
2627             .setEndTime(Timestamp.newBuilder().build())
2628             .setName(
2629                 CloneJobName.of(
2630                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CLONE_JOB]")
2631                     .toString())
2632             .setStateTime(Timestamp.newBuilder().build())
2633             .setError(Status.newBuilder().build())
2634             .addAllSteps(new ArrayList<CloneStep>())
2635             .build();
2636     mockVmMigration.addResponse(expectedResponse);
2637 
2638     String name = "name3373707";
2639 
2640     CloneJob actualResponse = client.getCloneJob(name);
2641     Assert.assertEquals(expectedResponse, actualResponse);
2642 
2643     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2644     Assert.assertEquals(1, actualRequests.size());
2645     GetCloneJobRequest actualRequest = ((GetCloneJobRequest) actualRequests.get(0));
2646 
2647     Assert.assertEquals(name, actualRequest.getName());
2648     Assert.assertTrue(
2649         channelProvider.isHeaderSent(
2650             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2651             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2652   }
2653 
2654   @Test
getCloneJobExceptionTest2()2655   public void getCloneJobExceptionTest2() throws Exception {
2656     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2657     mockVmMigration.addException(exception);
2658 
2659     try {
2660       String name = "name3373707";
2661       client.getCloneJob(name);
2662       Assert.fail("No exception raised");
2663     } catch (InvalidArgumentException e) {
2664       // Expected exception.
2665     }
2666   }
2667 
2668   @Test
createCutoverJobTest()2669   public void createCutoverJobTest() throws Exception {
2670     CutoverJob expectedResponse =
2671         CutoverJob.newBuilder()
2672             .setCreateTime(Timestamp.newBuilder().build())
2673             .setEndTime(Timestamp.newBuilder().build())
2674             .setName(
2675                 CutoverJobName.of(
2676                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]")
2677                     .toString())
2678             .setStateTime(Timestamp.newBuilder().build())
2679             .setProgressPercent(-2137894861)
2680             .setError(Status.newBuilder().build())
2681             .setStateMessage("stateMessage1128185398")
2682             .addAllSteps(new ArrayList<CutoverStep>())
2683             .build();
2684     Operation resultOperation =
2685         Operation.newBuilder()
2686             .setName("createCutoverJobTest")
2687             .setDone(true)
2688             .setResponse(Any.pack(expectedResponse))
2689             .build();
2690     mockVmMigration.addResponse(resultOperation);
2691 
2692     MigratingVmName parent =
2693         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2694     CutoverJob cutoverJob = CutoverJob.newBuilder().build();
2695     String cutoverJobId = "cutoverJobId-2003089086";
2696 
2697     CutoverJob actualResponse =
2698         client.createCutoverJobAsync(parent, cutoverJob, cutoverJobId).get();
2699     Assert.assertEquals(expectedResponse, actualResponse);
2700 
2701     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2702     Assert.assertEquals(1, actualRequests.size());
2703     CreateCutoverJobRequest actualRequest = ((CreateCutoverJobRequest) actualRequests.get(0));
2704 
2705     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2706     Assert.assertEquals(cutoverJob, actualRequest.getCutoverJob());
2707     Assert.assertEquals(cutoverJobId, actualRequest.getCutoverJobId());
2708     Assert.assertTrue(
2709         channelProvider.isHeaderSent(
2710             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2711             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2712   }
2713 
2714   @Test
createCutoverJobExceptionTest()2715   public void createCutoverJobExceptionTest() throws Exception {
2716     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2717     mockVmMigration.addException(exception);
2718 
2719     try {
2720       MigratingVmName parent =
2721           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2722       CutoverJob cutoverJob = CutoverJob.newBuilder().build();
2723       String cutoverJobId = "cutoverJobId-2003089086";
2724       client.createCutoverJobAsync(parent, cutoverJob, cutoverJobId).get();
2725       Assert.fail("No exception raised");
2726     } catch (ExecutionException e) {
2727       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2728       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2729       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2730     }
2731   }
2732 
2733   @Test
createCutoverJobTest2()2734   public void createCutoverJobTest2() throws Exception {
2735     CutoverJob expectedResponse =
2736         CutoverJob.newBuilder()
2737             .setCreateTime(Timestamp.newBuilder().build())
2738             .setEndTime(Timestamp.newBuilder().build())
2739             .setName(
2740                 CutoverJobName.of(
2741                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]")
2742                     .toString())
2743             .setStateTime(Timestamp.newBuilder().build())
2744             .setProgressPercent(-2137894861)
2745             .setError(Status.newBuilder().build())
2746             .setStateMessage("stateMessage1128185398")
2747             .addAllSteps(new ArrayList<CutoverStep>())
2748             .build();
2749     Operation resultOperation =
2750         Operation.newBuilder()
2751             .setName("createCutoverJobTest")
2752             .setDone(true)
2753             .setResponse(Any.pack(expectedResponse))
2754             .build();
2755     mockVmMigration.addResponse(resultOperation);
2756 
2757     String parent = "parent-995424086";
2758     CutoverJob cutoverJob = CutoverJob.newBuilder().build();
2759     String cutoverJobId = "cutoverJobId-2003089086";
2760 
2761     CutoverJob actualResponse =
2762         client.createCutoverJobAsync(parent, cutoverJob, cutoverJobId).get();
2763     Assert.assertEquals(expectedResponse, actualResponse);
2764 
2765     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2766     Assert.assertEquals(1, actualRequests.size());
2767     CreateCutoverJobRequest actualRequest = ((CreateCutoverJobRequest) actualRequests.get(0));
2768 
2769     Assert.assertEquals(parent, actualRequest.getParent());
2770     Assert.assertEquals(cutoverJob, actualRequest.getCutoverJob());
2771     Assert.assertEquals(cutoverJobId, actualRequest.getCutoverJobId());
2772     Assert.assertTrue(
2773         channelProvider.isHeaderSent(
2774             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2775             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2776   }
2777 
2778   @Test
createCutoverJobExceptionTest2()2779   public void createCutoverJobExceptionTest2() throws Exception {
2780     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2781     mockVmMigration.addException(exception);
2782 
2783     try {
2784       String parent = "parent-995424086";
2785       CutoverJob cutoverJob = CutoverJob.newBuilder().build();
2786       String cutoverJobId = "cutoverJobId-2003089086";
2787       client.createCutoverJobAsync(parent, cutoverJob, cutoverJobId).get();
2788       Assert.fail("No exception raised");
2789     } catch (ExecutionException e) {
2790       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2791       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2792       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2793     }
2794   }
2795 
2796   @Test
cancelCutoverJobTest()2797   public void cancelCutoverJobTest() throws Exception {
2798     CancelCutoverJobResponse expectedResponse = CancelCutoverJobResponse.newBuilder().build();
2799     Operation resultOperation =
2800         Operation.newBuilder()
2801             .setName("cancelCutoverJobTest")
2802             .setDone(true)
2803             .setResponse(Any.pack(expectedResponse))
2804             .build();
2805     mockVmMigration.addResponse(resultOperation);
2806 
2807     CutoverJobName name =
2808         CutoverJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]");
2809 
2810     CancelCutoverJobResponse actualResponse = client.cancelCutoverJobAsync(name).get();
2811     Assert.assertEquals(expectedResponse, actualResponse);
2812 
2813     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2814     Assert.assertEquals(1, actualRequests.size());
2815     CancelCutoverJobRequest actualRequest = ((CancelCutoverJobRequest) actualRequests.get(0));
2816 
2817     Assert.assertEquals(name.toString(), actualRequest.getName());
2818     Assert.assertTrue(
2819         channelProvider.isHeaderSent(
2820             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2821             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2822   }
2823 
2824   @Test
cancelCutoverJobExceptionTest()2825   public void cancelCutoverJobExceptionTest() throws Exception {
2826     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2827     mockVmMigration.addException(exception);
2828 
2829     try {
2830       CutoverJobName name =
2831           CutoverJobName.of(
2832               "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]");
2833       client.cancelCutoverJobAsync(name).get();
2834       Assert.fail("No exception raised");
2835     } catch (ExecutionException e) {
2836       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2837       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2838       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2839     }
2840   }
2841 
2842   @Test
cancelCutoverJobTest2()2843   public void cancelCutoverJobTest2() throws Exception {
2844     CancelCutoverJobResponse expectedResponse = CancelCutoverJobResponse.newBuilder().build();
2845     Operation resultOperation =
2846         Operation.newBuilder()
2847             .setName("cancelCutoverJobTest")
2848             .setDone(true)
2849             .setResponse(Any.pack(expectedResponse))
2850             .build();
2851     mockVmMigration.addResponse(resultOperation);
2852 
2853     String name = "name3373707";
2854 
2855     CancelCutoverJobResponse actualResponse = client.cancelCutoverJobAsync(name).get();
2856     Assert.assertEquals(expectedResponse, actualResponse);
2857 
2858     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2859     Assert.assertEquals(1, actualRequests.size());
2860     CancelCutoverJobRequest actualRequest = ((CancelCutoverJobRequest) actualRequests.get(0));
2861 
2862     Assert.assertEquals(name, actualRequest.getName());
2863     Assert.assertTrue(
2864         channelProvider.isHeaderSent(
2865             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2866             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2867   }
2868 
2869   @Test
cancelCutoverJobExceptionTest2()2870   public void cancelCutoverJobExceptionTest2() throws Exception {
2871     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2872     mockVmMigration.addException(exception);
2873 
2874     try {
2875       String name = "name3373707";
2876       client.cancelCutoverJobAsync(name).get();
2877       Assert.fail("No exception raised");
2878     } catch (ExecutionException e) {
2879       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2880       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2881       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2882     }
2883   }
2884 
2885   @Test
listCutoverJobsTest()2886   public void listCutoverJobsTest() throws Exception {
2887     CutoverJob responsesElement = CutoverJob.newBuilder().build();
2888     ListCutoverJobsResponse expectedResponse =
2889         ListCutoverJobsResponse.newBuilder()
2890             .setNextPageToken("")
2891             .addAllCutoverJobs(Arrays.asList(responsesElement))
2892             .build();
2893     mockVmMigration.addResponse(expectedResponse);
2894 
2895     MigratingVmName parent =
2896         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2897 
2898     ListCutoverJobsPagedResponse pagedListResponse = client.listCutoverJobs(parent);
2899 
2900     List<CutoverJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2901 
2902     Assert.assertEquals(1, resources.size());
2903     Assert.assertEquals(expectedResponse.getCutoverJobsList().get(0), resources.get(0));
2904 
2905     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2906     Assert.assertEquals(1, actualRequests.size());
2907     ListCutoverJobsRequest actualRequest = ((ListCutoverJobsRequest) actualRequests.get(0));
2908 
2909     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2910     Assert.assertTrue(
2911         channelProvider.isHeaderSent(
2912             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2913             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2914   }
2915 
2916   @Test
listCutoverJobsExceptionTest()2917   public void listCutoverJobsExceptionTest() throws Exception {
2918     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2919     mockVmMigration.addException(exception);
2920 
2921     try {
2922       MigratingVmName parent =
2923           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
2924       client.listCutoverJobs(parent);
2925       Assert.fail("No exception raised");
2926     } catch (InvalidArgumentException e) {
2927       // Expected exception.
2928     }
2929   }
2930 
2931   @Test
listCutoverJobsTest2()2932   public void listCutoverJobsTest2() throws Exception {
2933     CutoverJob responsesElement = CutoverJob.newBuilder().build();
2934     ListCutoverJobsResponse expectedResponse =
2935         ListCutoverJobsResponse.newBuilder()
2936             .setNextPageToken("")
2937             .addAllCutoverJobs(Arrays.asList(responsesElement))
2938             .build();
2939     mockVmMigration.addResponse(expectedResponse);
2940 
2941     String parent = "parent-995424086";
2942 
2943     ListCutoverJobsPagedResponse pagedListResponse = client.listCutoverJobs(parent);
2944 
2945     List<CutoverJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2946 
2947     Assert.assertEquals(1, resources.size());
2948     Assert.assertEquals(expectedResponse.getCutoverJobsList().get(0), resources.get(0));
2949 
2950     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
2951     Assert.assertEquals(1, actualRequests.size());
2952     ListCutoverJobsRequest actualRequest = ((ListCutoverJobsRequest) actualRequests.get(0));
2953 
2954     Assert.assertEquals(parent, actualRequest.getParent());
2955     Assert.assertTrue(
2956         channelProvider.isHeaderSent(
2957             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2958             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2959   }
2960 
2961   @Test
listCutoverJobsExceptionTest2()2962   public void listCutoverJobsExceptionTest2() throws Exception {
2963     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2964     mockVmMigration.addException(exception);
2965 
2966     try {
2967       String parent = "parent-995424086";
2968       client.listCutoverJobs(parent);
2969       Assert.fail("No exception raised");
2970     } catch (InvalidArgumentException e) {
2971       // Expected exception.
2972     }
2973   }
2974 
2975   @Test
getCutoverJobTest()2976   public void getCutoverJobTest() throws Exception {
2977     CutoverJob expectedResponse =
2978         CutoverJob.newBuilder()
2979             .setCreateTime(Timestamp.newBuilder().build())
2980             .setEndTime(Timestamp.newBuilder().build())
2981             .setName(
2982                 CutoverJobName.of(
2983                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]")
2984                     .toString())
2985             .setStateTime(Timestamp.newBuilder().build())
2986             .setProgressPercent(-2137894861)
2987             .setError(Status.newBuilder().build())
2988             .setStateMessage("stateMessage1128185398")
2989             .addAllSteps(new ArrayList<CutoverStep>())
2990             .build();
2991     mockVmMigration.addResponse(expectedResponse);
2992 
2993     CutoverJobName name =
2994         CutoverJobName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]");
2995 
2996     CutoverJob actualResponse = client.getCutoverJob(name);
2997     Assert.assertEquals(expectedResponse, actualResponse);
2998 
2999     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3000     Assert.assertEquals(1, actualRequests.size());
3001     GetCutoverJobRequest actualRequest = ((GetCutoverJobRequest) actualRequests.get(0));
3002 
3003     Assert.assertEquals(name.toString(), actualRequest.getName());
3004     Assert.assertTrue(
3005         channelProvider.isHeaderSent(
3006             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3007             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3008   }
3009 
3010   @Test
getCutoverJobExceptionTest()3011   public void getCutoverJobExceptionTest() throws Exception {
3012     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3013     mockVmMigration.addException(exception);
3014 
3015     try {
3016       CutoverJobName name =
3017           CutoverJobName.of(
3018               "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]");
3019       client.getCutoverJob(name);
3020       Assert.fail("No exception raised");
3021     } catch (InvalidArgumentException e) {
3022       // Expected exception.
3023     }
3024   }
3025 
3026   @Test
getCutoverJobTest2()3027   public void getCutoverJobTest2() throws Exception {
3028     CutoverJob expectedResponse =
3029         CutoverJob.newBuilder()
3030             .setCreateTime(Timestamp.newBuilder().build())
3031             .setEndTime(Timestamp.newBuilder().build())
3032             .setName(
3033                 CutoverJobName.of(
3034                         "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[CUTOVER_JOB]")
3035                     .toString())
3036             .setStateTime(Timestamp.newBuilder().build())
3037             .setProgressPercent(-2137894861)
3038             .setError(Status.newBuilder().build())
3039             .setStateMessage("stateMessage1128185398")
3040             .addAllSteps(new ArrayList<CutoverStep>())
3041             .build();
3042     mockVmMigration.addResponse(expectedResponse);
3043 
3044     String name = "name3373707";
3045 
3046     CutoverJob actualResponse = client.getCutoverJob(name);
3047     Assert.assertEquals(expectedResponse, actualResponse);
3048 
3049     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3050     Assert.assertEquals(1, actualRequests.size());
3051     GetCutoverJobRequest actualRequest = ((GetCutoverJobRequest) actualRequests.get(0));
3052 
3053     Assert.assertEquals(name, actualRequest.getName());
3054     Assert.assertTrue(
3055         channelProvider.isHeaderSent(
3056             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3057             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3058   }
3059 
3060   @Test
getCutoverJobExceptionTest2()3061   public void getCutoverJobExceptionTest2() throws Exception {
3062     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3063     mockVmMigration.addException(exception);
3064 
3065     try {
3066       String name = "name3373707";
3067       client.getCutoverJob(name);
3068       Assert.fail("No exception raised");
3069     } catch (InvalidArgumentException e) {
3070       // Expected exception.
3071     }
3072   }
3073 
3074   @Test
listGroupsTest()3075   public void listGroupsTest() throws Exception {
3076     Group responsesElement = Group.newBuilder().build();
3077     ListGroupsResponse expectedResponse =
3078         ListGroupsResponse.newBuilder()
3079             .setNextPageToken("")
3080             .addAllGroups(Arrays.asList(responsesElement))
3081             .build();
3082     mockVmMigration.addResponse(expectedResponse);
3083 
3084     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3085 
3086     ListGroupsPagedResponse pagedListResponse = client.listGroups(parent);
3087 
3088     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3089 
3090     Assert.assertEquals(1, resources.size());
3091     Assert.assertEquals(expectedResponse.getGroupsList().get(0), resources.get(0));
3092 
3093     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3094     Assert.assertEquals(1, actualRequests.size());
3095     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
3096 
3097     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3098     Assert.assertTrue(
3099         channelProvider.isHeaderSent(
3100             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3101             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3102   }
3103 
3104   @Test
listGroupsExceptionTest()3105   public void listGroupsExceptionTest() throws Exception {
3106     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3107     mockVmMigration.addException(exception);
3108 
3109     try {
3110       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3111       client.listGroups(parent);
3112       Assert.fail("No exception raised");
3113     } catch (InvalidArgumentException e) {
3114       // Expected exception.
3115     }
3116   }
3117 
3118   @Test
listGroupsTest2()3119   public void listGroupsTest2() throws Exception {
3120     Group responsesElement = Group.newBuilder().build();
3121     ListGroupsResponse expectedResponse =
3122         ListGroupsResponse.newBuilder()
3123             .setNextPageToken("")
3124             .addAllGroups(Arrays.asList(responsesElement))
3125             .build();
3126     mockVmMigration.addResponse(expectedResponse);
3127 
3128     String parent = "parent-995424086";
3129 
3130     ListGroupsPagedResponse pagedListResponse = client.listGroups(parent);
3131 
3132     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3133 
3134     Assert.assertEquals(1, resources.size());
3135     Assert.assertEquals(expectedResponse.getGroupsList().get(0), resources.get(0));
3136 
3137     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3138     Assert.assertEquals(1, actualRequests.size());
3139     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
3140 
3141     Assert.assertEquals(parent, actualRequest.getParent());
3142     Assert.assertTrue(
3143         channelProvider.isHeaderSent(
3144             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3145             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3146   }
3147 
3148   @Test
listGroupsExceptionTest2()3149   public void listGroupsExceptionTest2() throws Exception {
3150     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3151     mockVmMigration.addException(exception);
3152 
3153     try {
3154       String parent = "parent-995424086";
3155       client.listGroups(parent);
3156       Assert.fail("No exception raised");
3157     } catch (InvalidArgumentException e) {
3158       // Expected exception.
3159     }
3160   }
3161 
3162   @Test
getGroupTest()3163   public void getGroupTest() throws Exception {
3164     Group expectedResponse =
3165         Group.newBuilder()
3166             .setName(GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]").toString())
3167             .setCreateTime(Timestamp.newBuilder().build())
3168             .setUpdateTime(Timestamp.newBuilder().build())
3169             .setDescription("description-1724546052")
3170             .setDisplayName("displayName1714148973")
3171             .build();
3172     mockVmMigration.addResponse(expectedResponse);
3173 
3174     GroupName name = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3175 
3176     Group actualResponse = client.getGroup(name);
3177     Assert.assertEquals(expectedResponse, actualResponse);
3178 
3179     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3180     Assert.assertEquals(1, actualRequests.size());
3181     GetGroupRequest actualRequest = ((GetGroupRequest) actualRequests.get(0));
3182 
3183     Assert.assertEquals(name.toString(), actualRequest.getName());
3184     Assert.assertTrue(
3185         channelProvider.isHeaderSent(
3186             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3187             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3188   }
3189 
3190   @Test
getGroupExceptionTest()3191   public void getGroupExceptionTest() throws Exception {
3192     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3193     mockVmMigration.addException(exception);
3194 
3195     try {
3196       GroupName name = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3197       client.getGroup(name);
3198       Assert.fail("No exception raised");
3199     } catch (InvalidArgumentException e) {
3200       // Expected exception.
3201     }
3202   }
3203 
3204   @Test
getGroupTest2()3205   public void getGroupTest2() throws Exception {
3206     Group expectedResponse =
3207         Group.newBuilder()
3208             .setName(GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]").toString())
3209             .setCreateTime(Timestamp.newBuilder().build())
3210             .setUpdateTime(Timestamp.newBuilder().build())
3211             .setDescription("description-1724546052")
3212             .setDisplayName("displayName1714148973")
3213             .build();
3214     mockVmMigration.addResponse(expectedResponse);
3215 
3216     String name = "name3373707";
3217 
3218     Group actualResponse = client.getGroup(name);
3219     Assert.assertEquals(expectedResponse, actualResponse);
3220 
3221     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3222     Assert.assertEquals(1, actualRequests.size());
3223     GetGroupRequest actualRequest = ((GetGroupRequest) actualRequests.get(0));
3224 
3225     Assert.assertEquals(name, actualRequest.getName());
3226     Assert.assertTrue(
3227         channelProvider.isHeaderSent(
3228             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3229             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3230   }
3231 
3232   @Test
getGroupExceptionTest2()3233   public void getGroupExceptionTest2() throws Exception {
3234     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3235     mockVmMigration.addException(exception);
3236 
3237     try {
3238       String name = "name3373707";
3239       client.getGroup(name);
3240       Assert.fail("No exception raised");
3241     } catch (InvalidArgumentException e) {
3242       // Expected exception.
3243     }
3244   }
3245 
3246   @Test
createGroupTest()3247   public void createGroupTest() throws Exception {
3248     Group expectedResponse =
3249         Group.newBuilder()
3250             .setName(GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]").toString())
3251             .setCreateTime(Timestamp.newBuilder().build())
3252             .setUpdateTime(Timestamp.newBuilder().build())
3253             .setDescription("description-1724546052")
3254             .setDisplayName("displayName1714148973")
3255             .build();
3256     Operation resultOperation =
3257         Operation.newBuilder()
3258             .setName("createGroupTest")
3259             .setDone(true)
3260             .setResponse(Any.pack(expectedResponse))
3261             .build();
3262     mockVmMigration.addResponse(resultOperation);
3263 
3264     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3265     Group group = Group.newBuilder().build();
3266     String groupId = "groupId293428218";
3267 
3268     Group actualResponse = client.createGroupAsync(parent, group, groupId).get();
3269     Assert.assertEquals(expectedResponse, actualResponse);
3270 
3271     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3272     Assert.assertEquals(1, actualRequests.size());
3273     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
3274 
3275     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3276     Assert.assertEquals(group, actualRequest.getGroup());
3277     Assert.assertEquals(groupId, actualRequest.getGroupId());
3278     Assert.assertTrue(
3279         channelProvider.isHeaderSent(
3280             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3281             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3282   }
3283 
3284   @Test
createGroupExceptionTest()3285   public void createGroupExceptionTest() throws Exception {
3286     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3287     mockVmMigration.addException(exception);
3288 
3289     try {
3290       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3291       Group group = Group.newBuilder().build();
3292       String groupId = "groupId293428218";
3293       client.createGroupAsync(parent, group, groupId).get();
3294       Assert.fail("No exception raised");
3295     } catch (ExecutionException e) {
3296       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3297       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3298       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3299     }
3300   }
3301 
3302   @Test
createGroupTest2()3303   public void createGroupTest2() throws Exception {
3304     Group expectedResponse =
3305         Group.newBuilder()
3306             .setName(GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]").toString())
3307             .setCreateTime(Timestamp.newBuilder().build())
3308             .setUpdateTime(Timestamp.newBuilder().build())
3309             .setDescription("description-1724546052")
3310             .setDisplayName("displayName1714148973")
3311             .build();
3312     Operation resultOperation =
3313         Operation.newBuilder()
3314             .setName("createGroupTest")
3315             .setDone(true)
3316             .setResponse(Any.pack(expectedResponse))
3317             .build();
3318     mockVmMigration.addResponse(resultOperation);
3319 
3320     String parent = "parent-995424086";
3321     Group group = Group.newBuilder().build();
3322     String groupId = "groupId293428218";
3323 
3324     Group actualResponse = client.createGroupAsync(parent, group, groupId).get();
3325     Assert.assertEquals(expectedResponse, actualResponse);
3326 
3327     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3328     Assert.assertEquals(1, actualRequests.size());
3329     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
3330 
3331     Assert.assertEquals(parent, actualRequest.getParent());
3332     Assert.assertEquals(group, actualRequest.getGroup());
3333     Assert.assertEquals(groupId, actualRequest.getGroupId());
3334     Assert.assertTrue(
3335         channelProvider.isHeaderSent(
3336             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3337             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3338   }
3339 
3340   @Test
createGroupExceptionTest2()3341   public void createGroupExceptionTest2() throws Exception {
3342     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3343     mockVmMigration.addException(exception);
3344 
3345     try {
3346       String parent = "parent-995424086";
3347       Group group = Group.newBuilder().build();
3348       String groupId = "groupId293428218";
3349       client.createGroupAsync(parent, group, groupId).get();
3350       Assert.fail("No exception raised");
3351     } catch (ExecutionException e) {
3352       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3353       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3354       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3355     }
3356   }
3357 
3358   @Test
updateGroupTest()3359   public void updateGroupTest() throws Exception {
3360     Group expectedResponse =
3361         Group.newBuilder()
3362             .setName(GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]").toString())
3363             .setCreateTime(Timestamp.newBuilder().build())
3364             .setUpdateTime(Timestamp.newBuilder().build())
3365             .setDescription("description-1724546052")
3366             .setDisplayName("displayName1714148973")
3367             .build();
3368     Operation resultOperation =
3369         Operation.newBuilder()
3370             .setName("updateGroupTest")
3371             .setDone(true)
3372             .setResponse(Any.pack(expectedResponse))
3373             .build();
3374     mockVmMigration.addResponse(resultOperation);
3375 
3376     Group group = Group.newBuilder().build();
3377     FieldMask updateMask = FieldMask.newBuilder().build();
3378 
3379     Group actualResponse = client.updateGroupAsync(group, updateMask).get();
3380     Assert.assertEquals(expectedResponse, actualResponse);
3381 
3382     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3383     Assert.assertEquals(1, actualRequests.size());
3384     UpdateGroupRequest actualRequest = ((UpdateGroupRequest) actualRequests.get(0));
3385 
3386     Assert.assertEquals(group, actualRequest.getGroup());
3387     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
3388     Assert.assertTrue(
3389         channelProvider.isHeaderSent(
3390             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3391             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3392   }
3393 
3394   @Test
updateGroupExceptionTest()3395   public void updateGroupExceptionTest() throws Exception {
3396     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3397     mockVmMigration.addException(exception);
3398 
3399     try {
3400       Group group = Group.newBuilder().build();
3401       FieldMask updateMask = FieldMask.newBuilder().build();
3402       client.updateGroupAsync(group, updateMask).get();
3403       Assert.fail("No exception raised");
3404     } catch (ExecutionException e) {
3405       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3406       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3407       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3408     }
3409   }
3410 
3411   @Test
deleteGroupTest()3412   public void deleteGroupTest() throws Exception {
3413     Empty expectedResponse = Empty.newBuilder().build();
3414     Operation resultOperation =
3415         Operation.newBuilder()
3416             .setName("deleteGroupTest")
3417             .setDone(true)
3418             .setResponse(Any.pack(expectedResponse))
3419             .build();
3420     mockVmMigration.addResponse(resultOperation);
3421 
3422     GroupName name = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3423 
3424     client.deleteGroupAsync(name).get();
3425 
3426     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3427     Assert.assertEquals(1, actualRequests.size());
3428     DeleteGroupRequest actualRequest = ((DeleteGroupRequest) actualRequests.get(0));
3429 
3430     Assert.assertEquals(name.toString(), actualRequest.getName());
3431     Assert.assertTrue(
3432         channelProvider.isHeaderSent(
3433             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3434             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3435   }
3436 
3437   @Test
deleteGroupExceptionTest()3438   public void deleteGroupExceptionTest() throws Exception {
3439     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3440     mockVmMigration.addException(exception);
3441 
3442     try {
3443       GroupName name = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3444       client.deleteGroupAsync(name).get();
3445       Assert.fail("No exception raised");
3446     } catch (ExecutionException e) {
3447       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3448       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3449       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3450     }
3451   }
3452 
3453   @Test
deleteGroupTest2()3454   public void deleteGroupTest2() throws Exception {
3455     Empty expectedResponse = Empty.newBuilder().build();
3456     Operation resultOperation =
3457         Operation.newBuilder()
3458             .setName("deleteGroupTest")
3459             .setDone(true)
3460             .setResponse(Any.pack(expectedResponse))
3461             .build();
3462     mockVmMigration.addResponse(resultOperation);
3463 
3464     String name = "name3373707";
3465 
3466     client.deleteGroupAsync(name).get();
3467 
3468     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3469     Assert.assertEquals(1, actualRequests.size());
3470     DeleteGroupRequest actualRequest = ((DeleteGroupRequest) actualRequests.get(0));
3471 
3472     Assert.assertEquals(name, actualRequest.getName());
3473     Assert.assertTrue(
3474         channelProvider.isHeaderSent(
3475             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3476             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3477   }
3478 
3479   @Test
deleteGroupExceptionTest2()3480   public void deleteGroupExceptionTest2() throws Exception {
3481     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3482     mockVmMigration.addException(exception);
3483 
3484     try {
3485       String name = "name3373707";
3486       client.deleteGroupAsync(name).get();
3487       Assert.fail("No exception raised");
3488     } catch (ExecutionException e) {
3489       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3490       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3491       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3492     }
3493   }
3494 
3495   @Test
addGroupMigrationTest()3496   public void addGroupMigrationTest() throws Exception {
3497     AddGroupMigrationResponse expectedResponse = AddGroupMigrationResponse.newBuilder().build();
3498     Operation resultOperation =
3499         Operation.newBuilder()
3500             .setName("addGroupMigrationTest")
3501             .setDone(true)
3502             .setResponse(Any.pack(expectedResponse))
3503             .build();
3504     mockVmMigration.addResponse(resultOperation);
3505 
3506     GroupName group = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3507 
3508     AddGroupMigrationResponse actualResponse = client.addGroupMigrationAsync(group).get();
3509     Assert.assertEquals(expectedResponse, actualResponse);
3510 
3511     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3512     Assert.assertEquals(1, actualRequests.size());
3513     AddGroupMigrationRequest actualRequest = ((AddGroupMigrationRequest) actualRequests.get(0));
3514 
3515     Assert.assertEquals(group.toString(), actualRequest.getGroup());
3516     Assert.assertTrue(
3517         channelProvider.isHeaderSent(
3518             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3519             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3520   }
3521 
3522   @Test
addGroupMigrationExceptionTest()3523   public void addGroupMigrationExceptionTest() throws Exception {
3524     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3525     mockVmMigration.addException(exception);
3526 
3527     try {
3528       GroupName group = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3529       client.addGroupMigrationAsync(group).get();
3530       Assert.fail("No exception raised");
3531     } catch (ExecutionException e) {
3532       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3533       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3534       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3535     }
3536   }
3537 
3538   @Test
addGroupMigrationTest2()3539   public void addGroupMigrationTest2() throws Exception {
3540     AddGroupMigrationResponse expectedResponse = AddGroupMigrationResponse.newBuilder().build();
3541     Operation resultOperation =
3542         Operation.newBuilder()
3543             .setName("addGroupMigrationTest")
3544             .setDone(true)
3545             .setResponse(Any.pack(expectedResponse))
3546             .build();
3547     mockVmMigration.addResponse(resultOperation);
3548 
3549     String group = "group98629247";
3550 
3551     AddGroupMigrationResponse actualResponse = client.addGroupMigrationAsync(group).get();
3552     Assert.assertEquals(expectedResponse, actualResponse);
3553 
3554     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3555     Assert.assertEquals(1, actualRequests.size());
3556     AddGroupMigrationRequest actualRequest = ((AddGroupMigrationRequest) actualRequests.get(0));
3557 
3558     Assert.assertEquals(group, actualRequest.getGroup());
3559     Assert.assertTrue(
3560         channelProvider.isHeaderSent(
3561             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3562             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3563   }
3564 
3565   @Test
addGroupMigrationExceptionTest2()3566   public void addGroupMigrationExceptionTest2() throws Exception {
3567     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3568     mockVmMigration.addException(exception);
3569 
3570     try {
3571       String group = "group98629247";
3572       client.addGroupMigrationAsync(group).get();
3573       Assert.fail("No exception raised");
3574     } catch (ExecutionException e) {
3575       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3576       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3577       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3578     }
3579   }
3580 
3581   @Test
removeGroupMigrationTest()3582   public void removeGroupMigrationTest() throws Exception {
3583     RemoveGroupMigrationResponse expectedResponse =
3584         RemoveGroupMigrationResponse.newBuilder().build();
3585     Operation resultOperation =
3586         Operation.newBuilder()
3587             .setName("removeGroupMigrationTest")
3588             .setDone(true)
3589             .setResponse(Any.pack(expectedResponse))
3590             .build();
3591     mockVmMigration.addResponse(resultOperation);
3592 
3593     GroupName group = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3594 
3595     RemoveGroupMigrationResponse actualResponse = client.removeGroupMigrationAsync(group).get();
3596     Assert.assertEquals(expectedResponse, actualResponse);
3597 
3598     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3599     Assert.assertEquals(1, actualRequests.size());
3600     RemoveGroupMigrationRequest actualRequest =
3601         ((RemoveGroupMigrationRequest) actualRequests.get(0));
3602 
3603     Assert.assertEquals(group.toString(), actualRequest.getGroup());
3604     Assert.assertTrue(
3605         channelProvider.isHeaderSent(
3606             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3607             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3608   }
3609 
3610   @Test
removeGroupMigrationExceptionTest()3611   public void removeGroupMigrationExceptionTest() throws Exception {
3612     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3613     mockVmMigration.addException(exception);
3614 
3615     try {
3616       GroupName group = GroupName.of("[PROJECT]", "[LOCATION]", "[GROUP]");
3617       client.removeGroupMigrationAsync(group).get();
3618       Assert.fail("No exception raised");
3619     } catch (ExecutionException e) {
3620       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3621       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3622       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3623     }
3624   }
3625 
3626   @Test
removeGroupMigrationTest2()3627   public void removeGroupMigrationTest2() throws Exception {
3628     RemoveGroupMigrationResponse expectedResponse =
3629         RemoveGroupMigrationResponse.newBuilder().build();
3630     Operation resultOperation =
3631         Operation.newBuilder()
3632             .setName("removeGroupMigrationTest")
3633             .setDone(true)
3634             .setResponse(Any.pack(expectedResponse))
3635             .build();
3636     mockVmMigration.addResponse(resultOperation);
3637 
3638     String group = "group98629247";
3639 
3640     RemoveGroupMigrationResponse actualResponse = client.removeGroupMigrationAsync(group).get();
3641     Assert.assertEquals(expectedResponse, actualResponse);
3642 
3643     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3644     Assert.assertEquals(1, actualRequests.size());
3645     RemoveGroupMigrationRequest actualRequest =
3646         ((RemoveGroupMigrationRequest) actualRequests.get(0));
3647 
3648     Assert.assertEquals(group, actualRequest.getGroup());
3649     Assert.assertTrue(
3650         channelProvider.isHeaderSent(
3651             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3652             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3653   }
3654 
3655   @Test
removeGroupMigrationExceptionTest2()3656   public void removeGroupMigrationExceptionTest2() throws Exception {
3657     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3658     mockVmMigration.addException(exception);
3659 
3660     try {
3661       String group = "group98629247";
3662       client.removeGroupMigrationAsync(group).get();
3663       Assert.fail("No exception raised");
3664     } catch (ExecutionException e) {
3665       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3666       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3667       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3668     }
3669   }
3670 
3671   @Test
listTargetProjectsTest()3672   public void listTargetProjectsTest() throws Exception {
3673     TargetProject responsesElement = TargetProject.newBuilder().build();
3674     ListTargetProjectsResponse expectedResponse =
3675         ListTargetProjectsResponse.newBuilder()
3676             .setNextPageToken("")
3677             .addAllTargetProjects(Arrays.asList(responsesElement))
3678             .build();
3679     mockVmMigration.addResponse(expectedResponse);
3680 
3681     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3682 
3683     ListTargetProjectsPagedResponse pagedListResponse = client.listTargetProjects(parent);
3684 
3685     List<TargetProject> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3686 
3687     Assert.assertEquals(1, resources.size());
3688     Assert.assertEquals(expectedResponse.getTargetProjectsList().get(0), resources.get(0));
3689 
3690     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3691     Assert.assertEquals(1, actualRequests.size());
3692     ListTargetProjectsRequest actualRequest = ((ListTargetProjectsRequest) actualRequests.get(0));
3693 
3694     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3695     Assert.assertTrue(
3696         channelProvider.isHeaderSent(
3697             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3698             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3699   }
3700 
3701   @Test
listTargetProjectsExceptionTest()3702   public void listTargetProjectsExceptionTest() throws Exception {
3703     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3704     mockVmMigration.addException(exception);
3705 
3706     try {
3707       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3708       client.listTargetProjects(parent);
3709       Assert.fail("No exception raised");
3710     } catch (InvalidArgumentException e) {
3711       // Expected exception.
3712     }
3713   }
3714 
3715   @Test
listTargetProjectsTest2()3716   public void listTargetProjectsTest2() throws Exception {
3717     TargetProject responsesElement = TargetProject.newBuilder().build();
3718     ListTargetProjectsResponse expectedResponse =
3719         ListTargetProjectsResponse.newBuilder()
3720             .setNextPageToken("")
3721             .addAllTargetProjects(Arrays.asList(responsesElement))
3722             .build();
3723     mockVmMigration.addResponse(expectedResponse);
3724 
3725     String parent = "parent-995424086";
3726 
3727     ListTargetProjectsPagedResponse pagedListResponse = client.listTargetProjects(parent);
3728 
3729     List<TargetProject> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3730 
3731     Assert.assertEquals(1, resources.size());
3732     Assert.assertEquals(expectedResponse.getTargetProjectsList().get(0), resources.get(0));
3733 
3734     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3735     Assert.assertEquals(1, actualRequests.size());
3736     ListTargetProjectsRequest actualRequest = ((ListTargetProjectsRequest) actualRequests.get(0));
3737 
3738     Assert.assertEquals(parent, actualRequest.getParent());
3739     Assert.assertTrue(
3740         channelProvider.isHeaderSent(
3741             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3742             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3743   }
3744 
3745   @Test
listTargetProjectsExceptionTest2()3746   public void listTargetProjectsExceptionTest2() throws Exception {
3747     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3748     mockVmMigration.addException(exception);
3749 
3750     try {
3751       String parent = "parent-995424086";
3752       client.listTargetProjects(parent);
3753       Assert.fail("No exception raised");
3754     } catch (InvalidArgumentException e) {
3755       // Expected exception.
3756     }
3757   }
3758 
3759   @Test
getTargetProjectTest()3760   public void getTargetProjectTest() throws Exception {
3761     TargetProject expectedResponse =
3762         TargetProject.newBuilder()
3763             .setName(TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]").toString())
3764             .setProject("project-309310695")
3765             .setDescription("description-1724546052")
3766             .setCreateTime(Timestamp.newBuilder().build())
3767             .setUpdateTime(Timestamp.newBuilder().build())
3768             .build();
3769     mockVmMigration.addResponse(expectedResponse);
3770 
3771     TargetProjectName name = TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]");
3772 
3773     TargetProject actualResponse = client.getTargetProject(name);
3774     Assert.assertEquals(expectedResponse, actualResponse);
3775 
3776     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3777     Assert.assertEquals(1, actualRequests.size());
3778     GetTargetProjectRequest actualRequest = ((GetTargetProjectRequest) actualRequests.get(0));
3779 
3780     Assert.assertEquals(name.toString(), actualRequest.getName());
3781     Assert.assertTrue(
3782         channelProvider.isHeaderSent(
3783             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3784             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3785   }
3786 
3787   @Test
getTargetProjectExceptionTest()3788   public void getTargetProjectExceptionTest() throws Exception {
3789     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3790     mockVmMigration.addException(exception);
3791 
3792     try {
3793       TargetProjectName name = TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]");
3794       client.getTargetProject(name);
3795       Assert.fail("No exception raised");
3796     } catch (InvalidArgumentException e) {
3797       // Expected exception.
3798     }
3799   }
3800 
3801   @Test
getTargetProjectTest2()3802   public void getTargetProjectTest2() throws Exception {
3803     TargetProject expectedResponse =
3804         TargetProject.newBuilder()
3805             .setName(TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]").toString())
3806             .setProject("project-309310695")
3807             .setDescription("description-1724546052")
3808             .setCreateTime(Timestamp.newBuilder().build())
3809             .setUpdateTime(Timestamp.newBuilder().build())
3810             .build();
3811     mockVmMigration.addResponse(expectedResponse);
3812 
3813     String name = "name3373707";
3814 
3815     TargetProject actualResponse = client.getTargetProject(name);
3816     Assert.assertEquals(expectedResponse, actualResponse);
3817 
3818     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3819     Assert.assertEquals(1, actualRequests.size());
3820     GetTargetProjectRequest actualRequest = ((GetTargetProjectRequest) actualRequests.get(0));
3821 
3822     Assert.assertEquals(name, actualRequest.getName());
3823     Assert.assertTrue(
3824         channelProvider.isHeaderSent(
3825             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3826             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3827   }
3828 
3829   @Test
getTargetProjectExceptionTest2()3830   public void getTargetProjectExceptionTest2() throws Exception {
3831     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3832     mockVmMigration.addException(exception);
3833 
3834     try {
3835       String name = "name3373707";
3836       client.getTargetProject(name);
3837       Assert.fail("No exception raised");
3838     } catch (InvalidArgumentException e) {
3839       // Expected exception.
3840     }
3841   }
3842 
3843   @Test
createTargetProjectTest()3844   public void createTargetProjectTest() throws Exception {
3845     TargetProject expectedResponse =
3846         TargetProject.newBuilder()
3847             .setName(TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]").toString())
3848             .setProject("project-309310695")
3849             .setDescription("description-1724546052")
3850             .setCreateTime(Timestamp.newBuilder().build())
3851             .setUpdateTime(Timestamp.newBuilder().build())
3852             .build();
3853     Operation resultOperation =
3854         Operation.newBuilder()
3855             .setName("createTargetProjectTest")
3856             .setDone(true)
3857             .setResponse(Any.pack(expectedResponse))
3858             .build();
3859     mockVmMigration.addResponse(resultOperation);
3860 
3861     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3862     TargetProject targetProject = TargetProject.newBuilder().build();
3863     String targetProjectId = "targetProjectId1290130307";
3864 
3865     TargetProject actualResponse =
3866         client.createTargetProjectAsync(parent, targetProject, targetProjectId).get();
3867     Assert.assertEquals(expectedResponse, actualResponse);
3868 
3869     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3870     Assert.assertEquals(1, actualRequests.size());
3871     CreateTargetProjectRequest actualRequest = ((CreateTargetProjectRequest) actualRequests.get(0));
3872 
3873     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3874     Assert.assertEquals(targetProject, actualRequest.getTargetProject());
3875     Assert.assertEquals(targetProjectId, actualRequest.getTargetProjectId());
3876     Assert.assertTrue(
3877         channelProvider.isHeaderSent(
3878             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3879             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3880   }
3881 
3882   @Test
createTargetProjectExceptionTest()3883   public void createTargetProjectExceptionTest() throws Exception {
3884     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3885     mockVmMigration.addException(exception);
3886 
3887     try {
3888       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3889       TargetProject targetProject = TargetProject.newBuilder().build();
3890       String targetProjectId = "targetProjectId1290130307";
3891       client.createTargetProjectAsync(parent, targetProject, targetProjectId).get();
3892       Assert.fail("No exception raised");
3893     } catch (ExecutionException e) {
3894       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3895       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3896       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3897     }
3898   }
3899 
3900   @Test
createTargetProjectTest2()3901   public void createTargetProjectTest2() throws Exception {
3902     TargetProject expectedResponse =
3903         TargetProject.newBuilder()
3904             .setName(TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]").toString())
3905             .setProject("project-309310695")
3906             .setDescription("description-1724546052")
3907             .setCreateTime(Timestamp.newBuilder().build())
3908             .setUpdateTime(Timestamp.newBuilder().build())
3909             .build();
3910     Operation resultOperation =
3911         Operation.newBuilder()
3912             .setName("createTargetProjectTest")
3913             .setDone(true)
3914             .setResponse(Any.pack(expectedResponse))
3915             .build();
3916     mockVmMigration.addResponse(resultOperation);
3917 
3918     String parent = "parent-995424086";
3919     TargetProject targetProject = TargetProject.newBuilder().build();
3920     String targetProjectId = "targetProjectId1290130307";
3921 
3922     TargetProject actualResponse =
3923         client.createTargetProjectAsync(parent, targetProject, targetProjectId).get();
3924     Assert.assertEquals(expectedResponse, actualResponse);
3925 
3926     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3927     Assert.assertEquals(1, actualRequests.size());
3928     CreateTargetProjectRequest actualRequest = ((CreateTargetProjectRequest) actualRequests.get(0));
3929 
3930     Assert.assertEquals(parent, actualRequest.getParent());
3931     Assert.assertEquals(targetProject, actualRequest.getTargetProject());
3932     Assert.assertEquals(targetProjectId, actualRequest.getTargetProjectId());
3933     Assert.assertTrue(
3934         channelProvider.isHeaderSent(
3935             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3936             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3937   }
3938 
3939   @Test
createTargetProjectExceptionTest2()3940   public void createTargetProjectExceptionTest2() throws Exception {
3941     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3942     mockVmMigration.addException(exception);
3943 
3944     try {
3945       String parent = "parent-995424086";
3946       TargetProject targetProject = TargetProject.newBuilder().build();
3947       String targetProjectId = "targetProjectId1290130307";
3948       client.createTargetProjectAsync(parent, targetProject, targetProjectId).get();
3949       Assert.fail("No exception raised");
3950     } catch (ExecutionException e) {
3951       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3952       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3953       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3954     }
3955   }
3956 
3957   @Test
updateTargetProjectTest()3958   public void updateTargetProjectTest() throws Exception {
3959     TargetProject expectedResponse =
3960         TargetProject.newBuilder()
3961             .setName(TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]").toString())
3962             .setProject("project-309310695")
3963             .setDescription("description-1724546052")
3964             .setCreateTime(Timestamp.newBuilder().build())
3965             .setUpdateTime(Timestamp.newBuilder().build())
3966             .build();
3967     Operation resultOperation =
3968         Operation.newBuilder()
3969             .setName("updateTargetProjectTest")
3970             .setDone(true)
3971             .setResponse(Any.pack(expectedResponse))
3972             .build();
3973     mockVmMigration.addResponse(resultOperation);
3974 
3975     TargetProject targetProject = TargetProject.newBuilder().build();
3976     FieldMask updateMask = FieldMask.newBuilder().build();
3977 
3978     TargetProject actualResponse = client.updateTargetProjectAsync(targetProject, updateMask).get();
3979     Assert.assertEquals(expectedResponse, actualResponse);
3980 
3981     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
3982     Assert.assertEquals(1, actualRequests.size());
3983     UpdateTargetProjectRequest actualRequest = ((UpdateTargetProjectRequest) actualRequests.get(0));
3984 
3985     Assert.assertEquals(targetProject, actualRequest.getTargetProject());
3986     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
3987     Assert.assertTrue(
3988         channelProvider.isHeaderSent(
3989             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3990             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3991   }
3992 
3993   @Test
updateTargetProjectExceptionTest()3994   public void updateTargetProjectExceptionTest() throws Exception {
3995     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3996     mockVmMigration.addException(exception);
3997 
3998     try {
3999       TargetProject targetProject = TargetProject.newBuilder().build();
4000       FieldMask updateMask = FieldMask.newBuilder().build();
4001       client.updateTargetProjectAsync(targetProject, updateMask).get();
4002       Assert.fail("No exception raised");
4003     } catch (ExecutionException e) {
4004       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
4005       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
4006       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
4007     }
4008   }
4009 
4010   @Test
deleteTargetProjectTest()4011   public void deleteTargetProjectTest() throws Exception {
4012     Empty expectedResponse = Empty.newBuilder().build();
4013     Operation resultOperation =
4014         Operation.newBuilder()
4015             .setName("deleteTargetProjectTest")
4016             .setDone(true)
4017             .setResponse(Any.pack(expectedResponse))
4018             .build();
4019     mockVmMigration.addResponse(resultOperation);
4020 
4021     TargetProjectName name = TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]");
4022 
4023     client.deleteTargetProjectAsync(name).get();
4024 
4025     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4026     Assert.assertEquals(1, actualRequests.size());
4027     DeleteTargetProjectRequest actualRequest = ((DeleteTargetProjectRequest) actualRequests.get(0));
4028 
4029     Assert.assertEquals(name.toString(), actualRequest.getName());
4030     Assert.assertTrue(
4031         channelProvider.isHeaderSent(
4032             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4033             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4034   }
4035 
4036   @Test
deleteTargetProjectExceptionTest()4037   public void deleteTargetProjectExceptionTest() throws Exception {
4038     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4039     mockVmMigration.addException(exception);
4040 
4041     try {
4042       TargetProjectName name = TargetProjectName.of("[PROJECT]", "[LOCATION]", "[TARGET_PROJECT]");
4043       client.deleteTargetProjectAsync(name).get();
4044       Assert.fail("No exception raised");
4045     } catch (ExecutionException e) {
4046       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
4047       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
4048       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
4049     }
4050   }
4051 
4052   @Test
deleteTargetProjectTest2()4053   public void deleteTargetProjectTest2() throws Exception {
4054     Empty expectedResponse = Empty.newBuilder().build();
4055     Operation resultOperation =
4056         Operation.newBuilder()
4057             .setName("deleteTargetProjectTest")
4058             .setDone(true)
4059             .setResponse(Any.pack(expectedResponse))
4060             .build();
4061     mockVmMigration.addResponse(resultOperation);
4062 
4063     String name = "name3373707";
4064 
4065     client.deleteTargetProjectAsync(name).get();
4066 
4067     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4068     Assert.assertEquals(1, actualRequests.size());
4069     DeleteTargetProjectRequest actualRequest = ((DeleteTargetProjectRequest) actualRequests.get(0));
4070 
4071     Assert.assertEquals(name, actualRequest.getName());
4072     Assert.assertTrue(
4073         channelProvider.isHeaderSent(
4074             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4075             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4076   }
4077 
4078   @Test
deleteTargetProjectExceptionTest2()4079   public void deleteTargetProjectExceptionTest2() throws Exception {
4080     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4081     mockVmMigration.addException(exception);
4082 
4083     try {
4084       String name = "name3373707";
4085       client.deleteTargetProjectAsync(name).get();
4086       Assert.fail("No exception raised");
4087     } catch (ExecutionException e) {
4088       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
4089       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
4090       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
4091     }
4092   }
4093 
4094   @Test
listReplicationCyclesTest()4095   public void listReplicationCyclesTest() throws Exception {
4096     ReplicationCycle responsesElement = ReplicationCycle.newBuilder().build();
4097     ListReplicationCyclesResponse expectedResponse =
4098         ListReplicationCyclesResponse.newBuilder()
4099             .setNextPageToken("")
4100             .addAllReplicationCycles(Arrays.asList(responsesElement))
4101             .build();
4102     mockVmMigration.addResponse(expectedResponse);
4103 
4104     MigratingVmName parent =
4105         MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
4106 
4107     ListReplicationCyclesPagedResponse pagedListResponse = client.listReplicationCycles(parent);
4108 
4109     List<ReplicationCycle> resources = Lists.newArrayList(pagedListResponse.iterateAll());
4110 
4111     Assert.assertEquals(1, resources.size());
4112     Assert.assertEquals(expectedResponse.getReplicationCyclesList().get(0), resources.get(0));
4113 
4114     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4115     Assert.assertEquals(1, actualRequests.size());
4116     ListReplicationCyclesRequest actualRequest =
4117         ((ListReplicationCyclesRequest) actualRequests.get(0));
4118 
4119     Assert.assertEquals(parent.toString(), actualRequest.getParent());
4120     Assert.assertTrue(
4121         channelProvider.isHeaderSent(
4122             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4123             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4124   }
4125 
4126   @Test
listReplicationCyclesExceptionTest()4127   public void listReplicationCyclesExceptionTest() throws Exception {
4128     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4129     mockVmMigration.addException(exception);
4130 
4131     try {
4132       MigratingVmName parent =
4133           MigratingVmName.of("[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]");
4134       client.listReplicationCycles(parent);
4135       Assert.fail("No exception raised");
4136     } catch (InvalidArgumentException e) {
4137       // Expected exception.
4138     }
4139   }
4140 
4141   @Test
listReplicationCyclesTest2()4142   public void listReplicationCyclesTest2() throws Exception {
4143     ReplicationCycle responsesElement = ReplicationCycle.newBuilder().build();
4144     ListReplicationCyclesResponse expectedResponse =
4145         ListReplicationCyclesResponse.newBuilder()
4146             .setNextPageToken("")
4147             .addAllReplicationCycles(Arrays.asList(responsesElement))
4148             .build();
4149     mockVmMigration.addResponse(expectedResponse);
4150 
4151     String parent = "parent-995424086";
4152 
4153     ListReplicationCyclesPagedResponse pagedListResponse = client.listReplicationCycles(parent);
4154 
4155     List<ReplicationCycle> resources = Lists.newArrayList(pagedListResponse.iterateAll());
4156 
4157     Assert.assertEquals(1, resources.size());
4158     Assert.assertEquals(expectedResponse.getReplicationCyclesList().get(0), resources.get(0));
4159 
4160     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4161     Assert.assertEquals(1, actualRequests.size());
4162     ListReplicationCyclesRequest actualRequest =
4163         ((ListReplicationCyclesRequest) actualRequests.get(0));
4164 
4165     Assert.assertEquals(parent, actualRequest.getParent());
4166     Assert.assertTrue(
4167         channelProvider.isHeaderSent(
4168             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4169             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4170   }
4171 
4172   @Test
listReplicationCyclesExceptionTest2()4173   public void listReplicationCyclesExceptionTest2() throws Exception {
4174     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4175     mockVmMigration.addException(exception);
4176 
4177     try {
4178       String parent = "parent-995424086";
4179       client.listReplicationCycles(parent);
4180       Assert.fail("No exception raised");
4181     } catch (InvalidArgumentException e) {
4182       // Expected exception.
4183     }
4184   }
4185 
4186   @Test
getReplicationCycleTest()4187   public void getReplicationCycleTest() throws Exception {
4188     ReplicationCycle expectedResponse =
4189         ReplicationCycle.newBuilder()
4190             .setName(
4191                 ReplicationCycleName.of(
4192                         "[PROJECT]",
4193                         "[LOCATION]",
4194                         "[SOURCE]",
4195                         "[MIGRATING_VM]",
4196                         "[REPLICATION_CYCLE]")
4197                     .toString())
4198             .setCycleNumber(-1095724862)
4199             .setStartTime(Timestamp.newBuilder().build())
4200             .setEndTime(Timestamp.newBuilder().build())
4201             .setTotalPauseDuration(Duration.newBuilder().build())
4202             .setProgressPercent(-2137894861)
4203             .addAllSteps(new ArrayList<CycleStep>())
4204             .setError(Status.newBuilder().build())
4205             .build();
4206     mockVmMigration.addResponse(expectedResponse);
4207 
4208     ReplicationCycleName name =
4209         ReplicationCycleName.of(
4210             "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[REPLICATION_CYCLE]");
4211 
4212     ReplicationCycle actualResponse = client.getReplicationCycle(name);
4213     Assert.assertEquals(expectedResponse, actualResponse);
4214 
4215     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4216     Assert.assertEquals(1, actualRequests.size());
4217     GetReplicationCycleRequest actualRequest = ((GetReplicationCycleRequest) actualRequests.get(0));
4218 
4219     Assert.assertEquals(name.toString(), actualRequest.getName());
4220     Assert.assertTrue(
4221         channelProvider.isHeaderSent(
4222             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4223             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4224   }
4225 
4226   @Test
getReplicationCycleExceptionTest()4227   public void getReplicationCycleExceptionTest() throws Exception {
4228     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4229     mockVmMigration.addException(exception);
4230 
4231     try {
4232       ReplicationCycleName name =
4233           ReplicationCycleName.of(
4234               "[PROJECT]", "[LOCATION]", "[SOURCE]", "[MIGRATING_VM]", "[REPLICATION_CYCLE]");
4235       client.getReplicationCycle(name);
4236       Assert.fail("No exception raised");
4237     } catch (InvalidArgumentException e) {
4238       // Expected exception.
4239     }
4240   }
4241 
4242   @Test
getReplicationCycleTest2()4243   public void getReplicationCycleTest2() throws Exception {
4244     ReplicationCycle expectedResponse =
4245         ReplicationCycle.newBuilder()
4246             .setName(
4247                 ReplicationCycleName.of(
4248                         "[PROJECT]",
4249                         "[LOCATION]",
4250                         "[SOURCE]",
4251                         "[MIGRATING_VM]",
4252                         "[REPLICATION_CYCLE]")
4253                     .toString())
4254             .setCycleNumber(-1095724862)
4255             .setStartTime(Timestamp.newBuilder().build())
4256             .setEndTime(Timestamp.newBuilder().build())
4257             .setTotalPauseDuration(Duration.newBuilder().build())
4258             .setProgressPercent(-2137894861)
4259             .addAllSteps(new ArrayList<CycleStep>())
4260             .setError(Status.newBuilder().build())
4261             .build();
4262     mockVmMigration.addResponse(expectedResponse);
4263 
4264     String name = "name3373707";
4265 
4266     ReplicationCycle actualResponse = client.getReplicationCycle(name);
4267     Assert.assertEquals(expectedResponse, actualResponse);
4268 
4269     List<AbstractMessage> actualRequests = mockVmMigration.getRequests();
4270     Assert.assertEquals(1, actualRequests.size());
4271     GetReplicationCycleRequest actualRequest = ((GetReplicationCycleRequest) actualRequests.get(0));
4272 
4273     Assert.assertEquals(name, actualRequest.getName());
4274     Assert.assertTrue(
4275         channelProvider.isHeaderSent(
4276             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4277             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4278   }
4279 
4280   @Test
getReplicationCycleExceptionTest2()4281   public void getReplicationCycleExceptionTest2() throws Exception {
4282     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4283     mockVmMigration.addException(exception);
4284 
4285     try {
4286       String name = "name3373707";
4287       client.getReplicationCycle(name);
4288       Assert.fail("No exception raised");
4289     } catch (InvalidArgumentException e) {
4290       // Expected exception.
4291     }
4292   }
4293 
4294   @Test
listLocationsTest()4295   public void listLocationsTest() throws Exception {
4296     Location responsesElement = Location.newBuilder().build();
4297     ListLocationsResponse expectedResponse =
4298         ListLocationsResponse.newBuilder()
4299             .setNextPageToken("")
4300             .addAllLocations(Arrays.asList(responsesElement))
4301             .build();
4302     mockLocations.addResponse(expectedResponse);
4303 
4304     ListLocationsRequest request =
4305         ListLocationsRequest.newBuilder()
4306             .setName("name3373707")
4307             .setFilter("filter-1274492040")
4308             .setPageSize(883849137)
4309             .setPageToken("pageToken873572522")
4310             .build();
4311 
4312     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
4313 
4314     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
4315 
4316     Assert.assertEquals(1, resources.size());
4317     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
4318 
4319     List<AbstractMessage> actualRequests = mockLocations.getRequests();
4320     Assert.assertEquals(1, actualRequests.size());
4321     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
4322 
4323     Assert.assertEquals(request.getName(), actualRequest.getName());
4324     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
4325     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
4326     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
4327     Assert.assertTrue(
4328         channelProvider.isHeaderSent(
4329             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4330             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4331   }
4332 
4333   @Test
listLocationsExceptionTest()4334   public void listLocationsExceptionTest() throws Exception {
4335     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4336     mockLocations.addException(exception);
4337 
4338     try {
4339       ListLocationsRequest request =
4340           ListLocationsRequest.newBuilder()
4341               .setName("name3373707")
4342               .setFilter("filter-1274492040")
4343               .setPageSize(883849137)
4344               .setPageToken("pageToken873572522")
4345               .build();
4346       client.listLocations(request);
4347       Assert.fail("No exception raised");
4348     } catch (InvalidArgumentException e) {
4349       // Expected exception.
4350     }
4351   }
4352 
4353   @Test
getLocationTest()4354   public void getLocationTest() throws Exception {
4355     Location expectedResponse =
4356         Location.newBuilder()
4357             .setName("name3373707")
4358             .setLocationId("locationId1541836720")
4359             .setDisplayName("displayName1714148973")
4360             .putAllLabels(new HashMap<String, String>())
4361             .setMetadata(Any.newBuilder().build())
4362             .build();
4363     mockLocations.addResponse(expectedResponse);
4364 
4365     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
4366 
4367     Location actualResponse = client.getLocation(request);
4368     Assert.assertEquals(expectedResponse, actualResponse);
4369 
4370     List<AbstractMessage> actualRequests = mockLocations.getRequests();
4371     Assert.assertEquals(1, actualRequests.size());
4372     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
4373 
4374     Assert.assertEquals(request.getName(), actualRequest.getName());
4375     Assert.assertTrue(
4376         channelProvider.isHeaderSent(
4377             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4378             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4379   }
4380 
4381   @Test
getLocationExceptionTest()4382   public void getLocationExceptionTest() throws Exception {
4383     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4384     mockLocations.addException(exception);
4385 
4386     try {
4387       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
4388       client.getLocation(request);
4389       Assert.fail("No exception raised");
4390     } catch (InvalidArgumentException e) {
4391       // Expected exception.
4392     }
4393   }
4394 }
4395