• 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.clouddms.v1;
18 
19 import static com.google.cloud.clouddms.v1.DataMigrationServiceClient.ListConnectionProfilesPagedResponse;
20 import static com.google.cloud.clouddms.v1.DataMigrationServiceClient.ListMigrationJobsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.common.collect.Lists;
31 import com.google.longrunning.Operation;
32 import com.google.protobuf.AbstractMessage;
33 import com.google.protobuf.Any;
34 import com.google.protobuf.Duration;
35 import com.google.protobuf.Empty;
36 import com.google.protobuf.FieldMask;
37 import com.google.protobuf.Timestamp;
38 import com.google.rpc.Status;
39 import io.grpc.StatusRuntimeException;
40 import java.io.IOException;
41 import java.util.Arrays;
42 import java.util.HashMap;
43 import java.util.List;
44 import java.util.UUID;
45 import java.util.concurrent.ExecutionException;
46 import javax.annotation.Generated;
47 import org.junit.After;
48 import org.junit.AfterClass;
49 import org.junit.Assert;
50 import org.junit.Before;
51 import org.junit.BeforeClass;
52 import org.junit.Test;
53 
54 @Generated("by gapic-generator-java")
55 public class DataMigrationServiceClientTest {
56   private static MockDataMigrationService mockDataMigrationService;
57   private static MockServiceHelper mockServiceHelper;
58   private LocalChannelProvider channelProvider;
59   private DataMigrationServiceClient client;
60 
61   @BeforeClass
startStaticServer()62   public static void startStaticServer() {
63     mockDataMigrationService = new MockDataMigrationService();
64     mockServiceHelper =
65         new MockServiceHelper(
66             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockDataMigrationService));
67     mockServiceHelper.start();
68   }
69 
70   @AfterClass
stopServer()71   public static void stopServer() {
72     mockServiceHelper.stop();
73   }
74 
75   @Before
setUp()76   public void setUp() throws IOException {
77     mockServiceHelper.reset();
78     channelProvider = mockServiceHelper.createChannelProvider();
79     DataMigrationServiceSettings settings =
80         DataMigrationServiceSettings.newBuilder()
81             .setTransportChannelProvider(channelProvider)
82             .setCredentialsProvider(NoCredentialsProvider.create())
83             .build();
84     client = DataMigrationServiceClient.create(settings);
85   }
86 
87   @After
tearDown()88   public void tearDown() throws Exception {
89     client.close();
90   }
91 
92   @Test
listMigrationJobsTest()93   public void listMigrationJobsTest() throws Exception {
94     MigrationJob responsesElement = MigrationJob.newBuilder().build();
95     ListMigrationJobsResponse expectedResponse =
96         ListMigrationJobsResponse.newBuilder()
97             .setNextPageToken("")
98             .addAllMigrationJobs(Arrays.asList(responsesElement))
99             .build();
100     mockDataMigrationService.addResponse(expectedResponse);
101 
102     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
103 
104     ListMigrationJobsPagedResponse pagedListResponse = client.listMigrationJobs(parent);
105 
106     List<MigrationJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
107 
108     Assert.assertEquals(1, resources.size());
109     Assert.assertEquals(expectedResponse.getMigrationJobsList().get(0), resources.get(0));
110 
111     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
112     Assert.assertEquals(1, actualRequests.size());
113     ListMigrationJobsRequest actualRequest = ((ListMigrationJobsRequest) actualRequests.get(0));
114 
115     Assert.assertEquals(parent.toString(), actualRequest.getParent());
116     Assert.assertTrue(
117         channelProvider.isHeaderSent(
118             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
119             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
120   }
121 
122   @Test
listMigrationJobsExceptionTest()123   public void listMigrationJobsExceptionTest() throws Exception {
124     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
125     mockDataMigrationService.addException(exception);
126 
127     try {
128       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
129       client.listMigrationJobs(parent);
130       Assert.fail("No exception raised");
131     } catch (InvalidArgumentException e) {
132       // Expected exception.
133     }
134   }
135 
136   @Test
listMigrationJobsTest2()137   public void listMigrationJobsTest2() throws Exception {
138     MigrationJob responsesElement = MigrationJob.newBuilder().build();
139     ListMigrationJobsResponse expectedResponse =
140         ListMigrationJobsResponse.newBuilder()
141             .setNextPageToken("")
142             .addAllMigrationJobs(Arrays.asList(responsesElement))
143             .build();
144     mockDataMigrationService.addResponse(expectedResponse);
145 
146     String parent = "parent-995424086";
147 
148     ListMigrationJobsPagedResponse pagedListResponse = client.listMigrationJobs(parent);
149 
150     List<MigrationJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
151 
152     Assert.assertEquals(1, resources.size());
153     Assert.assertEquals(expectedResponse.getMigrationJobsList().get(0), resources.get(0));
154 
155     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
156     Assert.assertEquals(1, actualRequests.size());
157     ListMigrationJobsRequest actualRequest = ((ListMigrationJobsRequest) actualRequests.get(0));
158 
159     Assert.assertEquals(parent, actualRequest.getParent());
160     Assert.assertTrue(
161         channelProvider.isHeaderSent(
162             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
163             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
164   }
165 
166   @Test
listMigrationJobsExceptionTest2()167   public void listMigrationJobsExceptionTest2() throws Exception {
168     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
169     mockDataMigrationService.addException(exception);
170 
171     try {
172       String parent = "parent-995424086";
173       client.listMigrationJobs(parent);
174       Assert.fail("No exception raised");
175     } catch (InvalidArgumentException e) {
176       // Expected exception.
177     }
178   }
179 
180   @Test
getMigrationJobTest()181   public void getMigrationJobTest() throws Exception {
182     MigrationJob expectedResponse =
183         MigrationJob.newBuilder()
184             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
185             .setCreateTime(Timestamp.newBuilder().build())
186             .setUpdateTime(Timestamp.newBuilder().build())
187             .putAllLabels(new HashMap<String, String>())
188             .setDisplayName("displayName1714148973")
189             .setDumpPath("dumpPath-2122385351")
190             .setSource("source-896505829")
191             .setDestination("destination-1429847026")
192             .setDuration(Duration.newBuilder().build())
193             .setError(Status.newBuilder().build())
194             .setSourceDatabase(DatabaseType.newBuilder().build())
195             .setDestinationDatabase(DatabaseType.newBuilder().build())
196             .setEndTime(Timestamp.newBuilder().build())
197             .build();
198     mockDataMigrationService.addResponse(expectedResponse);
199 
200     MigrationJobName name = MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
201 
202     MigrationJob actualResponse = client.getMigrationJob(name);
203     Assert.assertEquals(expectedResponse, actualResponse);
204 
205     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
206     Assert.assertEquals(1, actualRequests.size());
207     GetMigrationJobRequest actualRequest = ((GetMigrationJobRequest) actualRequests.get(0));
208 
209     Assert.assertEquals(name.toString(), actualRequest.getName());
210     Assert.assertTrue(
211         channelProvider.isHeaderSent(
212             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
213             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
214   }
215 
216   @Test
getMigrationJobExceptionTest()217   public void getMigrationJobExceptionTest() throws Exception {
218     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
219     mockDataMigrationService.addException(exception);
220 
221     try {
222       MigrationJobName name = MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
223       client.getMigrationJob(name);
224       Assert.fail("No exception raised");
225     } catch (InvalidArgumentException e) {
226       // Expected exception.
227     }
228   }
229 
230   @Test
getMigrationJobTest2()231   public void getMigrationJobTest2() throws Exception {
232     MigrationJob expectedResponse =
233         MigrationJob.newBuilder()
234             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
235             .setCreateTime(Timestamp.newBuilder().build())
236             .setUpdateTime(Timestamp.newBuilder().build())
237             .putAllLabels(new HashMap<String, String>())
238             .setDisplayName("displayName1714148973")
239             .setDumpPath("dumpPath-2122385351")
240             .setSource("source-896505829")
241             .setDestination("destination-1429847026")
242             .setDuration(Duration.newBuilder().build())
243             .setError(Status.newBuilder().build())
244             .setSourceDatabase(DatabaseType.newBuilder().build())
245             .setDestinationDatabase(DatabaseType.newBuilder().build())
246             .setEndTime(Timestamp.newBuilder().build())
247             .build();
248     mockDataMigrationService.addResponse(expectedResponse);
249 
250     String name = "name3373707";
251 
252     MigrationJob actualResponse = client.getMigrationJob(name);
253     Assert.assertEquals(expectedResponse, actualResponse);
254 
255     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
256     Assert.assertEquals(1, actualRequests.size());
257     GetMigrationJobRequest actualRequest = ((GetMigrationJobRequest) actualRequests.get(0));
258 
259     Assert.assertEquals(name, actualRequest.getName());
260     Assert.assertTrue(
261         channelProvider.isHeaderSent(
262             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
263             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
264   }
265 
266   @Test
getMigrationJobExceptionTest2()267   public void getMigrationJobExceptionTest2() throws Exception {
268     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
269     mockDataMigrationService.addException(exception);
270 
271     try {
272       String name = "name3373707";
273       client.getMigrationJob(name);
274       Assert.fail("No exception raised");
275     } catch (InvalidArgumentException e) {
276       // Expected exception.
277     }
278   }
279 
280   @Test
createMigrationJobTest()281   public void createMigrationJobTest() throws Exception {
282     MigrationJob expectedResponse =
283         MigrationJob.newBuilder()
284             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
285             .setCreateTime(Timestamp.newBuilder().build())
286             .setUpdateTime(Timestamp.newBuilder().build())
287             .putAllLabels(new HashMap<String, String>())
288             .setDisplayName("displayName1714148973")
289             .setDumpPath("dumpPath-2122385351")
290             .setSource("source-896505829")
291             .setDestination("destination-1429847026")
292             .setDuration(Duration.newBuilder().build())
293             .setError(Status.newBuilder().build())
294             .setSourceDatabase(DatabaseType.newBuilder().build())
295             .setDestinationDatabase(DatabaseType.newBuilder().build())
296             .setEndTime(Timestamp.newBuilder().build())
297             .build();
298     Operation resultOperation =
299         Operation.newBuilder()
300             .setName("createMigrationJobTest")
301             .setDone(true)
302             .setResponse(Any.pack(expectedResponse))
303             .build();
304     mockDataMigrationService.addResponse(resultOperation);
305 
306     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
307     MigrationJob migrationJob = MigrationJob.newBuilder().build();
308     String migrationJobId = "migrationJobId1870575242";
309 
310     MigrationJob actualResponse =
311         client.createMigrationJobAsync(parent, migrationJob, migrationJobId).get();
312     Assert.assertEquals(expectedResponse, actualResponse);
313 
314     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
315     Assert.assertEquals(1, actualRequests.size());
316     CreateMigrationJobRequest actualRequest = ((CreateMigrationJobRequest) actualRequests.get(0));
317 
318     Assert.assertEquals(parent.toString(), actualRequest.getParent());
319     Assert.assertEquals(migrationJob, actualRequest.getMigrationJob());
320     Assert.assertEquals(migrationJobId, actualRequest.getMigrationJobId());
321     Assert.assertTrue(
322         channelProvider.isHeaderSent(
323             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
324             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
325   }
326 
327   @Test
createMigrationJobExceptionTest()328   public void createMigrationJobExceptionTest() throws Exception {
329     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
330     mockDataMigrationService.addException(exception);
331 
332     try {
333       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
334       MigrationJob migrationJob = MigrationJob.newBuilder().build();
335       String migrationJobId = "migrationJobId1870575242";
336       client.createMigrationJobAsync(parent, migrationJob, migrationJobId).get();
337       Assert.fail("No exception raised");
338     } catch (ExecutionException e) {
339       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
340       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
341       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
342     }
343   }
344 
345   @Test
createMigrationJobTest2()346   public void createMigrationJobTest2() throws Exception {
347     MigrationJob expectedResponse =
348         MigrationJob.newBuilder()
349             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
350             .setCreateTime(Timestamp.newBuilder().build())
351             .setUpdateTime(Timestamp.newBuilder().build())
352             .putAllLabels(new HashMap<String, String>())
353             .setDisplayName("displayName1714148973")
354             .setDumpPath("dumpPath-2122385351")
355             .setSource("source-896505829")
356             .setDestination("destination-1429847026")
357             .setDuration(Duration.newBuilder().build())
358             .setError(Status.newBuilder().build())
359             .setSourceDatabase(DatabaseType.newBuilder().build())
360             .setDestinationDatabase(DatabaseType.newBuilder().build())
361             .setEndTime(Timestamp.newBuilder().build())
362             .build();
363     Operation resultOperation =
364         Operation.newBuilder()
365             .setName("createMigrationJobTest")
366             .setDone(true)
367             .setResponse(Any.pack(expectedResponse))
368             .build();
369     mockDataMigrationService.addResponse(resultOperation);
370 
371     String parent = "parent-995424086";
372     MigrationJob migrationJob = MigrationJob.newBuilder().build();
373     String migrationJobId = "migrationJobId1870575242";
374 
375     MigrationJob actualResponse =
376         client.createMigrationJobAsync(parent, migrationJob, migrationJobId).get();
377     Assert.assertEquals(expectedResponse, actualResponse);
378 
379     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
380     Assert.assertEquals(1, actualRequests.size());
381     CreateMigrationJobRequest actualRequest = ((CreateMigrationJobRequest) actualRequests.get(0));
382 
383     Assert.assertEquals(parent, actualRequest.getParent());
384     Assert.assertEquals(migrationJob, actualRequest.getMigrationJob());
385     Assert.assertEquals(migrationJobId, actualRequest.getMigrationJobId());
386     Assert.assertTrue(
387         channelProvider.isHeaderSent(
388             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
389             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
390   }
391 
392   @Test
createMigrationJobExceptionTest2()393   public void createMigrationJobExceptionTest2() throws Exception {
394     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
395     mockDataMigrationService.addException(exception);
396 
397     try {
398       String parent = "parent-995424086";
399       MigrationJob migrationJob = MigrationJob.newBuilder().build();
400       String migrationJobId = "migrationJobId1870575242";
401       client.createMigrationJobAsync(parent, migrationJob, migrationJobId).get();
402       Assert.fail("No exception raised");
403     } catch (ExecutionException e) {
404       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
405       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
406       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
407     }
408   }
409 
410   @Test
updateMigrationJobTest()411   public void updateMigrationJobTest() throws Exception {
412     MigrationJob expectedResponse =
413         MigrationJob.newBuilder()
414             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
415             .setCreateTime(Timestamp.newBuilder().build())
416             .setUpdateTime(Timestamp.newBuilder().build())
417             .putAllLabels(new HashMap<String, String>())
418             .setDisplayName("displayName1714148973")
419             .setDumpPath("dumpPath-2122385351")
420             .setSource("source-896505829")
421             .setDestination("destination-1429847026")
422             .setDuration(Duration.newBuilder().build())
423             .setError(Status.newBuilder().build())
424             .setSourceDatabase(DatabaseType.newBuilder().build())
425             .setDestinationDatabase(DatabaseType.newBuilder().build())
426             .setEndTime(Timestamp.newBuilder().build())
427             .build();
428     Operation resultOperation =
429         Operation.newBuilder()
430             .setName("updateMigrationJobTest")
431             .setDone(true)
432             .setResponse(Any.pack(expectedResponse))
433             .build();
434     mockDataMigrationService.addResponse(resultOperation);
435 
436     MigrationJob migrationJob = MigrationJob.newBuilder().build();
437     FieldMask updateMask = FieldMask.newBuilder().build();
438 
439     MigrationJob actualResponse = client.updateMigrationJobAsync(migrationJob, updateMask).get();
440     Assert.assertEquals(expectedResponse, actualResponse);
441 
442     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
443     Assert.assertEquals(1, actualRequests.size());
444     UpdateMigrationJobRequest actualRequest = ((UpdateMigrationJobRequest) actualRequests.get(0));
445 
446     Assert.assertEquals(migrationJob, actualRequest.getMigrationJob());
447     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
448     Assert.assertTrue(
449         channelProvider.isHeaderSent(
450             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
451             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
452   }
453 
454   @Test
updateMigrationJobExceptionTest()455   public void updateMigrationJobExceptionTest() throws Exception {
456     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
457     mockDataMigrationService.addException(exception);
458 
459     try {
460       MigrationJob migrationJob = MigrationJob.newBuilder().build();
461       FieldMask updateMask = FieldMask.newBuilder().build();
462       client.updateMigrationJobAsync(migrationJob, updateMask).get();
463       Assert.fail("No exception raised");
464     } catch (ExecutionException e) {
465       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
466       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
467       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
468     }
469   }
470 
471   @Test
deleteMigrationJobTest()472   public void deleteMigrationJobTest() throws Exception {
473     Empty expectedResponse = Empty.newBuilder().build();
474     Operation resultOperation =
475         Operation.newBuilder()
476             .setName("deleteMigrationJobTest")
477             .setDone(true)
478             .setResponse(Any.pack(expectedResponse))
479             .build();
480     mockDataMigrationService.addResponse(resultOperation);
481 
482     MigrationJobName name = MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
483 
484     client.deleteMigrationJobAsync(name).get();
485 
486     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
487     Assert.assertEquals(1, actualRequests.size());
488     DeleteMigrationJobRequest actualRequest = ((DeleteMigrationJobRequest) actualRequests.get(0));
489 
490     Assert.assertEquals(name.toString(), actualRequest.getName());
491     Assert.assertTrue(
492         channelProvider.isHeaderSent(
493             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
494             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
495   }
496 
497   @Test
deleteMigrationJobExceptionTest()498   public void deleteMigrationJobExceptionTest() throws Exception {
499     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
500     mockDataMigrationService.addException(exception);
501 
502     try {
503       MigrationJobName name = MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
504       client.deleteMigrationJobAsync(name).get();
505       Assert.fail("No exception raised");
506     } catch (ExecutionException e) {
507       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
508       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
509       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
510     }
511   }
512 
513   @Test
deleteMigrationJobTest2()514   public void deleteMigrationJobTest2() throws Exception {
515     Empty expectedResponse = Empty.newBuilder().build();
516     Operation resultOperation =
517         Operation.newBuilder()
518             .setName("deleteMigrationJobTest")
519             .setDone(true)
520             .setResponse(Any.pack(expectedResponse))
521             .build();
522     mockDataMigrationService.addResponse(resultOperation);
523 
524     String name = "name3373707";
525 
526     client.deleteMigrationJobAsync(name).get();
527 
528     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
529     Assert.assertEquals(1, actualRequests.size());
530     DeleteMigrationJobRequest actualRequest = ((DeleteMigrationJobRequest) actualRequests.get(0));
531 
532     Assert.assertEquals(name, actualRequest.getName());
533     Assert.assertTrue(
534         channelProvider.isHeaderSent(
535             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
536             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
537   }
538 
539   @Test
deleteMigrationJobExceptionTest2()540   public void deleteMigrationJobExceptionTest2() throws Exception {
541     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
542     mockDataMigrationService.addException(exception);
543 
544     try {
545       String name = "name3373707";
546       client.deleteMigrationJobAsync(name).get();
547       Assert.fail("No exception raised");
548     } catch (ExecutionException e) {
549       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
550       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
551       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
552     }
553   }
554 
555   @Test
startMigrationJobTest()556   public void startMigrationJobTest() throws Exception {
557     MigrationJob expectedResponse =
558         MigrationJob.newBuilder()
559             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
560             .setCreateTime(Timestamp.newBuilder().build())
561             .setUpdateTime(Timestamp.newBuilder().build())
562             .putAllLabels(new HashMap<String, String>())
563             .setDisplayName("displayName1714148973")
564             .setDumpPath("dumpPath-2122385351")
565             .setSource("source-896505829")
566             .setDestination("destination-1429847026")
567             .setDuration(Duration.newBuilder().build())
568             .setError(Status.newBuilder().build())
569             .setSourceDatabase(DatabaseType.newBuilder().build())
570             .setDestinationDatabase(DatabaseType.newBuilder().build())
571             .setEndTime(Timestamp.newBuilder().build())
572             .build();
573     Operation resultOperation =
574         Operation.newBuilder()
575             .setName("startMigrationJobTest")
576             .setDone(true)
577             .setResponse(Any.pack(expectedResponse))
578             .build();
579     mockDataMigrationService.addResponse(resultOperation);
580 
581     StartMigrationJobRequest request =
582         StartMigrationJobRequest.newBuilder()
583             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
584             .build();
585 
586     MigrationJob actualResponse = client.startMigrationJobAsync(request).get();
587     Assert.assertEquals(expectedResponse, actualResponse);
588 
589     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
590     Assert.assertEquals(1, actualRequests.size());
591     StartMigrationJobRequest actualRequest = ((StartMigrationJobRequest) actualRequests.get(0));
592 
593     Assert.assertEquals(request.getName(), actualRequest.getName());
594     Assert.assertTrue(
595         channelProvider.isHeaderSent(
596             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
597             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
598   }
599 
600   @Test
startMigrationJobExceptionTest()601   public void startMigrationJobExceptionTest() throws Exception {
602     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
603     mockDataMigrationService.addException(exception);
604 
605     try {
606       StartMigrationJobRequest request =
607           StartMigrationJobRequest.newBuilder()
608               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
609               .build();
610       client.startMigrationJobAsync(request).get();
611       Assert.fail("No exception raised");
612     } catch (ExecutionException e) {
613       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
614       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
615       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
616     }
617   }
618 
619   @Test
stopMigrationJobTest()620   public void stopMigrationJobTest() throws Exception {
621     MigrationJob expectedResponse =
622         MigrationJob.newBuilder()
623             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
624             .setCreateTime(Timestamp.newBuilder().build())
625             .setUpdateTime(Timestamp.newBuilder().build())
626             .putAllLabels(new HashMap<String, String>())
627             .setDisplayName("displayName1714148973")
628             .setDumpPath("dumpPath-2122385351")
629             .setSource("source-896505829")
630             .setDestination("destination-1429847026")
631             .setDuration(Duration.newBuilder().build())
632             .setError(Status.newBuilder().build())
633             .setSourceDatabase(DatabaseType.newBuilder().build())
634             .setDestinationDatabase(DatabaseType.newBuilder().build())
635             .setEndTime(Timestamp.newBuilder().build())
636             .build();
637     Operation resultOperation =
638         Operation.newBuilder()
639             .setName("stopMigrationJobTest")
640             .setDone(true)
641             .setResponse(Any.pack(expectedResponse))
642             .build();
643     mockDataMigrationService.addResponse(resultOperation);
644 
645     StopMigrationJobRequest request =
646         StopMigrationJobRequest.newBuilder()
647             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
648             .build();
649 
650     MigrationJob actualResponse = client.stopMigrationJobAsync(request).get();
651     Assert.assertEquals(expectedResponse, actualResponse);
652 
653     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
654     Assert.assertEquals(1, actualRequests.size());
655     StopMigrationJobRequest actualRequest = ((StopMigrationJobRequest) actualRequests.get(0));
656 
657     Assert.assertEquals(request.getName(), actualRequest.getName());
658     Assert.assertTrue(
659         channelProvider.isHeaderSent(
660             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
661             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
662   }
663 
664   @Test
stopMigrationJobExceptionTest()665   public void stopMigrationJobExceptionTest() throws Exception {
666     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
667     mockDataMigrationService.addException(exception);
668 
669     try {
670       StopMigrationJobRequest request =
671           StopMigrationJobRequest.newBuilder()
672               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
673               .build();
674       client.stopMigrationJobAsync(request).get();
675       Assert.fail("No exception raised");
676     } catch (ExecutionException e) {
677       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
678       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
679       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
680     }
681   }
682 
683   @Test
resumeMigrationJobTest()684   public void resumeMigrationJobTest() throws Exception {
685     MigrationJob expectedResponse =
686         MigrationJob.newBuilder()
687             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
688             .setCreateTime(Timestamp.newBuilder().build())
689             .setUpdateTime(Timestamp.newBuilder().build())
690             .putAllLabels(new HashMap<String, String>())
691             .setDisplayName("displayName1714148973")
692             .setDumpPath("dumpPath-2122385351")
693             .setSource("source-896505829")
694             .setDestination("destination-1429847026")
695             .setDuration(Duration.newBuilder().build())
696             .setError(Status.newBuilder().build())
697             .setSourceDatabase(DatabaseType.newBuilder().build())
698             .setDestinationDatabase(DatabaseType.newBuilder().build())
699             .setEndTime(Timestamp.newBuilder().build())
700             .build();
701     Operation resultOperation =
702         Operation.newBuilder()
703             .setName("resumeMigrationJobTest")
704             .setDone(true)
705             .setResponse(Any.pack(expectedResponse))
706             .build();
707     mockDataMigrationService.addResponse(resultOperation);
708 
709     ResumeMigrationJobRequest request =
710         ResumeMigrationJobRequest.newBuilder()
711             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
712             .build();
713 
714     MigrationJob actualResponse = client.resumeMigrationJobAsync(request).get();
715     Assert.assertEquals(expectedResponse, actualResponse);
716 
717     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
718     Assert.assertEquals(1, actualRequests.size());
719     ResumeMigrationJobRequest actualRequest = ((ResumeMigrationJobRequest) actualRequests.get(0));
720 
721     Assert.assertEquals(request.getName(), actualRequest.getName());
722     Assert.assertTrue(
723         channelProvider.isHeaderSent(
724             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
725             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
726   }
727 
728   @Test
resumeMigrationJobExceptionTest()729   public void resumeMigrationJobExceptionTest() throws Exception {
730     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
731     mockDataMigrationService.addException(exception);
732 
733     try {
734       ResumeMigrationJobRequest request =
735           ResumeMigrationJobRequest.newBuilder()
736               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
737               .build();
738       client.resumeMigrationJobAsync(request).get();
739       Assert.fail("No exception raised");
740     } catch (ExecutionException e) {
741       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
742       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
743       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
744     }
745   }
746 
747   @Test
promoteMigrationJobTest()748   public void promoteMigrationJobTest() throws Exception {
749     MigrationJob expectedResponse =
750         MigrationJob.newBuilder()
751             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
752             .setCreateTime(Timestamp.newBuilder().build())
753             .setUpdateTime(Timestamp.newBuilder().build())
754             .putAllLabels(new HashMap<String, String>())
755             .setDisplayName("displayName1714148973")
756             .setDumpPath("dumpPath-2122385351")
757             .setSource("source-896505829")
758             .setDestination("destination-1429847026")
759             .setDuration(Duration.newBuilder().build())
760             .setError(Status.newBuilder().build())
761             .setSourceDatabase(DatabaseType.newBuilder().build())
762             .setDestinationDatabase(DatabaseType.newBuilder().build())
763             .setEndTime(Timestamp.newBuilder().build())
764             .build();
765     Operation resultOperation =
766         Operation.newBuilder()
767             .setName("promoteMigrationJobTest")
768             .setDone(true)
769             .setResponse(Any.pack(expectedResponse))
770             .build();
771     mockDataMigrationService.addResponse(resultOperation);
772 
773     PromoteMigrationJobRequest request =
774         PromoteMigrationJobRequest.newBuilder()
775             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
776             .build();
777 
778     MigrationJob actualResponse = client.promoteMigrationJobAsync(request).get();
779     Assert.assertEquals(expectedResponse, actualResponse);
780 
781     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
782     Assert.assertEquals(1, actualRequests.size());
783     PromoteMigrationJobRequest actualRequest = ((PromoteMigrationJobRequest) actualRequests.get(0));
784 
785     Assert.assertEquals(request.getName(), actualRequest.getName());
786     Assert.assertTrue(
787         channelProvider.isHeaderSent(
788             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
789             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
790   }
791 
792   @Test
promoteMigrationJobExceptionTest()793   public void promoteMigrationJobExceptionTest() throws Exception {
794     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
795     mockDataMigrationService.addException(exception);
796 
797     try {
798       PromoteMigrationJobRequest request =
799           PromoteMigrationJobRequest.newBuilder()
800               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
801               .build();
802       client.promoteMigrationJobAsync(request).get();
803       Assert.fail("No exception raised");
804     } catch (ExecutionException e) {
805       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
806       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
807       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
808     }
809   }
810 
811   @Test
verifyMigrationJobTest()812   public void verifyMigrationJobTest() throws Exception {
813     MigrationJob expectedResponse =
814         MigrationJob.newBuilder()
815             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
816             .setCreateTime(Timestamp.newBuilder().build())
817             .setUpdateTime(Timestamp.newBuilder().build())
818             .putAllLabels(new HashMap<String, String>())
819             .setDisplayName("displayName1714148973")
820             .setDumpPath("dumpPath-2122385351")
821             .setSource("source-896505829")
822             .setDestination("destination-1429847026")
823             .setDuration(Duration.newBuilder().build())
824             .setError(Status.newBuilder().build())
825             .setSourceDatabase(DatabaseType.newBuilder().build())
826             .setDestinationDatabase(DatabaseType.newBuilder().build())
827             .setEndTime(Timestamp.newBuilder().build())
828             .build();
829     Operation resultOperation =
830         Operation.newBuilder()
831             .setName("verifyMigrationJobTest")
832             .setDone(true)
833             .setResponse(Any.pack(expectedResponse))
834             .build();
835     mockDataMigrationService.addResponse(resultOperation);
836 
837     VerifyMigrationJobRequest request =
838         VerifyMigrationJobRequest.newBuilder()
839             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
840             .build();
841 
842     MigrationJob actualResponse = client.verifyMigrationJobAsync(request).get();
843     Assert.assertEquals(expectedResponse, actualResponse);
844 
845     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
846     Assert.assertEquals(1, actualRequests.size());
847     VerifyMigrationJobRequest actualRequest = ((VerifyMigrationJobRequest) actualRequests.get(0));
848 
849     Assert.assertEquals(request.getName(), actualRequest.getName());
850     Assert.assertTrue(
851         channelProvider.isHeaderSent(
852             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
853             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
854   }
855 
856   @Test
verifyMigrationJobExceptionTest()857   public void verifyMigrationJobExceptionTest() throws Exception {
858     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
859     mockDataMigrationService.addException(exception);
860 
861     try {
862       VerifyMigrationJobRequest request =
863           VerifyMigrationJobRequest.newBuilder()
864               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
865               .build();
866       client.verifyMigrationJobAsync(request).get();
867       Assert.fail("No exception raised");
868     } catch (ExecutionException e) {
869       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
870       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
871       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
872     }
873   }
874 
875   @Test
restartMigrationJobTest()876   public void restartMigrationJobTest() throws Exception {
877     MigrationJob expectedResponse =
878         MigrationJob.newBuilder()
879             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
880             .setCreateTime(Timestamp.newBuilder().build())
881             .setUpdateTime(Timestamp.newBuilder().build())
882             .putAllLabels(new HashMap<String, String>())
883             .setDisplayName("displayName1714148973")
884             .setDumpPath("dumpPath-2122385351")
885             .setSource("source-896505829")
886             .setDestination("destination-1429847026")
887             .setDuration(Duration.newBuilder().build())
888             .setError(Status.newBuilder().build())
889             .setSourceDatabase(DatabaseType.newBuilder().build())
890             .setDestinationDatabase(DatabaseType.newBuilder().build())
891             .setEndTime(Timestamp.newBuilder().build())
892             .build();
893     Operation resultOperation =
894         Operation.newBuilder()
895             .setName("restartMigrationJobTest")
896             .setDone(true)
897             .setResponse(Any.pack(expectedResponse))
898             .build();
899     mockDataMigrationService.addResponse(resultOperation);
900 
901     RestartMigrationJobRequest request =
902         RestartMigrationJobRequest.newBuilder()
903             .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
904             .build();
905 
906     MigrationJob actualResponse = client.restartMigrationJobAsync(request).get();
907     Assert.assertEquals(expectedResponse, actualResponse);
908 
909     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
910     Assert.assertEquals(1, actualRequests.size());
911     RestartMigrationJobRequest actualRequest = ((RestartMigrationJobRequest) actualRequests.get(0));
912 
913     Assert.assertEquals(request.getName(), actualRequest.getName());
914     Assert.assertTrue(
915         channelProvider.isHeaderSent(
916             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
917             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
918   }
919 
920   @Test
restartMigrationJobExceptionTest()921   public void restartMigrationJobExceptionTest() throws Exception {
922     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
923     mockDataMigrationService.addException(exception);
924 
925     try {
926       RestartMigrationJobRequest request =
927           RestartMigrationJobRequest.newBuilder()
928               .setName(MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
929               .build();
930       client.restartMigrationJobAsync(request).get();
931       Assert.fail("No exception raised");
932     } catch (ExecutionException e) {
933       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
934       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
935       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
936     }
937   }
938 
939   @Test
generateSshScriptTest()940   public void generateSshScriptTest() throws Exception {
941     SshScript expectedResponse = SshScript.newBuilder().setScript("script-907685685").build();
942     mockDataMigrationService.addResponse(expectedResponse);
943 
944     GenerateSshScriptRequest request =
945         GenerateSshScriptRequest.newBuilder()
946             .setMigrationJob(
947                 MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
948             .setVm("vm3767")
949             .setVmPort(563010825)
950             .build();
951 
952     SshScript actualResponse = client.generateSshScript(request);
953     Assert.assertEquals(expectedResponse, actualResponse);
954 
955     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
956     Assert.assertEquals(1, actualRequests.size());
957     GenerateSshScriptRequest actualRequest = ((GenerateSshScriptRequest) actualRequests.get(0));
958 
959     Assert.assertEquals(request.getMigrationJob(), actualRequest.getMigrationJob());
960     Assert.assertEquals(request.getVm(), actualRequest.getVm());
961     Assert.assertEquals(request.getVmCreationConfig(), actualRequest.getVmCreationConfig());
962     Assert.assertEquals(request.getVmSelectionConfig(), actualRequest.getVmSelectionConfig());
963     Assert.assertEquals(request.getVmPort(), actualRequest.getVmPort());
964     Assert.assertTrue(
965         channelProvider.isHeaderSent(
966             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
967             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
968   }
969 
970   @Test
generateSshScriptExceptionTest()971   public void generateSshScriptExceptionTest() throws Exception {
972     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
973     mockDataMigrationService.addException(exception);
974 
975     try {
976       GenerateSshScriptRequest request =
977           GenerateSshScriptRequest.newBuilder()
978               .setMigrationJob(
979                   MigrationJobName.of("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]").toString())
980               .setVm("vm3767")
981               .setVmPort(563010825)
982               .build();
983       client.generateSshScript(request);
984       Assert.fail("No exception raised");
985     } catch (InvalidArgumentException e) {
986       // Expected exception.
987     }
988   }
989 
990   @Test
listConnectionProfilesTest()991   public void listConnectionProfilesTest() throws Exception {
992     ConnectionProfile responsesElement = ConnectionProfile.newBuilder().build();
993     ListConnectionProfilesResponse expectedResponse =
994         ListConnectionProfilesResponse.newBuilder()
995             .setNextPageToken("")
996             .addAllConnectionProfiles(Arrays.asList(responsesElement))
997             .build();
998     mockDataMigrationService.addResponse(expectedResponse);
999 
1000     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1001 
1002     ListConnectionProfilesPagedResponse pagedListResponse = client.listConnectionProfiles(parent);
1003 
1004     List<ConnectionProfile> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1005 
1006     Assert.assertEquals(1, resources.size());
1007     Assert.assertEquals(expectedResponse.getConnectionProfilesList().get(0), resources.get(0));
1008 
1009     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1010     Assert.assertEquals(1, actualRequests.size());
1011     ListConnectionProfilesRequest actualRequest =
1012         ((ListConnectionProfilesRequest) actualRequests.get(0));
1013 
1014     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1015     Assert.assertTrue(
1016         channelProvider.isHeaderSent(
1017             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1018             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1019   }
1020 
1021   @Test
listConnectionProfilesExceptionTest()1022   public void listConnectionProfilesExceptionTest() throws Exception {
1023     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1024     mockDataMigrationService.addException(exception);
1025 
1026     try {
1027       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1028       client.listConnectionProfiles(parent);
1029       Assert.fail("No exception raised");
1030     } catch (InvalidArgumentException e) {
1031       // Expected exception.
1032     }
1033   }
1034 
1035   @Test
listConnectionProfilesTest2()1036   public void listConnectionProfilesTest2() throws Exception {
1037     ConnectionProfile responsesElement = ConnectionProfile.newBuilder().build();
1038     ListConnectionProfilesResponse expectedResponse =
1039         ListConnectionProfilesResponse.newBuilder()
1040             .setNextPageToken("")
1041             .addAllConnectionProfiles(Arrays.asList(responsesElement))
1042             .build();
1043     mockDataMigrationService.addResponse(expectedResponse);
1044 
1045     String parent = "parent-995424086";
1046 
1047     ListConnectionProfilesPagedResponse pagedListResponse = client.listConnectionProfiles(parent);
1048 
1049     List<ConnectionProfile> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1050 
1051     Assert.assertEquals(1, resources.size());
1052     Assert.assertEquals(expectedResponse.getConnectionProfilesList().get(0), resources.get(0));
1053 
1054     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1055     Assert.assertEquals(1, actualRequests.size());
1056     ListConnectionProfilesRequest actualRequest =
1057         ((ListConnectionProfilesRequest) actualRequests.get(0));
1058 
1059     Assert.assertEquals(parent, actualRequest.getParent());
1060     Assert.assertTrue(
1061         channelProvider.isHeaderSent(
1062             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1063             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1064   }
1065 
1066   @Test
listConnectionProfilesExceptionTest2()1067   public void listConnectionProfilesExceptionTest2() throws Exception {
1068     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1069     mockDataMigrationService.addException(exception);
1070 
1071     try {
1072       String parent = "parent-995424086";
1073       client.listConnectionProfiles(parent);
1074       Assert.fail("No exception raised");
1075     } catch (InvalidArgumentException e) {
1076       // Expected exception.
1077     }
1078   }
1079 
1080   @Test
getConnectionProfileTest()1081   public void getConnectionProfileTest() throws Exception {
1082     ConnectionProfile expectedResponse =
1083         ConnectionProfile.newBuilder()
1084             .setName(
1085                 ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]")
1086                     .toString())
1087             .setCreateTime(Timestamp.newBuilder().build())
1088             .setUpdateTime(Timestamp.newBuilder().build())
1089             .putAllLabels(new HashMap<String, String>())
1090             .setDisplayName("displayName1714148973")
1091             .setError(Status.newBuilder().build())
1092             .setProvider(DatabaseProvider.forNumber(0))
1093             .build();
1094     mockDataMigrationService.addResponse(expectedResponse);
1095 
1096     ConnectionProfileName name =
1097         ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1098 
1099     ConnectionProfile actualResponse = client.getConnectionProfile(name);
1100     Assert.assertEquals(expectedResponse, actualResponse);
1101 
1102     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1103     Assert.assertEquals(1, actualRequests.size());
1104     GetConnectionProfileRequest actualRequest =
1105         ((GetConnectionProfileRequest) actualRequests.get(0));
1106 
1107     Assert.assertEquals(name.toString(), actualRequest.getName());
1108     Assert.assertTrue(
1109         channelProvider.isHeaderSent(
1110             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1111             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1112   }
1113 
1114   @Test
getConnectionProfileExceptionTest()1115   public void getConnectionProfileExceptionTest() throws Exception {
1116     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1117     mockDataMigrationService.addException(exception);
1118 
1119     try {
1120       ConnectionProfileName name =
1121           ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1122       client.getConnectionProfile(name);
1123       Assert.fail("No exception raised");
1124     } catch (InvalidArgumentException e) {
1125       // Expected exception.
1126     }
1127   }
1128 
1129   @Test
getConnectionProfileTest2()1130   public void getConnectionProfileTest2() throws Exception {
1131     ConnectionProfile expectedResponse =
1132         ConnectionProfile.newBuilder()
1133             .setName(
1134                 ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]")
1135                     .toString())
1136             .setCreateTime(Timestamp.newBuilder().build())
1137             .setUpdateTime(Timestamp.newBuilder().build())
1138             .putAllLabels(new HashMap<String, String>())
1139             .setDisplayName("displayName1714148973")
1140             .setError(Status.newBuilder().build())
1141             .setProvider(DatabaseProvider.forNumber(0))
1142             .build();
1143     mockDataMigrationService.addResponse(expectedResponse);
1144 
1145     String name = "name3373707";
1146 
1147     ConnectionProfile actualResponse = client.getConnectionProfile(name);
1148     Assert.assertEquals(expectedResponse, actualResponse);
1149 
1150     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1151     Assert.assertEquals(1, actualRequests.size());
1152     GetConnectionProfileRequest actualRequest =
1153         ((GetConnectionProfileRequest) actualRequests.get(0));
1154 
1155     Assert.assertEquals(name, actualRequest.getName());
1156     Assert.assertTrue(
1157         channelProvider.isHeaderSent(
1158             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1159             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1160   }
1161 
1162   @Test
getConnectionProfileExceptionTest2()1163   public void getConnectionProfileExceptionTest2() throws Exception {
1164     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1165     mockDataMigrationService.addException(exception);
1166 
1167     try {
1168       String name = "name3373707";
1169       client.getConnectionProfile(name);
1170       Assert.fail("No exception raised");
1171     } catch (InvalidArgumentException e) {
1172       // Expected exception.
1173     }
1174   }
1175 
1176   @Test
createConnectionProfileTest()1177   public void createConnectionProfileTest() throws Exception {
1178     ConnectionProfile expectedResponse =
1179         ConnectionProfile.newBuilder()
1180             .setName(
1181                 ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]")
1182                     .toString())
1183             .setCreateTime(Timestamp.newBuilder().build())
1184             .setUpdateTime(Timestamp.newBuilder().build())
1185             .putAllLabels(new HashMap<String, String>())
1186             .setDisplayName("displayName1714148973")
1187             .setError(Status.newBuilder().build())
1188             .setProvider(DatabaseProvider.forNumber(0))
1189             .build();
1190     Operation resultOperation =
1191         Operation.newBuilder()
1192             .setName("createConnectionProfileTest")
1193             .setDone(true)
1194             .setResponse(Any.pack(expectedResponse))
1195             .build();
1196     mockDataMigrationService.addResponse(resultOperation);
1197 
1198     ConnectionProfileName parent =
1199         ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1200     ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1201     String connectionProfileId = "connectionProfileId597575526";
1202 
1203     ConnectionProfile actualResponse =
1204         client.createConnectionProfileAsync(parent, connectionProfile, connectionProfileId).get();
1205     Assert.assertEquals(expectedResponse, actualResponse);
1206 
1207     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1208     Assert.assertEquals(1, actualRequests.size());
1209     CreateConnectionProfileRequest actualRequest =
1210         ((CreateConnectionProfileRequest) actualRequests.get(0));
1211 
1212     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1213     Assert.assertEquals(connectionProfile, actualRequest.getConnectionProfile());
1214     Assert.assertEquals(connectionProfileId, actualRequest.getConnectionProfileId());
1215     Assert.assertTrue(
1216         channelProvider.isHeaderSent(
1217             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1218             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1219   }
1220 
1221   @Test
createConnectionProfileExceptionTest()1222   public void createConnectionProfileExceptionTest() throws Exception {
1223     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1224     mockDataMigrationService.addException(exception);
1225 
1226     try {
1227       ConnectionProfileName parent =
1228           ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1229       ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1230       String connectionProfileId = "connectionProfileId597575526";
1231       client.createConnectionProfileAsync(parent, connectionProfile, connectionProfileId).get();
1232       Assert.fail("No exception raised");
1233     } catch (ExecutionException e) {
1234       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1235       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1236       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1237     }
1238   }
1239 
1240   @Test
createConnectionProfileTest2()1241   public void createConnectionProfileTest2() throws Exception {
1242     ConnectionProfile expectedResponse =
1243         ConnectionProfile.newBuilder()
1244             .setName(
1245                 ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]")
1246                     .toString())
1247             .setCreateTime(Timestamp.newBuilder().build())
1248             .setUpdateTime(Timestamp.newBuilder().build())
1249             .putAllLabels(new HashMap<String, String>())
1250             .setDisplayName("displayName1714148973")
1251             .setError(Status.newBuilder().build())
1252             .setProvider(DatabaseProvider.forNumber(0))
1253             .build();
1254     Operation resultOperation =
1255         Operation.newBuilder()
1256             .setName("createConnectionProfileTest")
1257             .setDone(true)
1258             .setResponse(Any.pack(expectedResponse))
1259             .build();
1260     mockDataMigrationService.addResponse(resultOperation);
1261 
1262     String parent = "parent-995424086";
1263     ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1264     String connectionProfileId = "connectionProfileId597575526";
1265 
1266     ConnectionProfile actualResponse =
1267         client.createConnectionProfileAsync(parent, connectionProfile, connectionProfileId).get();
1268     Assert.assertEquals(expectedResponse, actualResponse);
1269 
1270     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1271     Assert.assertEquals(1, actualRequests.size());
1272     CreateConnectionProfileRequest actualRequest =
1273         ((CreateConnectionProfileRequest) actualRequests.get(0));
1274 
1275     Assert.assertEquals(parent, actualRequest.getParent());
1276     Assert.assertEquals(connectionProfile, actualRequest.getConnectionProfile());
1277     Assert.assertEquals(connectionProfileId, actualRequest.getConnectionProfileId());
1278     Assert.assertTrue(
1279         channelProvider.isHeaderSent(
1280             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1281             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1282   }
1283 
1284   @Test
createConnectionProfileExceptionTest2()1285   public void createConnectionProfileExceptionTest2() throws Exception {
1286     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1287     mockDataMigrationService.addException(exception);
1288 
1289     try {
1290       String parent = "parent-995424086";
1291       ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1292       String connectionProfileId = "connectionProfileId597575526";
1293       client.createConnectionProfileAsync(parent, connectionProfile, connectionProfileId).get();
1294       Assert.fail("No exception raised");
1295     } catch (ExecutionException e) {
1296       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1297       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1298       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1299     }
1300   }
1301 
1302   @Test
updateConnectionProfileTest()1303   public void updateConnectionProfileTest() throws Exception {
1304     ConnectionProfile expectedResponse =
1305         ConnectionProfile.newBuilder()
1306             .setName(
1307                 ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]")
1308                     .toString())
1309             .setCreateTime(Timestamp.newBuilder().build())
1310             .setUpdateTime(Timestamp.newBuilder().build())
1311             .putAllLabels(new HashMap<String, String>())
1312             .setDisplayName("displayName1714148973")
1313             .setError(Status.newBuilder().build())
1314             .setProvider(DatabaseProvider.forNumber(0))
1315             .build();
1316     Operation resultOperation =
1317         Operation.newBuilder()
1318             .setName("updateConnectionProfileTest")
1319             .setDone(true)
1320             .setResponse(Any.pack(expectedResponse))
1321             .build();
1322     mockDataMigrationService.addResponse(resultOperation);
1323 
1324     ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1325     FieldMask updateMask = FieldMask.newBuilder().build();
1326 
1327     ConnectionProfile actualResponse =
1328         client.updateConnectionProfileAsync(connectionProfile, updateMask).get();
1329     Assert.assertEquals(expectedResponse, actualResponse);
1330 
1331     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1332     Assert.assertEquals(1, actualRequests.size());
1333     UpdateConnectionProfileRequest actualRequest =
1334         ((UpdateConnectionProfileRequest) actualRequests.get(0));
1335 
1336     Assert.assertEquals(connectionProfile, actualRequest.getConnectionProfile());
1337     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1338     Assert.assertTrue(
1339         channelProvider.isHeaderSent(
1340             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1341             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1342   }
1343 
1344   @Test
updateConnectionProfileExceptionTest()1345   public void updateConnectionProfileExceptionTest() throws Exception {
1346     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1347     mockDataMigrationService.addException(exception);
1348 
1349     try {
1350       ConnectionProfile connectionProfile = ConnectionProfile.newBuilder().build();
1351       FieldMask updateMask = FieldMask.newBuilder().build();
1352       client.updateConnectionProfileAsync(connectionProfile, updateMask).get();
1353       Assert.fail("No exception raised");
1354     } catch (ExecutionException e) {
1355       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1356       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1357       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1358     }
1359   }
1360 
1361   @Test
deleteConnectionProfileTest()1362   public void deleteConnectionProfileTest() throws Exception {
1363     Empty expectedResponse = Empty.newBuilder().build();
1364     Operation resultOperation =
1365         Operation.newBuilder()
1366             .setName("deleteConnectionProfileTest")
1367             .setDone(true)
1368             .setResponse(Any.pack(expectedResponse))
1369             .build();
1370     mockDataMigrationService.addResponse(resultOperation);
1371 
1372     ConnectionProfileName name =
1373         ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1374 
1375     client.deleteConnectionProfileAsync(name).get();
1376 
1377     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1378     Assert.assertEquals(1, actualRequests.size());
1379     DeleteConnectionProfileRequest actualRequest =
1380         ((DeleteConnectionProfileRequest) actualRequests.get(0));
1381 
1382     Assert.assertEquals(name.toString(), actualRequest.getName());
1383     Assert.assertTrue(
1384         channelProvider.isHeaderSent(
1385             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1386             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1387   }
1388 
1389   @Test
deleteConnectionProfileExceptionTest()1390   public void deleteConnectionProfileExceptionTest() throws Exception {
1391     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1392     mockDataMigrationService.addException(exception);
1393 
1394     try {
1395       ConnectionProfileName name =
1396           ConnectionProfileName.of("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
1397       client.deleteConnectionProfileAsync(name).get();
1398       Assert.fail("No exception raised");
1399     } catch (ExecutionException e) {
1400       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1401       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1402       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1403     }
1404   }
1405 
1406   @Test
deleteConnectionProfileTest2()1407   public void deleteConnectionProfileTest2() throws Exception {
1408     Empty expectedResponse = Empty.newBuilder().build();
1409     Operation resultOperation =
1410         Operation.newBuilder()
1411             .setName("deleteConnectionProfileTest")
1412             .setDone(true)
1413             .setResponse(Any.pack(expectedResponse))
1414             .build();
1415     mockDataMigrationService.addResponse(resultOperation);
1416 
1417     String name = "name3373707";
1418 
1419     client.deleteConnectionProfileAsync(name).get();
1420 
1421     List<AbstractMessage> actualRequests = mockDataMigrationService.getRequests();
1422     Assert.assertEquals(1, actualRequests.size());
1423     DeleteConnectionProfileRequest actualRequest =
1424         ((DeleteConnectionProfileRequest) actualRequests.get(0));
1425 
1426     Assert.assertEquals(name, actualRequest.getName());
1427     Assert.assertTrue(
1428         channelProvider.isHeaderSent(
1429             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1430             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1431   }
1432 
1433   @Test
deleteConnectionProfileExceptionTest2()1434   public void deleteConnectionProfileExceptionTest2() throws Exception {
1435     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1436     mockDataMigrationService.addException(exception);
1437 
1438     try {
1439       String name = "name3373707";
1440       client.deleteConnectionProfileAsync(name).get();
1441       Assert.fail("No exception raised");
1442     } catch (ExecutionException e) {
1443       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1444       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1445       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1446     }
1447   }
1448 }
1449