• 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.automl.v1;
18 
19 import static com.google.cloud.automl.v1.AutoMlClient.ListDatasetsPagedResponse;
20 import static com.google.cloud.automl.v1.AutoMlClient.ListModelEvaluationsPagedResponse;
21 import static com.google.cloud.automl.v1.AutoMlClient.ListModelsPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.grpc.GaxGrpcProperties;
25 import com.google.api.gax.grpc.testing.LocalChannelProvider;
26 import com.google.api.gax.grpc.testing.MockGrpcService;
27 import com.google.api.gax.grpc.testing.MockServiceHelper;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.common.collect.Lists;
32 import com.google.longrunning.Operation;
33 import com.google.protobuf.AbstractMessage;
34 import com.google.protobuf.Any;
35 import com.google.protobuf.Empty;
36 import com.google.protobuf.FieldMask;
37 import com.google.protobuf.Timestamp;
38 import io.grpc.StatusRuntimeException;
39 import java.io.IOException;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.List;
43 import java.util.UUID;
44 import java.util.concurrent.ExecutionException;
45 import javax.annotation.Generated;
46 import org.junit.After;
47 import org.junit.AfterClass;
48 import org.junit.Assert;
49 import org.junit.Before;
50 import org.junit.BeforeClass;
51 import org.junit.Test;
52 
53 @Generated("by gapic-generator-java")
54 public class AutoMlClientTest {
55   private static MockAutoMl mockAutoMl;
56   private static MockServiceHelper mockServiceHelper;
57   private LocalChannelProvider channelProvider;
58   private AutoMlClient client;
59 
60   @BeforeClass
startStaticServer()61   public static void startStaticServer() {
62     mockAutoMl = new MockAutoMl();
63     mockServiceHelper =
64         new MockServiceHelper(
65             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockAutoMl));
66     mockServiceHelper.start();
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     mockServiceHelper.stop();
72   }
73 
74   @Before
setUp()75   public void setUp() throws IOException {
76     mockServiceHelper.reset();
77     channelProvider = mockServiceHelper.createChannelProvider();
78     AutoMlSettings settings =
79         AutoMlSettings.newBuilder()
80             .setTransportChannelProvider(channelProvider)
81             .setCredentialsProvider(NoCredentialsProvider.create())
82             .build();
83     client = AutoMlClient.create(settings);
84   }
85 
86   @After
tearDown()87   public void tearDown() throws Exception {
88     client.close();
89   }
90 
91   @Test
createDatasetTest()92   public void createDatasetTest() throws Exception {
93     Dataset expectedResponse =
94         Dataset.newBuilder()
95             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
96             .setDisplayName("displayName1714148973")
97             .setDescription("description-1724546052")
98             .setExampleCount(1517063674)
99             .setCreateTime(Timestamp.newBuilder().build())
100             .setEtag("etag3123477")
101             .putAllLabels(new HashMap<String, String>())
102             .build();
103     Operation resultOperation =
104         Operation.newBuilder()
105             .setName("createDatasetTest")
106             .setDone(true)
107             .setResponse(Any.pack(expectedResponse))
108             .build();
109     mockAutoMl.addResponse(resultOperation);
110 
111     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
112     Dataset dataset = Dataset.newBuilder().build();
113 
114     Dataset actualResponse = client.createDatasetAsync(parent, dataset).get();
115     Assert.assertEquals(expectedResponse, actualResponse);
116 
117     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
118     Assert.assertEquals(1, actualRequests.size());
119     CreateDatasetRequest actualRequest = ((CreateDatasetRequest) actualRequests.get(0));
120 
121     Assert.assertEquals(parent.toString(), actualRequest.getParent());
122     Assert.assertEquals(dataset, actualRequest.getDataset());
123     Assert.assertTrue(
124         channelProvider.isHeaderSent(
125             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
126             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
127   }
128 
129   @Test
createDatasetExceptionTest()130   public void createDatasetExceptionTest() throws Exception {
131     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
132     mockAutoMl.addException(exception);
133 
134     try {
135       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
136       Dataset dataset = Dataset.newBuilder().build();
137       client.createDatasetAsync(parent, dataset).get();
138       Assert.fail("No exception raised");
139     } catch (ExecutionException e) {
140       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
141       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
142       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
143     }
144   }
145 
146   @Test
createDatasetTest2()147   public void createDatasetTest2() throws Exception {
148     Dataset expectedResponse =
149         Dataset.newBuilder()
150             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
151             .setDisplayName("displayName1714148973")
152             .setDescription("description-1724546052")
153             .setExampleCount(1517063674)
154             .setCreateTime(Timestamp.newBuilder().build())
155             .setEtag("etag3123477")
156             .putAllLabels(new HashMap<String, String>())
157             .build();
158     Operation resultOperation =
159         Operation.newBuilder()
160             .setName("createDatasetTest")
161             .setDone(true)
162             .setResponse(Any.pack(expectedResponse))
163             .build();
164     mockAutoMl.addResponse(resultOperation);
165 
166     String parent = "parent-995424086";
167     Dataset dataset = Dataset.newBuilder().build();
168 
169     Dataset actualResponse = client.createDatasetAsync(parent, dataset).get();
170     Assert.assertEquals(expectedResponse, actualResponse);
171 
172     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
173     Assert.assertEquals(1, actualRequests.size());
174     CreateDatasetRequest actualRequest = ((CreateDatasetRequest) actualRequests.get(0));
175 
176     Assert.assertEquals(parent, actualRequest.getParent());
177     Assert.assertEquals(dataset, actualRequest.getDataset());
178     Assert.assertTrue(
179         channelProvider.isHeaderSent(
180             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
181             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
182   }
183 
184   @Test
createDatasetExceptionTest2()185   public void createDatasetExceptionTest2() throws Exception {
186     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
187     mockAutoMl.addException(exception);
188 
189     try {
190       String parent = "parent-995424086";
191       Dataset dataset = Dataset.newBuilder().build();
192       client.createDatasetAsync(parent, dataset).get();
193       Assert.fail("No exception raised");
194     } catch (ExecutionException e) {
195       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
196       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
197       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
198     }
199   }
200 
201   @Test
getDatasetTest()202   public void getDatasetTest() throws Exception {
203     Dataset expectedResponse =
204         Dataset.newBuilder()
205             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
206             .setDisplayName("displayName1714148973")
207             .setDescription("description-1724546052")
208             .setExampleCount(1517063674)
209             .setCreateTime(Timestamp.newBuilder().build())
210             .setEtag("etag3123477")
211             .putAllLabels(new HashMap<String, String>())
212             .build();
213     mockAutoMl.addResponse(expectedResponse);
214 
215     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
216 
217     Dataset actualResponse = client.getDataset(name);
218     Assert.assertEquals(expectedResponse, actualResponse);
219 
220     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
221     Assert.assertEquals(1, actualRequests.size());
222     GetDatasetRequest actualRequest = ((GetDatasetRequest) actualRequests.get(0));
223 
224     Assert.assertEquals(name.toString(), actualRequest.getName());
225     Assert.assertTrue(
226         channelProvider.isHeaderSent(
227             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
228             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
229   }
230 
231   @Test
getDatasetExceptionTest()232   public void getDatasetExceptionTest() throws Exception {
233     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
234     mockAutoMl.addException(exception);
235 
236     try {
237       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
238       client.getDataset(name);
239       Assert.fail("No exception raised");
240     } catch (InvalidArgumentException e) {
241       // Expected exception.
242     }
243   }
244 
245   @Test
getDatasetTest2()246   public void getDatasetTest2() throws Exception {
247     Dataset expectedResponse =
248         Dataset.newBuilder()
249             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
250             .setDisplayName("displayName1714148973")
251             .setDescription("description-1724546052")
252             .setExampleCount(1517063674)
253             .setCreateTime(Timestamp.newBuilder().build())
254             .setEtag("etag3123477")
255             .putAllLabels(new HashMap<String, String>())
256             .build();
257     mockAutoMl.addResponse(expectedResponse);
258 
259     String name = "name3373707";
260 
261     Dataset actualResponse = client.getDataset(name);
262     Assert.assertEquals(expectedResponse, actualResponse);
263 
264     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
265     Assert.assertEquals(1, actualRequests.size());
266     GetDatasetRequest actualRequest = ((GetDatasetRequest) actualRequests.get(0));
267 
268     Assert.assertEquals(name, actualRequest.getName());
269     Assert.assertTrue(
270         channelProvider.isHeaderSent(
271             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
272             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
273   }
274 
275   @Test
getDatasetExceptionTest2()276   public void getDatasetExceptionTest2() throws Exception {
277     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
278     mockAutoMl.addException(exception);
279 
280     try {
281       String name = "name3373707";
282       client.getDataset(name);
283       Assert.fail("No exception raised");
284     } catch (InvalidArgumentException e) {
285       // Expected exception.
286     }
287   }
288 
289   @Test
listDatasetsTest()290   public void listDatasetsTest() throws Exception {
291     Dataset responsesElement = Dataset.newBuilder().build();
292     ListDatasetsResponse expectedResponse =
293         ListDatasetsResponse.newBuilder()
294             .setNextPageToken("")
295             .addAllDatasets(Arrays.asList(responsesElement))
296             .build();
297     mockAutoMl.addResponse(expectedResponse);
298 
299     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
300 
301     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
302 
303     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
304 
305     Assert.assertEquals(1, resources.size());
306     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
307 
308     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
309     Assert.assertEquals(1, actualRequests.size());
310     ListDatasetsRequest actualRequest = ((ListDatasetsRequest) actualRequests.get(0));
311 
312     Assert.assertEquals(parent.toString(), actualRequest.getParent());
313     Assert.assertTrue(
314         channelProvider.isHeaderSent(
315             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
316             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
317   }
318 
319   @Test
listDatasetsExceptionTest()320   public void listDatasetsExceptionTest() throws Exception {
321     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
322     mockAutoMl.addException(exception);
323 
324     try {
325       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
326       client.listDatasets(parent);
327       Assert.fail("No exception raised");
328     } catch (InvalidArgumentException e) {
329       // Expected exception.
330     }
331   }
332 
333   @Test
listDatasetsTest2()334   public void listDatasetsTest2() throws Exception {
335     Dataset responsesElement = Dataset.newBuilder().build();
336     ListDatasetsResponse expectedResponse =
337         ListDatasetsResponse.newBuilder()
338             .setNextPageToken("")
339             .addAllDatasets(Arrays.asList(responsesElement))
340             .build();
341     mockAutoMl.addResponse(expectedResponse);
342 
343     String parent = "parent-995424086";
344 
345     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
346 
347     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
348 
349     Assert.assertEquals(1, resources.size());
350     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
351 
352     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
353     Assert.assertEquals(1, actualRequests.size());
354     ListDatasetsRequest actualRequest = ((ListDatasetsRequest) actualRequests.get(0));
355 
356     Assert.assertEquals(parent, actualRequest.getParent());
357     Assert.assertTrue(
358         channelProvider.isHeaderSent(
359             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
360             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
361   }
362 
363   @Test
listDatasetsExceptionTest2()364   public void listDatasetsExceptionTest2() throws Exception {
365     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
366     mockAutoMl.addException(exception);
367 
368     try {
369       String parent = "parent-995424086";
370       client.listDatasets(parent);
371       Assert.fail("No exception raised");
372     } catch (InvalidArgumentException e) {
373       // Expected exception.
374     }
375   }
376 
377   @Test
updateDatasetTest()378   public void updateDatasetTest() throws Exception {
379     Dataset expectedResponse =
380         Dataset.newBuilder()
381             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
382             .setDisplayName("displayName1714148973")
383             .setDescription("description-1724546052")
384             .setExampleCount(1517063674)
385             .setCreateTime(Timestamp.newBuilder().build())
386             .setEtag("etag3123477")
387             .putAllLabels(new HashMap<String, String>())
388             .build();
389     mockAutoMl.addResponse(expectedResponse);
390 
391     Dataset dataset = Dataset.newBuilder().build();
392     FieldMask updateMask = FieldMask.newBuilder().build();
393 
394     Dataset actualResponse = client.updateDataset(dataset, updateMask);
395     Assert.assertEquals(expectedResponse, actualResponse);
396 
397     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
398     Assert.assertEquals(1, actualRequests.size());
399     UpdateDatasetRequest actualRequest = ((UpdateDatasetRequest) actualRequests.get(0));
400 
401     Assert.assertEquals(dataset, actualRequest.getDataset());
402     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
403     Assert.assertTrue(
404         channelProvider.isHeaderSent(
405             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
406             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
407   }
408 
409   @Test
updateDatasetExceptionTest()410   public void updateDatasetExceptionTest() throws Exception {
411     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
412     mockAutoMl.addException(exception);
413 
414     try {
415       Dataset dataset = Dataset.newBuilder().build();
416       FieldMask updateMask = FieldMask.newBuilder().build();
417       client.updateDataset(dataset, updateMask);
418       Assert.fail("No exception raised");
419     } catch (InvalidArgumentException e) {
420       // Expected exception.
421     }
422   }
423 
424   @Test
deleteDatasetTest()425   public void deleteDatasetTest() throws Exception {
426     Empty expectedResponse = Empty.newBuilder().build();
427     Operation resultOperation =
428         Operation.newBuilder()
429             .setName("deleteDatasetTest")
430             .setDone(true)
431             .setResponse(Any.pack(expectedResponse))
432             .build();
433     mockAutoMl.addResponse(resultOperation);
434 
435     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
436 
437     client.deleteDatasetAsync(name).get();
438 
439     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
440     Assert.assertEquals(1, actualRequests.size());
441     DeleteDatasetRequest actualRequest = ((DeleteDatasetRequest) actualRequests.get(0));
442 
443     Assert.assertEquals(name.toString(), actualRequest.getName());
444     Assert.assertTrue(
445         channelProvider.isHeaderSent(
446             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
447             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
448   }
449 
450   @Test
deleteDatasetExceptionTest()451   public void deleteDatasetExceptionTest() throws Exception {
452     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
453     mockAutoMl.addException(exception);
454 
455     try {
456       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
457       client.deleteDatasetAsync(name).get();
458       Assert.fail("No exception raised");
459     } catch (ExecutionException e) {
460       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
461       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
462       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
463     }
464   }
465 
466   @Test
deleteDatasetTest2()467   public void deleteDatasetTest2() throws Exception {
468     Empty expectedResponse = Empty.newBuilder().build();
469     Operation resultOperation =
470         Operation.newBuilder()
471             .setName("deleteDatasetTest")
472             .setDone(true)
473             .setResponse(Any.pack(expectedResponse))
474             .build();
475     mockAutoMl.addResponse(resultOperation);
476 
477     String name = "name3373707";
478 
479     client.deleteDatasetAsync(name).get();
480 
481     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
482     Assert.assertEquals(1, actualRequests.size());
483     DeleteDatasetRequest actualRequest = ((DeleteDatasetRequest) actualRequests.get(0));
484 
485     Assert.assertEquals(name, actualRequest.getName());
486     Assert.assertTrue(
487         channelProvider.isHeaderSent(
488             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
489             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
490   }
491 
492   @Test
deleteDatasetExceptionTest2()493   public void deleteDatasetExceptionTest2() throws Exception {
494     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
495     mockAutoMl.addException(exception);
496 
497     try {
498       String name = "name3373707";
499       client.deleteDatasetAsync(name).get();
500       Assert.fail("No exception raised");
501     } catch (ExecutionException e) {
502       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
503       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
504       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
505     }
506   }
507 
508   @Test
importDataTest()509   public void importDataTest() throws Exception {
510     Empty expectedResponse = Empty.newBuilder().build();
511     Operation resultOperation =
512         Operation.newBuilder()
513             .setName("importDataTest")
514             .setDone(true)
515             .setResponse(Any.pack(expectedResponse))
516             .build();
517     mockAutoMl.addResponse(resultOperation);
518 
519     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
520     InputConfig inputConfig = InputConfig.newBuilder().build();
521 
522     client.importDataAsync(name, inputConfig).get();
523 
524     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
525     Assert.assertEquals(1, actualRequests.size());
526     ImportDataRequest actualRequest = ((ImportDataRequest) actualRequests.get(0));
527 
528     Assert.assertEquals(name.toString(), actualRequest.getName());
529     Assert.assertEquals(inputConfig, actualRequest.getInputConfig());
530     Assert.assertTrue(
531         channelProvider.isHeaderSent(
532             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
533             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
534   }
535 
536   @Test
importDataExceptionTest()537   public void importDataExceptionTest() throws Exception {
538     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
539     mockAutoMl.addException(exception);
540 
541     try {
542       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
543       InputConfig inputConfig = InputConfig.newBuilder().build();
544       client.importDataAsync(name, inputConfig).get();
545       Assert.fail("No exception raised");
546     } catch (ExecutionException e) {
547       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
548       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
549       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
550     }
551   }
552 
553   @Test
importDataTest2()554   public void importDataTest2() throws Exception {
555     Empty expectedResponse = Empty.newBuilder().build();
556     Operation resultOperation =
557         Operation.newBuilder()
558             .setName("importDataTest")
559             .setDone(true)
560             .setResponse(Any.pack(expectedResponse))
561             .build();
562     mockAutoMl.addResponse(resultOperation);
563 
564     String name = "name3373707";
565     InputConfig inputConfig = InputConfig.newBuilder().build();
566 
567     client.importDataAsync(name, inputConfig).get();
568 
569     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
570     Assert.assertEquals(1, actualRequests.size());
571     ImportDataRequest actualRequest = ((ImportDataRequest) actualRequests.get(0));
572 
573     Assert.assertEquals(name, actualRequest.getName());
574     Assert.assertEquals(inputConfig, actualRequest.getInputConfig());
575     Assert.assertTrue(
576         channelProvider.isHeaderSent(
577             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
578             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
579   }
580 
581   @Test
importDataExceptionTest2()582   public void importDataExceptionTest2() throws Exception {
583     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
584     mockAutoMl.addException(exception);
585 
586     try {
587       String name = "name3373707";
588       InputConfig inputConfig = InputConfig.newBuilder().build();
589       client.importDataAsync(name, inputConfig).get();
590       Assert.fail("No exception raised");
591     } catch (ExecutionException e) {
592       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
593       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
594       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
595     }
596   }
597 
598   @Test
exportDataTest()599   public void exportDataTest() throws Exception {
600     Empty expectedResponse = Empty.newBuilder().build();
601     Operation resultOperation =
602         Operation.newBuilder()
603             .setName("exportDataTest")
604             .setDone(true)
605             .setResponse(Any.pack(expectedResponse))
606             .build();
607     mockAutoMl.addResponse(resultOperation);
608 
609     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
610     OutputConfig outputConfig = OutputConfig.newBuilder().build();
611 
612     client.exportDataAsync(name, outputConfig).get();
613 
614     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
615     Assert.assertEquals(1, actualRequests.size());
616     ExportDataRequest actualRequest = ((ExportDataRequest) actualRequests.get(0));
617 
618     Assert.assertEquals(name.toString(), actualRequest.getName());
619     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
620     Assert.assertTrue(
621         channelProvider.isHeaderSent(
622             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
623             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
624   }
625 
626   @Test
exportDataExceptionTest()627   public void exportDataExceptionTest() throws Exception {
628     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
629     mockAutoMl.addException(exception);
630 
631     try {
632       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
633       OutputConfig outputConfig = OutputConfig.newBuilder().build();
634       client.exportDataAsync(name, outputConfig).get();
635       Assert.fail("No exception raised");
636     } catch (ExecutionException e) {
637       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
638       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
639       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
640     }
641   }
642 
643   @Test
exportDataTest2()644   public void exportDataTest2() throws Exception {
645     Empty expectedResponse = Empty.newBuilder().build();
646     Operation resultOperation =
647         Operation.newBuilder()
648             .setName("exportDataTest")
649             .setDone(true)
650             .setResponse(Any.pack(expectedResponse))
651             .build();
652     mockAutoMl.addResponse(resultOperation);
653 
654     String name = "name3373707";
655     OutputConfig outputConfig = OutputConfig.newBuilder().build();
656 
657     client.exportDataAsync(name, outputConfig).get();
658 
659     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
660     Assert.assertEquals(1, actualRequests.size());
661     ExportDataRequest actualRequest = ((ExportDataRequest) actualRequests.get(0));
662 
663     Assert.assertEquals(name, actualRequest.getName());
664     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
665     Assert.assertTrue(
666         channelProvider.isHeaderSent(
667             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
668             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
669   }
670 
671   @Test
exportDataExceptionTest2()672   public void exportDataExceptionTest2() throws Exception {
673     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
674     mockAutoMl.addException(exception);
675 
676     try {
677       String name = "name3373707";
678       OutputConfig outputConfig = OutputConfig.newBuilder().build();
679       client.exportDataAsync(name, outputConfig).get();
680       Assert.fail("No exception raised");
681     } catch (ExecutionException e) {
682       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
683       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
684       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
685     }
686   }
687 
688   @Test
getAnnotationSpecTest()689   public void getAnnotationSpecTest() throws Exception {
690     AnnotationSpec expectedResponse =
691         AnnotationSpec.newBuilder()
692             .setName(
693                 AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]")
694                     .toString())
695             .setDisplayName("displayName1714148973")
696             .setExampleCount(1517063674)
697             .build();
698     mockAutoMl.addResponse(expectedResponse);
699 
700     AnnotationSpecName name =
701         AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]");
702 
703     AnnotationSpec actualResponse = client.getAnnotationSpec(name);
704     Assert.assertEquals(expectedResponse, actualResponse);
705 
706     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
707     Assert.assertEquals(1, actualRequests.size());
708     GetAnnotationSpecRequest actualRequest = ((GetAnnotationSpecRequest) actualRequests.get(0));
709 
710     Assert.assertEquals(name.toString(), actualRequest.getName());
711     Assert.assertTrue(
712         channelProvider.isHeaderSent(
713             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
714             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
715   }
716 
717   @Test
getAnnotationSpecExceptionTest()718   public void getAnnotationSpecExceptionTest() throws Exception {
719     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
720     mockAutoMl.addException(exception);
721 
722     try {
723       AnnotationSpecName name =
724           AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]");
725       client.getAnnotationSpec(name);
726       Assert.fail("No exception raised");
727     } catch (InvalidArgumentException e) {
728       // Expected exception.
729     }
730   }
731 
732   @Test
getAnnotationSpecTest2()733   public void getAnnotationSpecTest2() throws Exception {
734     AnnotationSpec expectedResponse =
735         AnnotationSpec.newBuilder()
736             .setName(
737                 AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]")
738                     .toString())
739             .setDisplayName("displayName1714148973")
740             .setExampleCount(1517063674)
741             .build();
742     mockAutoMl.addResponse(expectedResponse);
743 
744     String name = "name3373707";
745 
746     AnnotationSpec actualResponse = client.getAnnotationSpec(name);
747     Assert.assertEquals(expectedResponse, actualResponse);
748 
749     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
750     Assert.assertEquals(1, actualRequests.size());
751     GetAnnotationSpecRequest actualRequest = ((GetAnnotationSpecRequest) actualRequests.get(0));
752 
753     Assert.assertEquals(name, actualRequest.getName());
754     Assert.assertTrue(
755         channelProvider.isHeaderSent(
756             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
757             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
758   }
759 
760   @Test
getAnnotationSpecExceptionTest2()761   public void getAnnotationSpecExceptionTest2() throws Exception {
762     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
763     mockAutoMl.addException(exception);
764 
765     try {
766       String name = "name3373707";
767       client.getAnnotationSpec(name);
768       Assert.fail("No exception raised");
769     } catch (InvalidArgumentException e) {
770       // Expected exception.
771     }
772   }
773 
774   @Test
createModelTest()775   public void createModelTest() throws Exception {
776     Model expectedResponse =
777         Model.newBuilder()
778             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
779             .setDisplayName("displayName1714148973")
780             .setDatasetId("datasetId-345342029")
781             .setCreateTime(Timestamp.newBuilder().build())
782             .setUpdateTime(Timestamp.newBuilder().build())
783             .setEtag("etag3123477")
784             .putAllLabels(new HashMap<String, String>())
785             .build();
786     Operation resultOperation =
787         Operation.newBuilder()
788             .setName("createModelTest")
789             .setDone(true)
790             .setResponse(Any.pack(expectedResponse))
791             .build();
792     mockAutoMl.addResponse(resultOperation);
793 
794     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
795     Model model = Model.newBuilder().build();
796 
797     Model actualResponse = client.createModelAsync(parent, model).get();
798     Assert.assertEquals(expectedResponse, actualResponse);
799 
800     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
801     Assert.assertEquals(1, actualRequests.size());
802     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
803 
804     Assert.assertEquals(parent.toString(), actualRequest.getParent());
805     Assert.assertEquals(model, actualRequest.getModel());
806     Assert.assertTrue(
807         channelProvider.isHeaderSent(
808             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
809             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
810   }
811 
812   @Test
createModelExceptionTest()813   public void createModelExceptionTest() throws Exception {
814     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
815     mockAutoMl.addException(exception);
816 
817     try {
818       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
819       Model model = Model.newBuilder().build();
820       client.createModelAsync(parent, model).get();
821       Assert.fail("No exception raised");
822     } catch (ExecutionException e) {
823       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
824       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
825       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
826     }
827   }
828 
829   @Test
createModelTest2()830   public void createModelTest2() throws Exception {
831     Model expectedResponse =
832         Model.newBuilder()
833             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
834             .setDisplayName("displayName1714148973")
835             .setDatasetId("datasetId-345342029")
836             .setCreateTime(Timestamp.newBuilder().build())
837             .setUpdateTime(Timestamp.newBuilder().build())
838             .setEtag("etag3123477")
839             .putAllLabels(new HashMap<String, String>())
840             .build();
841     Operation resultOperation =
842         Operation.newBuilder()
843             .setName("createModelTest")
844             .setDone(true)
845             .setResponse(Any.pack(expectedResponse))
846             .build();
847     mockAutoMl.addResponse(resultOperation);
848 
849     String parent = "parent-995424086";
850     Model model = Model.newBuilder().build();
851 
852     Model actualResponse = client.createModelAsync(parent, model).get();
853     Assert.assertEquals(expectedResponse, actualResponse);
854 
855     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
856     Assert.assertEquals(1, actualRequests.size());
857     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
858 
859     Assert.assertEquals(parent, actualRequest.getParent());
860     Assert.assertEquals(model, actualRequest.getModel());
861     Assert.assertTrue(
862         channelProvider.isHeaderSent(
863             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
864             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
865   }
866 
867   @Test
createModelExceptionTest2()868   public void createModelExceptionTest2() throws Exception {
869     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
870     mockAutoMl.addException(exception);
871 
872     try {
873       String parent = "parent-995424086";
874       Model model = Model.newBuilder().build();
875       client.createModelAsync(parent, model).get();
876       Assert.fail("No exception raised");
877     } catch (ExecutionException e) {
878       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
879       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
880       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
881     }
882   }
883 
884   @Test
getModelTest()885   public void getModelTest() throws Exception {
886     Model expectedResponse =
887         Model.newBuilder()
888             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
889             .setDisplayName("displayName1714148973")
890             .setDatasetId("datasetId-345342029")
891             .setCreateTime(Timestamp.newBuilder().build())
892             .setUpdateTime(Timestamp.newBuilder().build())
893             .setEtag("etag3123477")
894             .putAllLabels(new HashMap<String, String>())
895             .build();
896     mockAutoMl.addResponse(expectedResponse);
897 
898     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
899 
900     Model actualResponse = client.getModel(name);
901     Assert.assertEquals(expectedResponse, actualResponse);
902 
903     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
904     Assert.assertEquals(1, actualRequests.size());
905     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
906 
907     Assert.assertEquals(name.toString(), actualRequest.getName());
908     Assert.assertTrue(
909         channelProvider.isHeaderSent(
910             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
911             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
912   }
913 
914   @Test
getModelExceptionTest()915   public void getModelExceptionTest() throws Exception {
916     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
917     mockAutoMl.addException(exception);
918 
919     try {
920       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
921       client.getModel(name);
922       Assert.fail("No exception raised");
923     } catch (InvalidArgumentException e) {
924       // Expected exception.
925     }
926   }
927 
928   @Test
getModelTest2()929   public void getModelTest2() throws Exception {
930     Model expectedResponse =
931         Model.newBuilder()
932             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
933             .setDisplayName("displayName1714148973")
934             .setDatasetId("datasetId-345342029")
935             .setCreateTime(Timestamp.newBuilder().build())
936             .setUpdateTime(Timestamp.newBuilder().build())
937             .setEtag("etag3123477")
938             .putAllLabels(new HashMap<String, String>())
939             .build();
940     mockAutoMl.addResponse(expectedResponse);
941 
942     String name = "name3373707";
943 
944     Model actualResponse = client.getModel(name);
945     Assert.assertEquals(expectedResponse, actualResponse);
946 
947     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
948     Assert.assertEquals(1, actualRequests.size());
949     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
950 
951     Assert.assertEquals(name, actualRequest.getName());
952     Assert.assertTrue(
953         channelProvider.isHeaderSent(
954             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
955             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
956   }
957 
958   @Test
getModelExceptionTest2()959   public void getModelExceptionTest2() throws Exception {
960     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
961     mockAutoMl.addException(exception);
962 
963     try {
964       String name = "name3373707";
965       client.getModel(name);
966       Assert.fail("No exception raised");
967     } catch (InvalidArgumentException e) {
968       // Expected exception.
969     }
970   }
971 
972   @Test
listModelsTest()973   public void listModelsTest() throws Exception {
974     Model responsesElement = Model.newBuilder().build();
975     ListModelsResponse expectedResponse =
976         ListModelsResponse.newBuilder()
977             .setNextPageToken("")
978             .addAllModel(Arrays.asList(responsesElement))
979             .build();
980     mockAutoMl.addResponse(expectedResponse);
981 
982     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
983 
984     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
985 
986     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
987 
988     Assert.assertEquals(1, resources.size());
989     Assert.assertEquals(expectedResponse.getModelList().get(0), resources.get(0));
990 
991     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
992     Assert.assertEquals(1, actualRequests.size());
993     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
994 
995     Assert.assertEquals(parent.toString(), actualRequest.getParent());
996     Assert.assertTrue(
997         channelProvider.isHeaderSent(
998             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
999             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1000   }
1001 
1002   @Test
listModelsExceptionTest()1003   public void listModelsExceptionTest() throws Exception {
1004     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1005     mockAutoMl.addException(exception);
1006 
1007     try {
1008       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1009       client.listModels(parent);
1010       Assert.fail("No exception raised");
1011     } catch (InvalidArgumentException e) {
1012       // Expected exception.
1013     }
1014   }
1015 
1016   @Test
listModelsTest2()1017   public void listModelsTest2() throws Exception {
1018     Model responsesElement = Model.newBuilder().build();
1019     ListModelsResponse expectedResponse =
1020         ListModelsResponse.newBuilder()
1021             .setNextPageToken("")
1022             .addAllModel(Arrays.asList(responsesElement))
1023             .build();
1024     mockAutoMl.addResponse(expectedResponse);
1025 
1026     String parent = "parent-995424086";
1027 
1028     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
1029 
1030     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1031 
1032     Assert.assertEquals(1, resources.size());
1033     Assert.assertEquals(expectedResponse.getModelList().get(0), resources.get(0));
1034 
1035     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1036     Assert.assertEquals(1, actualRequests.size());
1037     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
1038 
1039     Assert.assertEquals(parent, actualRequest.getParent());
1040     Assert.assertTrue(
1041         channelProvider.isHeaderSent(
1042             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1043             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1044   }
1045 
1046   @Test
listModelsExceptionTest2()1047   public void listModelsExceptionTest2() throws Exception {
1048     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1049     mockAutoMl.addException(exception);
1050 
1051     try {
1052       String parent = "parent-995424086";
1053       client.listModels(parent);
1054       Assert.fail("No exception raised");
1055     } catch (InvalidArgumentException e) {
1056       // Expected exception.
1057     }
1058   }
1059 
1060   @Test
deleteModelTest()1061   public void deleteModelTest() throws Exception {
1062     Empty expectedResponse = Empty.newBuilder().build();
1063     Operation resultOperation =
1064         Operation.newBuilder()
1065             .setName("deleteModelTest")
1066             .setDone(true)
1067             .setResponse(Any.pack(expectedResponse))
1068             .build();
1069     mockAutoMl.addResponse(resultOperation);
1070 
1071     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1072 
1073     client.deleteModelAsync(name).get();
1074 
1075     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1076     Assert.assertEquals(1, actualRequests.size());
1077     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
1078 
1079     Assert.assertEquals(name.toString(), actualRequest.getName());
1080     Assert.assertTrue(
1081         channelProvider.isHeaderSent(
1082             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1083             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1084   }
1085 
1086   @Test
deleteModelExceptionTest()1087   public void deleteModelExceptionTest() throws Exception {
1088     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1089     mockAutoMl.addException(exception);
1090 
1091     try {
1092       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1093       client.deleteModelAsync(name).get();
1094       Assert.fail("No exception raised");
1095     } catch (ExecutionException e) {
1096       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1097       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1098       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1099     }
1100   }
1101 
1102   @Test
deleteModelTest2()1103   public void deleteModelTest2() throws Exception {
1104     Empty expectedResponse = Empty.newBuilder().build();
1105     Operation resultOperation =
1106         Operation.newBuilder()
1107             .setName("deleteModelTest")
1108             .setDone(true)
1109             .setResponse(Any.pack(expectedResponse))
1110             .build();
1111     mockAutoMl.addResponse(resultOperation);
1112 
1113     String name = "name3373707";
1114 
1115     client.deleteModelAsync(name).get();
1116 
1117     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1118     Assert.assertEquals(1, actualRequests.size());
1119     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
1120 
1121     Assert.assertEquals(name, actualRequest.getName());
1122     Assert.assertTrue(
1123         channelProvider.isHeaderSent(
1124             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1125             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1126   }
1127 
1128   @Test
deleteModelExceptionTest2()1129   public void deleteModelExceptionTest2() throws Exception {
1130     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1131     mockAutoMl.addException(exception);
1132 
1133     try {
1134       String name = "name3373707";
1135       client.deleteModelAsync(name).get();
1136       Assert.fail("No exception raised");
1137     } catch (ExecutionException e) {
1138       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1139       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1140       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1141     }
1142   }
1143 
1144   @Test
updateModelTest()1145   public void updateModelTest() throws Exception {
1146     Model expectedResponse =
1147         Model.newBuilder()
1148             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
1149             .setDisplayName("displayName1714148973")
1150             .setDatasetId("datasetId-345342029")
1151             .setCreateTime(Timestamp.newBuilder().build())
1152             .setUpdateTime(Timestamp.newBuilder().build())
1153             .setEtag("etag3123477")
1154             .putAllLabels(new HashMap<String, String>())
1155             .build();
1156     mockAutoMl.addResponse(expectedResponse);
1157 
1158     Model model = Model.newBuilder().build();
1159     FieldMask updateMask = FieldMask.newBuilder().build();
1160 
1161     Model actualResponse = client.updateModel(model, updateMask);
1162     Assert.assertEquals(expectedResponse, actualResponse);
1163 
1164     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1165     Assert.assertEquals(1, actualRequests.size());
1166     UpdateModelRequest actualRequest = ((UpdateModelRequest) actualRequests.get(0));
1167 
1168     Assert.assertEquals(model, actualRequest.getModel());
1169     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1170     Assert.assertTrue(
1171         channelProvider.isHeaderSent(
1172             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1173             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1174   }
1175 
1176   @Test
updateModelExceptionTest()1177   public void updateModelExceptionTest() throws Exception {
1178     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1179     mockAutoMl.addException(exception);
1180 
1181     try {
1182       Model model = Model.newBuilder().build();
1183       FieldMask updateMask = FieldMask.newBuilder().build();
1184       client.updateModel(model, updateMask);
1185       Assert.fail("No exception raised");
1186     } catch (InvalidArgumentException e) {
1187       // Expected exception.
1188     }
1189   }
1190 
1191   @Test
deployModelTest()1192   public void deployModelTest() throws Exception {
1193     Empty expectedResponse = Empty.newBuilder().build();
1194     Operation resultOperation =
1195         Operation.newBuilder()
1196             .setName("deployModelTest")
1197             .setDone(true)
1198             .setResponse(Any.pack(expectedResponse))
1199             .build();
1200     mockAutoMl.addResponse(resultOperation);
1201 
1202     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1203 
1204     client.deployModelAsync(name).get();
1205 
1206     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1207     Assert.assertEquals(1, actualRequests.size());
1208     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
1209 
1210     Assert.assertEquals(name.toString(), actualRequest.getName());
1211     Assert.assertTrue(
1212         channelProvider.isHeaderSent(
1213             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1214             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1215   }
1216 
1217   @Test
deployModelExceptionTest()1218   public void deployModelExceptionTest() throws Exception {
1219     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1220     mockAutoMl.addException(exception);
1221 
1222     try {
1223       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1224       client.deployModelAsync(name).get();
1225       Assert.fail("No exception raised");
1226     } catch (ExecutionException e) {
1227       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1228       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1229       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1230     }
1231   }
1232 
1233   @Test
deployModelTest2()1234   public void deployModelTest2() throws Exception {
1235     Empty expectedResponse = Empty.newBuilder().build();
1236     Operation resultOperation =
1237         Operation.newBuilder()
1238             .setName("deployModelTest")
1239             .setDone(true)
1240             .setResponse(Any.pack(expectedResponse))
1241             .build();
1242     mockAutoMl.addResponse(resultOperation);
1243 
1244     String name = "name3373707";
1245 
1246     client.deployModelAsync(name).get();
1247 
1248     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1249     Assert.assertEquals(1, actualRequests.size());
1250     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
1251 
1252     Assert.assertEquals(name, actualRequest.getName());
1253     Assert.assertTrue(
1254         channelProvider.isHeaderSent(
1255             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1256             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1257   }
1258 
1259   @Test
deployModelExceptionTest2()1260   public void deployModelExceptionTest2() throws Exception {
1261     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1262     mockAutoMl.addException(exception);
1263 
1264     try {
1265       String name = "name3373707";
1266       client.deployModelAsync(name).get();
1267       Assert.fail("No exception raised");
1268     } catch (ExecutionException e) {
1269       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1270       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1271       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1272     }
1273   }
1274 
1275   @Test
undeployModelTest()1276   public void undeployModelTest() throws Exception {
1277     Empty expectedResponse = Empty.newBuilder().build();
1278     Operation resultOperation =
1279         Operation.newBuilder()
1280             .setName("undeployModelTest")
1281             .setDone(true)
1282             .setResponse(Any.pack(expectedResponse))
1283             .build();
1284     mockAutoMl.addResponse(resultOperation);
1285 
1286     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1287 
1288     client.undeployModelAsync(name).get();
1289 
1290     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1291     Assert.assertEquals(1, actualRequests.size());
1292     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
1293 
1294     Assert.assertEquals(name.toString(), actualRequest.getName());
1295     Assert.assertTrue(
1296         channelProvider.isHeaderSent(
1297             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1298             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1299   }
1300 
1301   @Test
undeployModelExceptionTest()1302   public void undeployModelExceptionTest() throws Exception {
1303     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1304     mockAutoMl.addException(exception);
1305 
1306     try {
1307       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1308       client.undeployModelAsync(name).get();
1309       Assert.fail("No exception raised");
1310     } catch (ExecutionException e) {
1311       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1312       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1313       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1314     }
1315   }
1316 
1317   @Test
undeployModelTest2()1318   public void undeployModelTest2() throws Exception {
1319     Empty expectedResponse = Empty.newBuilder().build();
1320     Operation resultOperation =
1321         Operation.newBuilder()
1322             .setName("undeployModelTest")
1323             .setDone(true)
1324             .setResponse(Any.pack(expectedResponse))
1325             .build();
1326     mockAutoMl.addResponse(resultOperation);
1327 
1328     String name = "name3373707";
1329 
1330     client.undeployModelAsync(name).get();
1331 
1332     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1333     Assert.assertEquals(1, actualRequests.size());
1334     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
1335 
1336     Assert.assertEquals(name, actualRequest.getName());
1337     Assert.assertTrue(
1338         channelProvider.isHeaderSent(
1339             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1340             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1341   }
1342 
1343   @Test
undeployModelExceptionTest2()1344   public void undeployModelExceptionTest2() throws Exception {
1345     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1346     mockAutoMl.addException(exception);
1347 
1348     try {
1349       String name = "name3373707";
1350       client.undeployModelAsync(name).get();
1351       Assert.fail("No exception raised");
1352     } catch (ExecutionException e) {
1353       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1354       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1355       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1356     }
1357   }
1358 
1359   @Test
exportModelTest()1360   public void exportModelTest() throws Exception {
1361     Empty expectedResponse = Empty.newBuilder().build();
1362     Operation resultOperation =
1363         Operation.newBuilder()
1364             .setName("exportModelTest")
1365             .setDone(true)
1366             .setResponse(Any.pack(expectedResponse))
1367             .build();
1368     mockAutoMl.addResponse(resultOperation);
1369 
1370     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1371     ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1372 
1373     client.exportModelAsync(name, outputConfig).get();
1374 
1375     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1376     Assert.assertEquals(1, actualRequests.size());
1377     ExportModelRequest actualRequest = ((ExportModelRequest) actualRequests.get(0));
1378 
1379     Assert.assertEquals(name.toString(), actualRequest.getName());
1380     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1381     Assert.assertTrue(
1382         channelProvider.isHeaderSent(
1383             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1384             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1385   }
1386 
1387   @Test
exportModelExceptionTest()1388   public void exportModelExceptionTest() throws Exception {
1389     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1390     mockAutoMl.addException(exception);
1391 
1392     try {
1393       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1394       ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1395       client.exportModelAsync(name, outputConfig).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
exportModelTest2()1405   public void exportModelTest2() throws Exception {
1406     Empty expectedResponse = Empty.newBuilder().build();
1407     Operation resultOperation =
1408         Operation.newBuilder()
1409             .setName("exportModelTest")
1410             .setDone(true)
1411             .setResponse(Any.pack(expectedResponse))
1412             .build();
1413     mockAutoMl.addResponse(resultOperation);
1414 
1415     String name = "name3373707";
1416     ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1417 
1418     client.exportModelAsync(name, outputConfig).get();
1419 
1420     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1421     Assert.assertEquals(1, actualRequests.size());
1422     ExportModelRequest actualRequest = ((ExportModelRequest) actualRequests.get(0));
1423 
1424     Assert.assertEquals(name, actualRequest.getName());
1425     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1426     Assert.assertTrue(
1427         channelProvider.isHeaderSent(
1428             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1429             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1430   }
1431 
1432   @Test
exportModelExceptionTest2()1433   public void exportModelExceptionTest2() throws Exception {
1434     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1435     mockAutoMl.addException(exception);
1436 
1437     try {
1438       String name = "name3373707";
1439       ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1440       client.exportModelAsync(name, outputConfig).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   @Test
getModelEvaluationTest()1450   public void getModelEvaluationTest() throws Exception {
1451     ModelEvaluation expectedResponse =
1452         ModelEvaluation.newBuilder()
1453             .setName(
1454                 ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]")
1455                     .toString())
1456             .setAnnotationSpecId("annotationSpecId1320449605")
1457             .setDisplayName("displayName1714148973")
1458             .setCreateTime(Timestamp.newBuilder().build())
1459             .setEvaluatedExampleCount(277565350)
1460             .build();
1461     mockAutoMl.addResponse(expectedResponse);
1462 
1463     ModelEvaluationName name =
1464         ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]");
1465 
1466     ModelEvaluation actualResponse = client.getModelEvaluation(name);
1467     Assert.assertEquals(expectedResponse, actualResponse);
1468 
1469     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1470     Assert.assertEquals(1, actualRequests.size());
1471     GetModelEvaluationRequest actualRequest = ((GetModelEvaluationRequest) actualRequests.get(0));
1472 
1473     Assert.assertEquals(name.toString(), actualRequest.getName());
1474     Assert.assertTrue(
1475         channelProvider.isHeaderSent(
1476             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1477             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1478   }
1479 
1480   @Test
getModelEvaluationExceptionTest()1481   public void getModelEvaluationExceptionTest() throws Exception {
1482     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1483     mockAutoMl.addException(exception);
1484 
1485     try {
1486       ModelEvaluationName name =
1487           ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]");
1488       client.getModelEvaluation(name);
1489       Assert.fail("No exception raised");
1490     } catch (InvalidArgumentException e) {
1491       // Expected exception.
1492     }
1493   }
1494 
1495   @Test
getModelEvaluationTest2()1496   public void getModelEvaluationTest2() throws Exception {
1497     ModelEvaluation expectedResponse =
1498         ModelEvaluation.newBuilder()
1499             .setName(
1500                 ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]")
1501                     .toString())
1502             .setAnnotationSpecId("annotationSpecId1320449605")
1503             .setDisplayName("displayName1714148973")
1504             .setCreateTime(Timestamp.newBuilder().build())
1505             .setEvaluatedExampleCount(277565350)
1506             .build();
1507     mockAutoMl.addResponse(expectedResponse);
1508 
1509     String name = "name3373707";
1510 
1511     ModelEvaluation actualResponse = client.getModelEvaluation(name);
1512     Assert.assertEquals(expectedResponse, actualResponse);
1513 
1514     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1515     Assert.assertEquals(1, actualRequests.size());
1516     GetModelEvaluationRequest actualRequest = ((GetModelEvaluationRequest) actualRequests.get(0));
1517 
1518     Assert.assertEquals(name, actualRequest.getName());
1519     Assert.assertTrue(
1520         channelProvider.isHeaderSent(
1521             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1522             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1523   }
1524 
1525   @Test
getModelEvaluationExceptionTest2()1526   public void getModelEvaluationExceptionTest2() throws Exception {
1527     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1528     mockAutoMl.addException(exception);
1529 
1530     try {
1531       String name = "name3373707";
1532       client.getModelEvaluation(name);
1533       Assert.fail("No exception raised");
1534     } catch (InvalidArgumentException e) {
1535       // Expected exception.
1536     }
1537   }
1538 
1539   @Test
listModelEvaluationsTest()1540   public void listModelEvaluationsTest() throws Exception {
1541     ModelEvaluation responsesElement = ModelEvaluation.newBuilder().build();
1542     ListModelEvaluationsResponse expectedResponse =
1543         ListModelEvaluationsResponse.newBuilder()
1544             .setNextPageToken("")
1545             .addAllModelEvaluation(Arrays.asList(responsesElement))
1546             .build();
1547     mockAutoMl.addResponse(expectedResponse);
1548 
1549     ModelName parent = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1550     String filter = "filter-1274492040";
1551 
1552     ListModelEvaluationsPagedResponse pagedListResponse =
1553         client.listModelEvaluations(parent, filter);
1554 
1555     List<ModelEvaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1556 
1557     Assert.assertEquals(1, resources.size());
1558     Assert.assertEquals(expectedResponse.getModelEvaluationList().get(0), resources.get(0));
1559 
1560     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1561     Assert.assertEquals(1, actualRequests.size());
1562     ListModelEvaluationsRequest actualRequest =
1563         ((ListModelEvaluationsRequest) actualRequests.get(0));
1564 
1565     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1566     Assert.assertEquals(filter, actualRequest.getFilter());
1567     Assert.assertTrue(
1568         channelProvider.isHeaderSent(
1569             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1570             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1571   }
1572 
1573   @Test
listModelEvaluationsExceptionTest()1574   public void listModelEvaluationsExceptionTest() throws Exception {
1575     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1576     mockAutoMl.addException(exception);
1577 
1578     try {
1579       ModelName parent = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1580       String filter = "filter-1274492040";
1581       client.listModelEvaluations(parent, filter);
1582       Assert.fail("No exception raised");
1583     } catch (InvalidArgumentException e) {
1584       // Expected exception.
1585     }
1586   }
1587 
1588   @Test
listModelEvaluationsTest2()1589   public void listModelEvaluationsTest2() throws Exception {
1590     ModelEvaluation responsesElement = ModelEvaluation.newBuilder().build();
1591     ListModelEvaluationsResponse expectedResponse =
1592         ListModelEvaluationsResponse.newBuilder()
1593             .setNextPageToken("")
1594             .addAllModelEvaluation(Arrays.asList(responsesElement))
1595             .build();
1596     mockAutoMl.addResponse(expectedResponse);
1597 
1598     String parent = "parent-995424086";
1599     String filter = "filter-1274492040";
1600 
1601     ListModelEvaluationsPagedResponse pagedListResponse =
1602         client.listModelEvaluations(parent, filter);
1603 
1604     List<ModelEvaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1605 
1606     Assert.assertEquals(1, resources.size());
1607     Assert.assertEquals(expectedResponse.getModelEvaluationList().get(0), resources.get(0));
1608 
1609     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1610     Assert.assertEquals(1, actualRequests.size());
1611     ListModelEvaluationsRequest actualRequest =
1612         ((ListModelEvaluationsRequest) actualRequests.get(0));
1613 
1614     Assert.assertEquals(parent, actualRequest.getParent());
1615     Assert.assertEquals(filter, actualRequest.getFilter());
1616     Assert.assertTrue(
1617         channelProvider.isHeaderSent(
1618             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1619             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1620   }
1621 
1622   @Test
listModelEvaluationsExceptionTest2()1623   public void listModelEvaluationsExceptionTest2() throws Exception {
1624     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1625     mockAutoMl.addException(exception);
1626 
1627     try {
1628       String parent = "parent-995424086";
1629       String filter = "filter-1274492040";
1630       client.listModelEvaluations(parent, filter);
1631       Assert.fail("No exception raised");
1632     } catch (InvalidArgumentException e) {
1633       // Expected exception.
1634     }
1635   }
1636 }
1637