• 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.v1beta1;
18 
19 import static com.google.cloud.automl.v1beta1.AutoMlClient.ListColumnSpecsPagedResponse;
20 import static com.google.cloud.automl.v1beta1.AutoMlClient.ListDatasetsPagedResponse;
21 import static com.google.cloud.automl.v1beta1.AutoMlClient.ListModelEvaluationsPagedResponse;
22 import static com.google.cloud.automl.v1beta1.AutoMlClient.ListModelsPagedResponse;
23 import static com.google.cloud.automl.v1beta1.AutoMlClient.ListTableSpecsPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.grpc.GaxGrpcProperties;
27 import com.google.api.gax.grpc.testing.LocalChannelProvider;
28 import com.google.api.gax.grpc.testing.MockGrpcService;
29 import com.google.api.gax.grpc.testing.MockServiceHelper;
30 import com.google.api.gax.rpc.ApiClientHeaderProvider;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.api.gax.rpc.StatusCode;
33 import com.google.common.collect.Lists;
34 import com.google.longrunning.Operation;
35 import com.google.protobuf.AbstractMessage;
36 import com.google.protobuf.Any;
37 import com.google.protobuf.Empty;
38 import com.google.protobuf.Timestamp;
39 import io.grpc.StatusRuntimeException;
40 import java.io.IOException;
41 import java.util.ArrayList;
42 import java.util.Arrays;
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 AutoMlClientTest {
56   private static MockAutoMl mockAutoMl;
57   private static MockServiceHelper mockServiceHelper;
58   private LocalChannelProvider channelProvider;
59   private AutoMlClient client;
60 
61   @BeforeClass
startStaticServer()62   public static void startStaticServer() {
63     mockAutoMl = new MockAutoMl();
64     mockServiceHelper =
65         new MockServiceHelper(
66             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockAutoMl));
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     AutoMlSettings settings =
80         AutoMlSettings.newBuilder()
81             .setTransportChannelProvider(channelProvider)
82             .setCredentialsProvider(NoCredentialsProvider.create())
83             .build();
84     client = AutoMlClient.create(settings);
85   }
86 
87   @After
tearDown()88   public void tearDown() throws Exception {
89     client.close();
90   }
91 
92   @Test
createDatasetTest()93   public void createDatasetTest() throws Exception {
94     Dataset expectedResponse =
95         Dataset.newBuilder()
96             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
97             .setDisplayName("displayName1714148973")
98             .setDescription("description-1724546052")
99             .setExampleCount(1517063674)
100             .setCreateTime(Timestamp.newBuilder().build())
101             .setEtag("etag3123477")
102             .build();
103     mockAutoMl.addResponse(expectedResponse);
104 
105     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
106     Dataset dataset = Dataset.newBuilder().build();
107 
108     Dataset actualResponse = client.createDataset(parent, dataset);
109     Assert.assertEquals(expectedResponse, actualResponse);
110 
111     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
112     Assert.assertEquals(1, actualRequests.size());
113     CreateDatasetRequest actualRequest = ((CreateDatasetRequest) actualRequests.get(0));
114 
115     Assert.assertEquals(parent.toString(), actualRequest.getParent());
116     Assert.assertEquals(dataset, actualRequest.getDataset());
117     Assert.assertTrue(
118         channelProvider.isHeaderSent(
119             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
120             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
121   }
122 
123   @Test
createDatasetExceptionTest()124   public void createDatasetExceptionTest() throws Exception {
125     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
126     mockAutoMl.addException(exception);
127 
128     try {
129       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
130       Dataset dataset = Dataset.newBuilder().build();
131       client.createDataset(parent, dataset);
132       Assert.fail("No exception raised");
133     } catch (InvalidArgumentException e) {
134       // Expected exception.
135     }
136   }
137 
138   @Test
createDatasetTest2()139   public void createDatasetTest2() throws Exception {
140     Dataset expectedResponse =
141         Dataset.newBuilder()
142             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
143             .setDisplayName("displayName1714148973")
144             .setDescription("description-1724546052")
145             .setExampleCount(1517063674)
146             .setCreateTime(Timestamp.newBuilder().build())
147             .setEtag("etag3123477")
148             .build();
149     mockAutoMl.addResponse(expectedResponse);
150 
151     String parent = "parent-995424086";
152     Dataset dataset = Dataset.newBuilder().build();
153 
154     Dataset actualResponse = client.createDataset(parent, dataset);
155     Assert.assertEquals(expectedResponse, actualResponse);
156 
157     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
158     Assert.assertEquals(1, actualRequests.size());
159     CreateDatasetRequest actualRequest = ((CreateDatasetRequest) actualRequests.get(0));
160 
161     Assert.assertEquals(parent, actualRequest.getParent());
162     Assert.assertEquals(dataset, actualRequest.getDataset());
163     Assert.assertTrue(
164         channelProvider.isHeaderSent(
165             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
166             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
167   }
168 
169   @Test
createDatasetExceptionTest2()170   public void createDatasetExceptionTest2() throws Exception {
171     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
172     mockAutoMl.addException(exception);
173 
174     try {
175       String parent = "parent-995424086";
176       Dataset dataset = Dataset.newBuilder().build();
177       client.createDataset(parent, dataset);
178       Assert.fail("No exception raised");
179     } catch (InvalidArgumentException e) {
180       // Expected exception.
181     }
182   }
183 
184   @Test
getDatasetTest()185   public void getDatasetTest() throws Exception {
186     Dataset expectedResponse =
187         Dataset.newBuilder()
188             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
189             .setDisplayName("displayName1714148973")
190             .setDescription("description-1724546052")
191             .setExampleCount(1517063674)
192             .setCreateTime(Timestamp.newBuilder().build())
193             .setEtag("etag3123477")
194             .build();
195     mockAutoMl.addResponse(expectedResponse);
196 
197     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
198 
199     Dataset actualResponse = client.getDataset(name);
200     Assert.assertEquals(expectedResponse, actualResponse);
201 
202     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
203     Assert.assertEquals(1, actualRequests.size());
204     GetDatasetRequest actualRequest = ((GetDatasetRequest) actualRequests.get(0));
205 
206     Assert.assertEquals(name.toString(), actualRequest.getName());
207     Assert.assertTrue(
208         channelProvider.isHeaderSent(
209             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
210             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
211   }
212 
213   @Test
getDatasetExceptionTest()214   public void getDatasetExceptionTest() throws Exception {
215     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
216     mockAutoMl.addException(exception);
217 
218     try {
219       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
220       client.getDataset(name);
221       Assert.fail("No exception raised");
222     } catch (InvalidArgumentException e) {
223       // Expected exception.
224     }
225   }
226 
227   @Test
getDatasetTest2()228   public void getDatasetTest2() throws Exception {
229     Dataset expectedResponse =
230         Dataset.newBuilder()
231             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
232             .setDisplayName("displayName1714148973")
233             .setDescription("description-1724546052")
234             .setExampleCount(1517063674)
235             .setCreateTime(Timestamp.newBuilder().build())
236             .setEtag("etag3123477")
237             .build();
238     mockAutoMl.addResponse(expectedResponse);
239 
240     String name = "name3373707";
241 
242     Dataset actualResponse = client.getDataset(name);
243     Assert.assertEquals(expectedResponse, actualResponse);
244 
245     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
246     Assert.assertEquals(1, actualRequests.size());
247     GetDatasetRequest actualRequest = ((GetDatasetRequest) actualRequests.get(0));
248 
249     Assert.assertEquals(name, actualRequest.getName());
250     Assert.assertTrue(
251         channelProvider.isHeaderSent(
252             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
253             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
254   }
255 
256   @Test
getDatasetExceptionTest2()257   public void getDatasetExceptionTest2() throws Exception {
258     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
259     mockAutoMl.addException(exception);
260 
261     try {
262       String name = "name3373707";
263       client.getDataset(name);
264       Assert.fail("No exception raised");
265     } catch (InvalidArgumentException e) {
266       // Expected exception.
267     }
268   }
269 
270   @Test
listDatasetsTest()271   public void listDatasetsTest() throws Exception {
272     Dataset responsesElement = Dataset.newBuilder().build();
273     ListDatasetsResponse expectedResponse =
274         ListDatasetsResponse.newBuilder()
275             .setNextPageToken("")
276             .addAllDatasets(Arrays.asList(responsesElement))
277             .build();
278     mockAutoMl.addResponse(expectedResponse);
279 
280     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
281 
282     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
283 
284     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
285 
286     Assert.assertEquals(1, resources.size());
287     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
288 
289     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
290     Assert.assertEquals(1, actualRequests.size());
291     ListDatasetsRequest actualRequest = ((ListDatasetsRequest) actualRequests.get(0));
292 
293     Assert.assertEquals(parent.toString(), actualRequest.getParent());
294     Assert.assertTrue(
295         channelProvider.isHeaderSent(
296             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
297             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
298   }
299 
300   @Test
listDatasetsExceptionTest()301   public void listDatasetsExceptionTest() throws Exception {
302     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
303     mockAutoMl.addException(exception);
304 
305     try {
306       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
307       client.listDatasets(parent);
308       Assert.fail("No exception raised");
309     } catch (InvalidArgumentException e) {
310       // Expected exception.
311     }
312   }
313 
314   @Test
listDatasetsTest2()315   public void listDatasetsTest2() throws Exception {
316     Dataset responsesElement = Dataset.newBuilder().build();
317     ListDatasetsResponse expectedResponse =
318         ListDatasetsResponse.newBuilder()
319             .setNextPageToken("")
320             .addAllDatasets(Arrays.asList(responsesElement))
321             .build();
322     mockAutoMl.addResponse(expectedResponse);
323 
324     String parent = "parent-995424086";
325 
326     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
327 
328     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
329 
330     Assert.assertEquals(1, resources.size());
331     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
332 
333     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
334     Assert.assertEquals(1, actualRequests.size());
335     ListDatasetsRequest actualRequest = ((ListDatasetsRequest) actualRequests.get(0));
336 
337     Assert.assertEquals(parent, actualRequest.getParent());
338     Assert.assertTrue(
339         channelProvider.isHeaderSent(
340             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
341             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
342   }
343 
344   @Test
listDatasetsExceptionTest2()345   public void listDatasetsExceptionTest2() throws Exception {
346     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
347     mockAutoMl.addException(exception);
348 
349     try {
350       String parent = "parent-995424086";
351       client.listDatasets(parent);
352       Assert.fail("No exception raised");
353     } catch (InvalidArgumentException e) {
354       // Expected exception.
355     }
356   }
357 
358   @Test
updateDatasetTest()359   public void updateDatasetTest() throws Exception {
360     Dataset expectedResponse =
361         Dataset.newBuilder()
362             .setName(DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]").toString())
363             .setDisplayName("displayName1714148973")
364             .setDescription("description-1724546052")
365             .setExampleCount(1517063674)
366             .setCreateTime(Timestamp.newBuilder().build())
367             .setEtag("etag3123477")
368             .build();
369     mockAutoMl.addResponse(expectedResponse);
370 
371     Dataset dataset = Dataset.newBuilder().build();
372 
373     Dataset actualResponse = client.updateDataset(dataset);
374     Assert.assertEquals(expectedResponse, actualResponse);
375 
376     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
377     Assert.assertEquals(1, actualRequests.size());
378     UpdateDatasetRequest actualRequest = ((UpdateDatasetRequest) actualRequests.get(0));
379 
380     Assert.assertEquals(dataset, actualRequest.getDataset());
381     Assert.assertTrue(
382         channelProvider.isHeaderSent(
383             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
384             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
385   }
386 
387   @Test
updateDatasetExceptionTest()388   public void updateDatasetExceptionTest() throws Exception {
389     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
390     mockAutoMl.addException(exception);
391 
392     try {
393       Dataset dataset = Dataset.newBuilder().build();
394       client.updateDataset(dataset);
395       Assert.fail("No exception raised");
396     } catch (InvalidArgumentException e) {
397       // Expected exception.
398     }
399   }
400 
401   @Test
deleteDatasetTest()402   public void deleteDatasetTest() throws Exception {
403     Empty expectedResponse = Empty.newBuilder().build();
404     Operation resultOperation =
405         Operation.newBuilder()
406             .setName("deleteDatasetTest")
407             .setDone(true)
408             .setResponse(Any.pack(expectedResponse))
409             .build();
410     mockAutoMl.addResponse(resultOperation);
411 
412     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
413 
414     client.deleteDatasetAsync(name).get();
415 
416     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
417     Assert.assertEquals(1, actualRequests.size());
418     DeleteDatasetRequest actualRequest = ((DeleteDatasetRequest) actualRequests.get(0));
419 
420     Assert.assertEquals(name.toString(), actualRequest.getName());
421     Assert.assertTrue(
422         channelProvider.isHeaderSent(
423             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
424             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
425   }
426 
427   @Test
deleteDatasetExceptionTest()428   public void deleteDatasetExceptionTest() throws Exception {
429     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
430     mockAutoMl.addException(exception);
431 
432     try {
433       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
434       client.deleteDatasetAsync(name).get();
435       Assert.fail("No exception raised");
436     } catch (ExecutionException e) {
437       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
438       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
439       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
440     }
441   }
442 
443   @Test
deleteDatasetTest2()444   public void deleteDatasetTest2() throws Exception {
445     Empty expectedResponse = Empty.newBuilder().build();
446     Operation resultOperation =
447         Operation.newBuilder()
448             .setName("deleteDatasetTest")
449             .setDone(true)
450             .setResponse(Any.pack(expectedResponse))
451             .build();
452     mockAutoMl.addResponse(resultOperation);
453 
454     String name = "name3373707";
455 
456     client.deleteDatasetAsync(name).get();
457 
458     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
459     Assert.assertEquals(1, actualRequests.size());
460     DeleteDatasetRequest actualRequest = ((DeleteDatasetRequest) actualRequests.get(0));
461 
462     Assert.assertEquals(name, actualRequest.getName());
463     Assert.assertTrue(
464         channelProvider.isHeaderSent(
465             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
466             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
467   }
468 
469   @Test
deleteDatasetExceptionTest2()470   public void deleteDatasetExceptionTest2() throws Exception {
471     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
472     mockAutoMl.addException(exception);
473 
474     try {
475       String name = "name3373707";
476       client.deleteDatasetAsync(name).get();
477       Assert.fail("No exception raised");
478     } catch (ExecutionException e) {
479       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
480       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
481       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
482     }
483   }
484 
485   @Test
importDataTest()486   public void importDataTest() throws Exception {
487     Empty expectedResponse = Empty.newBuilder().build();
488     Operation resultOperation =
489         Operation.newBuilder()
490             .setName("importDataTest")
491             .setDone(true)
492             .setResponse(Any.pack(expectedResponse))
493             .build();
494     mockAutoMl.addResponse(resultOperation);
495 
496     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
497     InputConfig inputConfig = InputConfig.newBuilder().build();
498 
499     client.importDataAsync(name, inputConfig).get();
500 
501     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
502     Assert.assertEquals(1, actualRequests.size());
503     ImportDataRequest actualRequest = ((ImportDataRequest) actualRequests.get(0));
504 
505     Assert.assertEquals(name.toString(), actualRequest.getName());
506     Assert.assertEquals(inputConfig, actualRequest.getInputConfig());
507     Assert.assertTrue(
508         channelProvider.isHeaderSent(
509             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
510             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
511   }
512 
513   @Test
importDataExceptionTest()514   public void importDataExceptionTest() throws Exception {
515     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
516     mockAutoMl.addException(exception);
517 
518     try {
519       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
520       InputConfig inputConfig = InputConfig.newBuilder().build();
521       client.importDataAsync(name, inputConfig).get();
522       Assert.fail("No exception raised");
523     } catch (ExecutionException e) {
524       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
525       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
526       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
527     }
528   }
529 
530   @Test
importDataTest2()531   public void importDataTest2() throws Exception {
532     Empty expectedResponse = Empty.newBuilder().build();
533     Operation resultOperation =
534         Operation.newBuilder()
535             .setName("importDataTest")
536             .setDone(true)
537             .setResponse(Any.pack(expectedResponse))
538             .build();
539     mockAutoMl.addResponse(resultOperation);
540 
541     String name = "name3373707";
542     InputConfig inputConfig = InputConfig.newBuilder().build();
543 
544     client.importDataAsync(name, inputConfig).get();
545 
546     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
547     Assert.assertEquals(1, actualRequests.size());
548     ImportDataRequest actualRequest = ((ImportDataRequest) actualRequests.get(0));
549 
550     Assert.assertEquals(name, actualRequest.getName());
551     Assert.assertEquals(inputConfig, actualRequest.getInputConfig());
552     Assert.assertTrue(
553         channelProvider.isHeaderSent(
554             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
555             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
556   }
557 
558   @Test
importDataExceptionTest2()559   public void importDataExceptionTest2() throws Exception {
560     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
561     mockAutoMl.addException(exception);
562 
563     try {
564       String name = "name3373707";
565       InputConfig inputConfig = InputConfig.newBuilder().build();
566       client.importDataAsync(name, inputConfig).get();
567       Assert.fail("No exception raised");
568     } catch (ExecutionException e) {
569       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
570       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
571       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
572     }
573   }
574 
575   @Test
exportDataTest()576   public void exportDataTest() throws Exception {
577     Empty expectedResponse = Empty.newBuilder().build();
578     Operation resultOperation =
579         Operation.newBuilder()
580             .setName("exportDataTest")
581             .setDone(true)
582             .setResponse(Any.pack(expectedResponse))
583             .build();
584     mockAutoMl.addResponse(resultOperation);
585 
586     DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
587     OutputConfig outputConfig = OutputConfig.newBuilder().build();
588 
589     client.exportDataAsync(name, outputConfig).get();
590 
591     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
592     Assert.assertEquals(1, actualRequests.size());
593     ExportDataRequest actualRequest = ((ExportDataRequest) actualRequests.get(0));
594 
595     Assert.assertEquals(name.toString(), actualRequest.getName());
596     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
597     Assert.assertTrue(
598         channelProvider.isHeaderSent(
599             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
600             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
601   }
602 
603   @Test
exportDataExceptionTest()604   public void exportDataExceptionTest() throws Exception {
605     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
606     mockAutoMl.addException(exception);
607 
608     try {
609       DatasetName name = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
610       OutputConfig outputConfig = OutputConfig.newBuilder().build();
611       client.exportDataAsync(name, outputConfig).get();
612       Assert.fail("No exception raised");
613     } catch (ExecutionException e) {
614       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
615       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
616       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
617     }
618   }
619 
620   @Test
exportDataTest2()621   public void exportDataTest2() throws Exception {
622     Empty expectedResponse = Empty.newBuilder().build();
623     Operation resultOperation =
624         Operation.newBuilder()
625             .setName("exportDataTest")
626             .setDone(true)
627             .setResponse(Any.pack(expectedResponse))
628             .build();
629     mockAutoMl.addResponse(resultOperation);
630 
631     String name = "name3373707";
632     OutputConfig outputConfig = OutputConfig.newBuilder().build();
633 
634     client.exportDataAsync(name, outputConfig).get();
635 
636     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
637     Assert.assertEquals(1, actualRequests.size());
638     ExportDataRequest actualRequest = ((ExportDataRequest) actualRequests.get(0));
639 
640     Assert.assertEquals(name, actualRequest.getName());
641     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
642     Assert.assertTrue(
643         channelProvider.isHeaderSent(
644             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
645             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
646   }
647 
648   @Test
exportDataExceptionTest2()649   public void exportDataExceptionTest2() throws Exception {
650     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
651     mockAutoMl.addException(exception);
652 
653     try {
654       String name = "name3373707";
655       OutputConfig outputConfig = OutputConfig.newBuilder().build();
656       client.exportDataAsync(name, outputConfig).get();
657       Assert.fail("No exception raised");
658     } catch (ExecutionException e) {
659       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
660       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
661       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
662     }
663   }
664 
665   @Test
getAnnotationSpecTest()666   public void getAnnotationSpecTest() throws Exception {
667     AnnotationSpec expectedResponse =
668         AnnotationSpec.newBuilder()
669             .setName(
670                 AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]")
671                     .toString())
672             .setDisplayName("displayName1714148973")
673             .setExampleCount(1517063674)
674             .build();
675     mockAutoMl.addResponse(expectedResponse);
676 
677     AnnotationSpecName name =
678         AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]");
679 
680     AnnotationSpec actualResponse = client.getAnnotationSpec(name);
681     Assert.assertEquals(expectedResponse, actualResponse);
682 
683     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
684     Assert.assertEquals(1, actualRequests.size());
685     GetAnnotationSpecRequest actualRequest = ((GetAnnotationSpecRequest) actualRequests.get(0));
686 
687     Assert.assertEquals(name.toString(), actualRequest.getName());
688     Assert.assertTrue(
689         channelProvider.isHeaderSent(
690             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
691             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
692   }
693 
694   @Test
getAnnotationSpecExceptionTest()695   public void getAnnotationSpecExceptionTest() throws Exception {
696     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
697     mockAutoMl.addException(exception);
698 
699     try {
700       AnnotationSpecName name =
701           AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]");
702       client.getAnnotationSpec(name);
703       Assert.fail("No exception raised");
704     } catch (InvalidArgumentException e) {
705       // Expected exception.
706     }
707   }
708 
709   @Test
getAnnotationSpecTest2()710   public void getAnnotationSpecTest2() throws Exception {
711     AnnotationSpec expectedResponse =
712         AnnotationSpec.newBuilder()
713             .setName(
714                 AnnotationSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[ANNOTATION_SPEC]")
715                     .toString())
716             .setDisplayName("displayName1714148973")
717             .setExampleCount(1517063674)
718             .build();
719     mockAutoMl.addResponse(expectedResponse);
720 
721     String name = "name3373707";
722 
723     AnnotationSpec actualResponse = client.getAnnotationSpec(name);
724     Assert.assertEquals(expectedResponse, actualResponse);
725 
726     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
727     Assert.assertEquals(1, actualRequests.size());
728     GetAnnotationSpecRequest actualRequest = ((GetAnnotationSpecRequest) actualRequests.get(0));
729 
730     Assert.assertEquals(name, actualRequest.getName());
731     Assert.assertTrue(
732         channelProvider.isHeaderSent(
733             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
734             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
735   }
736 
737   @Test
getAnnotationSpecExceptionTest2()738   public void getAnnotationSpecExceptionTest2() throws Exception {
739     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
740     mockAutoMl.addException(exception);
741 
742     try {
743       String name = "name3373707";
744       client.getAnnotationSpec(name);
745       Assert.fail("No exception raised");
746     } catch (InvalidArgumentException e) {
747       // Expected exception.
748     }
749   }
750 
751   @Test
getTableSpecTest()752   public void getTableSpecTest() throws Exception {
753     TableSpec expectedResponse =
754         TableSpec.newBuilder()
755             .setName(
756                 TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]").toString())
757             .setTimeColumnSpecId("timeColumnSpecId1156268185")
758             .setRowCount(1340416618)
759             .setValidRowCount(-406068761)
760             .setColumnCount(-122671386)
761             .addAllInputConfigs(new ArrayList<InputConfig>())
762             .setEtag("etag3123477")
763             .build();
764     mockAutoMl.addResponse(expectedResponse);
765 
766     TableSpecName name = TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]");
767 
768     TableSpec actualResponse = client.getTableSpec(name);
769     Assert.assertEquals(expectedResponse, actualResponse);
770 
771     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
772     Assert.assertEquals(1, actualRequests.size());
773     GetTableSpecRequest actualRequest = ((GetTableSpecRequest) actualRequests.get(0));
774 
775     Assert.assertEquals(name.toString(), actualRequest.getName());
776     Assert.assertTrue(
777         channelProvider.isHeaderSent(
778             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
779             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
780   }
781 
782   @Test
getTableSpecExceptionTest()783   public void getTableSpecExceptionTest() throws Exception {
784     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
785     mockAutoMl.addException(exception);
786 
787     try {
788       TableSpecName name = TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]");
789       client.getTableSpec(name);
790       Assert.fail("No exception raised");
791     } catch (InvalidArgumentException e) {
792       // Expected exception.
793     }
794   }
795 
796   @Test
getTableSpecTest2()797   public void getTableSpecTest2() throws Exception {
798     TableSpec expectedResponse =
799         TableSpec.newBuilder()
800             .setName(
801                 TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]").toString())
802             .setTimeColumnSpecId("timeColumnSpecId1156268185")
803             .setRowCount(1340416618)
804             .setValidRowCount(-406068761)
805             .setColumnCount(-122671386)
806             .addAllInputConfigs(new ArrayList<InputConfig>())
807             .setEtag("etag3123477")
808             .build();
809     mockAutoMl.addResponse(expectedResponse);
810 
811     String name = "name3373707";
812 
813     TableSpec actualResponse = client.getTableSpec(name);
814     Assert.assertEquals(expectedResponse, actualResponse);
815 
816     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
817     Assert.assertEquals(1, actualRequests.size());
818     GetTableSpecRequest actualRequest = ((GetTableSpecRequest) actualRequests.get(0));
819 
820     Assert.assertEquals(name, actualRequest.getName());
821     Assert.assertTrue(
822         channelProvider.isHeaderSent(
823             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
824             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
825   }
826 
827   @Test
getTableSpecExceptionTest2()828   public void getTableSpecExceptionTest2() throws Exception {
829     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
830     mockAutoMl.addException(exception);
831 
832     try {
833       String name = "name3373707";
834       client.getTableSpec(name);
835       Assert.fail("No exception raised");
836     } catch (InvalidArgumentException e) {
837       // Expected exception.
838     }
839   }
840 
841   @Test
listTableSpecsTest()842   public void listTableSpecsTest() throws Exception {
843     TableSpec responsesElement = TableSpec.newBuilder().build();
844     ListTableSpecsResponse expectedResponse =
845         ListTableSpecsResponse.newBuilder()
846             .setNextPageToken("")
847             .addAllTableSpecs(Arrays.asList(responsesElement))
848             .build();
849     mockAutoMl.addResponse(expectedResponse);
850 
851     DatasetName parent = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
852 
853     ListTableSpecsPagedResponse pagedListResponse = client.listTableSpecs(parent);
854 
855     List<TableSpec> resources = Lists.newArrayList(pagedListResponse.iterateAll());
856 
857     Assert.assertEquals(1, resources.size());
858     Assert.assertEquals(expectedResponse.getTableSpecsList().get(0), resources.get(0));
859 
860     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
861     Assert.assertEquals(1, actualRequests.size());
862     ListTableSpecsRequest actualRequest = ((ListTableSpecsRequest) actualRequests.get(0));
863 
864     Assert.assertEquals(parent.toString(), actualRequest.getParent());
865     Assert.assertTrue(
866         channelProvider.isHeaderSent(
867             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
868             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
869   }
870 
871   @Test
listTableSpecsExceptionTest()872   public void listTableSpecsExceptionTest() throws Exception {
873     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
874     mockAutoMl.addException(exception);
875 
876     try {
877       DatasetName parent = DatasetName.of("[PROJECT]", "[LOCATION]", "[DATASET]");
878       client.listTableSpecs(parent);
879       Assert.fail("No exception raised");
880     } catch (InvalidArgumentException e) {
881       // Expected exception.
882     }
883   }
884 
885   @Test
listTableSpecsTest2()886   public void listTableSpecsTest2() throws Exception {
887     TableSpec responsesElement = TableSpec.newBuilder().build();
888     ListTableSpecsResponse expectedResponse =
889         ListTableSpecsResponse.newBuilder()
890             .setNextPageToken("")
891             .addAllTableSpecs(Arrays.asList(responsesElement))
892             .build();
893     mockAutoMl.addResponse(expectedResponse);
894 
895     String parent = "parent-995424086";
896 
897     ListTableSpecsPagedResponse pagedListResponse = client.listTableSpecs(parent);
898 
899     List<TableSpec> resources = Lists.newArrayList(pagedListResponse.iterateAll());
900 
901     Assert.assertEquals(1, resources.size());
902     Assert.assertEquals(expectedResponse.getTableSpecsList().get(0), resources.get(0));
903 
904     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
905     Assert.assertEquals(1, actualRequests.size());
906     ListTableSpecsRequest actualRequest = ((ListTableSpecsRequest) actualRequests.get(0));
907 
908     Assert.assertEquals(parent, actualRequest.getParent());
909     Assert.assertTrue(
910         channelProvider.isHeaderSent(
911             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
912             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
913   }
914 
915   @Test
listTableSpecsExceptionTest2()916   public void listTableSpecsExceptionTest2() throws Exception {
917     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
918     mockAutoMl.addException(exception);
919 
920     try {
921       String parent = "parent-995424086";
922       client.listTableSpecs(parent);
923       Assert.fail("No exception raised");
924     } catch (InvalidArgumentException e) {
925       // Expected exception.
926     }
927   }
928 
929   @Test
updateTableSpecTest()930   public void updateTableSpecTest() throws Exception {
931     TableSpec expectedResponse =
932         TableSpec.newBuilder()
933             .setName(
934                 TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]").toString())
935             .setTimeColumnSpecId("timeColumnSpecId1156268185")
936             .setRowCount(1340416618)
937             .setValidRowCount(-406068761)
938             .setColumnCount(-122671386)
939             .addAllInputConfigs(new ArrayList<InputConfig>())
940             .setEtag("etag3123477")
941             .build();
942     mockAutoMl.addResponse(expectedResponse);
943 
944     TableSpec tableSpec = TableSpec.newBuilder().build();
945 
946     TableSpec actualResponse = client.updateTableSpec(tableSpec);
947     Assert.assertEquals(expectedResponse, actualResponse);
948 
949     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
950     Assert.assertEquals(1, actualRequests.size());
951     UpdateTableSpecRequest actualRequest = ((UpdateTableSpecRequest) actualRequests.get(0));
952 
953     Assert.assertEquals(tableSpec, actualRequest.getTableSpec());
954     Assert.assertTrue(
955         channelProvider.isHeaderSent(
956             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
957             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
958   }
959 
960   @Test
updateTableSpecExceptionTest()961   public void updateTableSpecExceptionTest() throws Exception {
962     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
963     mockAutoMl.addException(exception);
964 
965     try {
966       TableSpec tableSpec = TableSpec.newBuilder().build();
967       client.updateTableSpec(tableSpec);
968       Assert.fail("No exception raised");
969     } catch (InvalidArgumentException e) {
970       // Expected exception.
971     }
972   }
973 
974   @Test
getColumnSpecTest()975   public void getColumnSpecTest() throws Exception {
976     ColumnSpec expectedResponse =
977         ColumnSpec.newBuilder()
978             .setName(
979                 ColumnSpecName.of(
980                         "[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]", "[COLUMN_SPEC]")
981                     .toString())
982             .setDataType(DataType.newBuilder().build())
983             .setDisplayName("displayName1714148973")
984             .setDataStats(DataStats.newBuilder().build())
985             .addAllTopCorrelatedColumns(new ArrayList<ColumnSpec.CorrelatedColumn>())
986             .setEtag("etag3123477")
987             .build();
988     mockAutoMl.addResponse(expectedResponse);
989 
990     ColumnSpecName name =
991         ColumnSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]", "[COLUMN_SPEC]");
992 
993     ColumnSpec actualResponse = client.getColumnSpec(name);
994     Assert.assertEquals(expectedResponse, actualResponse);
995 
996     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
997     Assert.assertEquals(1, actualRequests.size());
998     GetColumnSpecRequest actualRequest = ((GetColumnSpecRequest) actualRequests.get(0));
999 
1000     Assert.assertEquals(name.toString(), actualRequest.getName());
1001     Assert.assertTrue(
1002         channelProvider.isHeaderSent(
1003             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1004             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1005   }
1006 
1007   @Test
getColumnSpecExceptionTest()1008   public void getColumnSpecExceptionTest() throws Exception {
1009     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1010     mockAutoMl.addException(exception);
1011 
1012     try {
1013       ColumnSpecName name =
1014           ColumnSpecName.of(
1015               "[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]", "[COLUMN_SPEC]");
1016       client.getColumnSpec(name);
1017       Assert.fail("No exception raised");
1018     } catch (InvalidArgumentException e) {
1019       // Expected exception.
1020     }
1021   }
1022 
1023   @Test
getColumnSpecTest2()1024   public void getColumnSpecTest2() throws Exception {
1025     ColumnSpec expectedResponse =
1026         ColumnSpec.newBuilder()
1027             .setName(
1028                 ColumnSpecName.of(
1029                         "[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]", "[COLUMN_SPEC]")
1030                     .toString())
1031             .setDataType(DataType.newBuilder().build())
1032             .setDisplayName("displayName1714148973")
1033             .setDataStats(DataStats.newBuilder().build())
1034             .addAllTopCorrelatedColumns(new ArrayList<ColumnSpec.CorrelatedColumn>())
1035             .setEtag("etag3123477")
1036             .build();
1037     mockAutoMl.addResponse(expectedResponse);
1038 
1039     String name = "name3373707";
1040 
1041     ColumnSpec actualResponse = client.getColumnSpec(name);
1042     Assert.assertEquals(expectedResponse, actualResponse);
1043 
1044     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1045     Assert.assertEquals(1, actualRequests.size());
1046     GetColumnSpecRequest actualRequest = ((GetColumnSpecRequest) actualRequests.get(0));
1047 
1048     Assert.assertEquals(name, actualRequest.getName());
1049     Assert.assertTrue(
1050         channelProvider.isHeaderSent(
1051             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1052             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1053   }
1054 
1055   @Test
getColumnSpecExceptionTest2()1056   public void getColumnSpecExceptionTest2() throws Exception {
1057     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1058     mockAutoMl.addException(exception);
1059 
1060     try {
1061       String name = "name3373707";
1062       client.getColumnSpec(name);
1063       Assert.fail("No exception raised");
1064     } catch (InvalidArgumentException e) {
1065       // Expected exception.
1066     }
1067   }
1068 
1069   @Test
listColumnSpecsTest()1070   public void listColumnSpecsTest() throws Exception {
1071     ColumnSpec responsesElement = ColumnSpec.newBuilder().build();
1072     ListColumnSpecsResponse expectedResponse =
1073         ListColumnSpecsResponse.newBuilder()
1074             .setNextPageToken("")
1075             .addAllColumnSpecs(Arrays.asList(responsesElement))
1076             .build();
1077     mockAutoMl.addResponse(expectedResponse);
1078 
1079     TableSpecName parent = TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]");
1080 
1081     ListColumnSpecsPagedResponse pagedListResponse = client.listColumnSpecs(parent);
1082 
1083     List<ColumnSpec> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1084 
1085     Assert.assertEquals(1, resources.size());
1086     Assert.assertEquals(expectedResponse.getColumnSpecsList().get(0), resources.get(0));
1087 
1088     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1089     Assert.assertEquals(1, actualRequests.size());
1090     ListColumnSpecsRequest actualRequest = ((ListColumnSpecsRequest) actualRequests.get(0));
1091 
1092     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1093     Assert.assertTrue(
1094         channelProvider.isHeaderSent(
1095             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1096             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1097   }
1098 
1099   @Test
listColumnSpecsExceptionTest()1100   public void listColumnSpecsExceptionTest() throws Exception {
1101     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1102     mockAutoMl.addException(exception);
1103 
1104     try {
1105       TableSpecName parent =
1106           TableSpecName.of("[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]");
1107       client.listColumnSpecs(parent);
1108       Assert.fail("No exception raised");
1109     } catch (InvalidArgumentException e) {
1110       // Expected exception.
1111     }
1112   }
1113 
1114   @Test
listColumnSpecsTest2()1115   public void listColumnSpecsTest2() throws Exception {
1116     ColumnSpec responsesElement = ColumnSpec.newBuilder().build();
1117     ListColumnSpecsResponse expectedResponse =
1118         ListColumnSpecsResponse.newBuilder()
1119             .setNextPageToken("")
1120             .addAllColumnSpecs(Arrays.asList(responsesElement))
1121             .build();
1122     mockAutoMl.addResponse(expectedResponse);
1123 
1124     String parent = "parent-995424086";
1125 
1126     ListColumnSpecsPagedResponse pagedListResponse = client.listColumnSpecs(parent);
1127 
1128     List<ColumnSpec> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1129 
1130     Assert.assertEquals(1, resources.size());
1131     Assert.assertEquals(expectedResponse.getColumnSpecsList().get(0), resources.get(0));
1132 
1133     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1134     Assert.assertEquals(1, actualRequests.size());
1135     ListColumnSpecsRequest actualRequest = ((ListColumnSpecsRequest) actualRequests.get(0));
1136 
1137     Assert.assertEquals(parent, actualRequest.getParent());
1138     Assert.assertTrue(
1139         channelProvider.isHeaderSent(
1140             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1141             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1142   }
1143 
1144   @Test
listColumnSpecsExceptionTest2()1145   public void listColumnSpecsExceptionTest2() throws Exception {
1146     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1147     mockAutoMl.addException(exception);
1148 
1149     try {
1150       String parent = "parent-995424086";
1151       client.listColumnSpecs(parent);
1152       Assert.fail("No exception raised");
1153     } catch (InvalidArgumentException e) {
1154       // Expected exception.
1155     }
1156   }
1157 
1158   @Test
updateColumnSpecTest()1159   public void updateColumnSpecTest() throws Exception {
1160     ColumnSpec expectedResponse =
1161         ColumnSpec.newBuilder()
1162             .setName(
1163                 ColumnSpecName.of(
1164                         "[PROJECT]", "[LOCATION]", "[DATASET]", "[TABLE_SPEC]", "[COLUMN_SPEC]")
1165                     .toString())
1166             .setDataType(DataType.newBuilder().build())
1167             .setDisplayName("displayName1714148973")
1168             .setDataStats(DataStats.newBuilder().build())
1169             .addAllTopCorrelatedColumns(new ArrayList<ColumnSpec.CorrelatedColumn>())
1170             .setEtag("etag3123477")
1171             .build();
1172     mockAutoMl.addResponse(expectedResponse);
1173 
1174     ColumnSpec columnSpec = ColumnSpec.newBuilder().build();
1175 
1176     ColumnSpec actualResponse = client.updateColumnSpec(columnSpec);
1177     Assert.assertEquals(expectedResponse, actualResponse);
1178 
1179     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1180     Assert.assertEquals(1, actualRequests.size());
1181     UpdateColumnSpecRequest actualRequest = ((UpdateColumnSpecRequest) actualRequests.get(0));
1182 
1183     Assert.assertEquals(columnSpec, actualRequest.getColumnSpec());
1184     Assert.assertTrue(
1185         channelProvider.isHeaderSent(
1186             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1187             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1188   }
1189 
1190   @Test
updateColumnSpecExceptionTest()1191   public void updateColumnSpecExceptionTest() throws Exception {
1192     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1193     mockAutoMl.addException(exception);
1194 
1195     try {
1196       ColumnSpec columnSpec = ColumnSpec.newBuilder().build();
1197       client.updateColumnSpec(columnSpec);
1198       Assert.fail("No exception raised");
1199     } catch (InvalidArgumentException e) {
1200       // Expected exception.
1201     }
1202   }
1203 
1204   @Test
createModelTest()1205   public void createModelTest() throws Exception {
1206     Model expectedResponse =
1207         Model.newBuilder()
1208             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
1209             .setDisplayName("displayName1714148973")
1210             .setDatasetId("datasetId-345342029")
1211             .setCreateTime(Timestamp.newBuilder().build())
1212             .setUpdateTime(Timestamp.newBuilder().build())
1213             .build();
1214     Operation resultOperation =
1215         Operation.newBuilder()
1216             .setName("createModelTest")
1217             .setDone(true)
1218             .setResponse(Any.pack(expectedResponse))
1219             .build();
1220     mockAutoMl.addResponse(resultOperation);
1221 
1222     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1223     Model model = Model.newBuilder().build();
1224 
1225     Model actualResponse = client.createModelAsync(parent, model).get();
1226     Assert.assertEquals(expectedResponse, actualResponse);
1227 
1228     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1229     Assert.assertEquals(1, actualRequests.size());
1230     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
1231 
1232     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1233     Assert.assertEquals(model, actualRequest.getModel());
1234     Assert.assertTrue(
1235         channelProvider.isHeaderSent(
1236             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1237             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1238   }
1239 
1240   @Test
createModelExceptionTest()1241   public void createModelExceptionTest() throws Exception {
1242     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1243     mockAutoMl.addException(exception);
1244 
1245     try {
1246       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1247       Model model = Model.newBuilder().build();
1248       client.createModelAsync(parent, model).get();
1249       Assert.fail("No exception raised");
1250     } catch (ExecutionException e) {
1251       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1252       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1253       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1254     }
1255   }
1256 
1257   @Test
createModelTest2()1258   public void createModelTest2() throws Exception {
1259     Model expectedResponse =
1260         Model.newBuilder()
1261             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
1262             .setDisplayName("displayName1714148973")
1263             .setDatasetId("datasetId-345342029")
1264             .setCreateTime(Timestamp.newBuilder().build())
1265             .setUpdateTime(Timestamp.newBuilder().build())
1266             .build();
1267     Operation resultOperation =
1268         Operation.newBuilder()
1269             .setName("createModelTest")
1270             .setDone(true)
1271             .setResponse(Any.pack(expectedResponse))
1272             .build();
1273     mockAutoMl.addResponse(resultOperation);
1274 
1275     String parent = "parent-995424086";
1276     Model model = Model.newBuilder().build();
1277 
1278     Model actualResponse = client.createModelAsync(parent, model).get();
1279     Assert.assertEquals(expectedResponse, actualResponse);
1280 
1281     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1282     Assert.assertEquals(1, actualRequests.size());
1283     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
1284 
1285     Assert.assertEquals(parent, actualRequest.getParent());
1286     Assert.assertEquals(model, actualRequest.getModel());
1287     Assert.assertTrue(
1288         channelProvider.isHeaderSent(
1289             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1290             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1291   }
1292 
1293   @Test
createModelExceptionTest2()1294   public void createModelExceptionTest2() throws Exception {
1295     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1296     mockAutoMl.addException(exception);
1297 
1298     try {
1299       String parent = "parent-995424086";
1300       Model model = Model.newBuilder().build();
1301       client.createModelAsync(parent, model).get();
1302       Assert.fail("No exception raised");
1303     } catch (ExecutionException e) {
1304       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1305       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1306       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1307     }
1308   }
1309 
1310   @Test
getModelTest()1311   public void getModelTest() throws Exception {
1312     Model expectedResponse =
1313         Model.newBuilder()
1314             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
1315             .setDisplayName("displayName1714148973")
1316             .setDatasetId("datasetId-345342029")
1317             .setCreateTime(Timestamp.newBuilder().build())
1318             .setUpdateTime(Timestamp.newBuilder().build())
1319             .build();
1320     mockAutoMl.addResponse(expectedResponse);
1321 
1322     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1323 
1324     Model actualResponse = client.getModel(name);
1325     Assert.assertEquals(expectedResponse, actualResponse);
1326 
1327     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1328     Assert.assertEquals(1, actualRequests.size());
1329     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
1330 
1331     Assert.assertEquals(name.toString(), actualRequest.getName());
1332     Assert.assertTrue(
1333         channelProvider.isHeaderSent(
1334             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1335             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1336   }
1337 
1338   @Test
getModelExceptionTest()1339   public void getModelExceptionTest() throws Exception {
1340     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1341     mockAutoMl.addException(exception);
1342 
1343     try {
1344       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1345       client.getModel(name);
1346       Assert.fail("No exception raised");
1347     } catch (InvalidArgumentException e) {
1348       // Expected exception.
1349     }
1350   }
1351 
1352   @Test
getModelTest2()1353   public void getModelTest2() throws Exception {
1354     Model expectedResponse =
1355         Model.newBuilder()
1356             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]").toString())
1357             .setDisplayName("displayName1714148973")
1358             .setDatasetId("datasetId-345342029")
1359             .setCreateTime(Timestamp.newBuilder().build())
1360             .setUpdateTime(Timestamp.newBuilder().build())
1361             .build();
1362     mockAutoMl.addResponse(expectedResponse);
1363 
1364     String name = "name3373707";
1365 
1366     Model actualResponse = client.getModel(name);
1367     Assert.assertEquals(expectedResponse, actualResponse);
1368 
1369     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1370     Assert.assertEquals(1, actualRequests.size());
1371     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
1372 
1373     Assert.assertEquals(name, actualRequest.getName());
1374     Assert.assertTrue(
1375         channelProvider.isHeaderSent(
1376             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1377             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1378   }
1379 
1380   @Test
getModelExceptionTest2()1381   public void getModelExceptionTest2() throws Exception {
1382     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1383     mockAutoMl.addException(exception);
1384 
1385     try {
1386       String name = "name3373707";
1387       client.getModel(name);
1388       Assert.fail("No exception raised");
1389     } catch (InvalidArgumentException e) {
1390       // Expected exception.
1391     }
1392   }
1393 
1394   @Test
listModelsTest()1395   public void listModelsTest() throws Exception {
1396     Model responsesElement = Model.newBuilder().build();
1397     ListModelsResponse expectedResponse =
1398         ListModelsResponse.newBuilder()
1399             .setNextPageToken("")
1400             .addAllModel(Arrays.asList(responsesElement))
1401             .build();
1402     mockAutoMl.addResponse(expectedResponse);
1403 
1404     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1405 
1406     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
1407 
1408     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1409 
1410     Assert.assertEquals(1, resources.size());
1411     Assert.assertEquals(expectedResponse.getModelList().get(0), resources.get(0));
1412 
1413     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1414     Assert.assertEquals(1, actualRequests.size());
1415     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
1416 
1417     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1418     Assert.assertTrue(
1419         channelProvider.isHeaderSent(
1420             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1421             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1422   }
1423 
1424   @Test
listModelsExceptionTest()1425   public void listModelsExceptionTest() throws Exception {
1426     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1427     mockAutoMl.addException(exception);
1428 
1429     try {
1430       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1431       client.listModels(parent);
1432       Assert.fail("No exception raised");
1433     } catch (InvalidArgumentException e) {
1434       // Expected exception.
1435     }
1436   }
1437 
1438   @Test
listModelsTest2()1439   public void listModelsTest2() throws Exception {
1440     Model responsesElement = Model.newBuilder().build();
1441     ListModelsResponse expectedResponse =
1442         ListModelsResponse.newBuilder()
1443             .setNextPageToken("")
1444             .addAllModel(Arrays.asList(responsesElement))
1445             .build();
1446     mockAutoMl.addResponse(expectedResponse);
1447 
1448     String parent = "parent-995424086";
1449 
1450     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
1451 
1452     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1453 
1454     Assert.assertEquals(1, resources.size());
1455     Assert.assertEquals(expectedResponse.getModelList().get(0), resources.get(0));
1456 
1457     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1458     Assert.assertEquals(1, actualRequests.size());
1459     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
1460 
1461     Assert.assertEquals(parent, actualRequest.getParent());
1462     Assert.assertTrue(
1463         channelProvider.isHeaderSent(
1464             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1465             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1466   }
1467 
1468   @Test
listModelsExceptionTest2()1469   public void listModelsExceptionTest2() throws Exception {
1470     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1471     mockAutoMl.addException(exception);
1472 
1473     try {
1474       String parent = "parent-995424086";
1475       client.listModels(parent);
1476       Assert.fail("No exception raised");
1477     } catch (InvalidArgumentException e) {
1478       // Expected exception.
1479     }
1480   }
1481 
1482   @Test
deleteModelTest()1483   public void deleteModelTest() throws Exception {
1484     Empty expectedResponse = Empty.newBuilder().build();
1485     Operation resultOperation =
1486         Operation.newBuilder()
1487             .setName("deleteModelTest")
1488             .setDone(true)
1489             .setResponse(Any.pack(expectedResponse))
1490             .build();
1491     mockAutoMl.addResponse(resultOperation);
1492 
1493     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1494 
1495     client.deleteModelAsync(name).get();
1496 
1497     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1498     Assert.assertEquals(1, actualRequests.size());
1499     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
1500 
1501     Assert.assertEquals(name.toString(), actualRequest.getName());
1502     Assert.assertTrue(
1503         channelProvider.isHeaderSent(
1504             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1505             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1506   }
1507 
1508   @Test
deleteModelExceptionTest()1509   public void deleteModelExceptionTest() throws Exception {
1510     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1511     mockAutoMl.addException(exception);
1512 
1513     try {
1514       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1515       client.deleteModelAsync(name).get();
1516       Assert.fail("No exception raised");
1517     } catch (ExecutionException e) {
1518       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1519       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1520       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1521     }
1522   }
1523 
1524   @Test
deleteModelTest2()1525   public void deleteModelTest2() throws Exception {
1526     Empty expectedResponse = Empty.newBuilder().build();
1527     Operation resultOperation =
1528         Operation.newBuilder()
1529             .setName("deleteModelTest")
1530             .setDone(true)
1531             .setResponse(Any.pack(expectedResponse))
1532             .build();
1533     mockAutoMl.addResponse(resultOperation);
1534 
1535     String name = "name3373707";
1536 
1537     client.deleteModelAsync(name).get();
1538 
1539     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1540     Assert.assertEquals(1, actualRequests.size());
1541     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
1542 
1543     Assert.assertEquals(name, actualRequest.getName());
1544     Assert.assertTrue(
1545         channelProvider.isHeaderSent(
1546             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1547             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1548   }
1549 
1550   @Test
deleteModelExceptionTest2()1551   public void deleteModelExceptionTest2() throws Exception {
1552     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1553     mockAutoMl.addException(exception);
1554 
1555     try {
1556       String name = "name3373707";
1557       client.deleteModelAsync(name).get();
1558       Assert.fail("No exception raised");
1559     } catch (ExecutionException e) {
1560       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1561       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1562       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1563     }
1564   }
1565 
1566   @Test
deployModelTest()1567   public void deployModelTest() throws Exception {
1568     Empty expectedResponse = Empty.newBuilder().build();
1569     Operation resultOperation =
1570         Operation.newBuilder()
1571             .setName("deployModelTest")
1572             .setDone(true)
1573             .setResponse(Any.pack(expectedResponse))
1574             .build();
1575     mockAutoMl.addResponse(resultOperation);
1576 
1577     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1578 
1579     client.deployModelAsync(name).get();
1580 
1581     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1582     Assert.assertEquals(1, actualRequests.size());
1583     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
1584 
1585     Assert.assertEquals(name.toString(), actualRequest.getName());
1586     Assert.assertTrue(
1587         channelProvider.isHeaderSent(
1588             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1589             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1590   }
1591 
1592   @Test
deployModelExceptionTest()1593   public void deployModelExceptionTest() throws Exception {
1594     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1595     mockAutoMl.addException(exception);
1596 
1597     try {
1598       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1599       client.deployModelAsync(name).get();
1600       Assert.fail("No exception raised");
1601     } catch (ExecutionException e) {
1602       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1603       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1604       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1605     }
1606   }
1607 
1608   @Test
deployModelTest2()1609   public void deployModelTest2() throws Exception {
1610     Empty expectedResponse = Empty.newBuilder().build();
1611     Operation resultOperation =
1612         Operation.newBuilder()
1613             .setName("deployModelTest")
1614             .setDone(true)
1615             .setResponse(Any.pack(expectedResponse))
1616             .build();
1617     mockAutoMl.addResponse(resultOperation);
1618 
1619     String name = "name3373707";
1620 
1621     client.deployModelAsync(name).get();
1622 
1623     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1624     Assert.assertEquals(1, actualRequests.size());
1625     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
1626 
1627     Assert.assertEquals(name, actualRequest.getName());
1628     Assert.assertTrue(
1629         channelProvider.isHeaderSent(
1630             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1631             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1632   }
1633 
1634   @Test
deployModelExceptionTest2()1635   public void deployModelExceptionTest2() throws Exception {
1636     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1637     mockAutoMl.addException(exception);
1638 
1639     try {
1640       String name = "name3373707";
1641       client.deployModelAsync(name).get();
1642       Assert.fail("No exception raised");
1643     } catch (ExecutionException e) {
1644       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1645       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1646       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1647     }
1648   }
1649 
1650   @Test
undeployModelTest()1651   public void undeployModelTest() throws Exception {
1652     Empty expectedResponse = Empty.newBuilder().build();
1653     Operation resultOperation =
1654         Operation.newBuilder()
1655             .setName("undeployModelTest")
1656             .setDone(true)
1657             .setResponse(Any.pack(expectedResponse))
1658             .build();
1659     mockAutoMl.addResponse(resultOperation);
1660 
1661     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1662 
1663     client.undeployModelAsync(name).get();
1664 
1665     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1666     Assert.assertEquals(1, actualRequests.size());
1667     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
1668 
1669     Assert.assertEquals(name.toString(), actualRequest.getName());
1670     Assert.assertTrue(
1671         channelProvider.isHeaderSent(
1672             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1673             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1674   }
1675 
1676   @Test
undeployModelExceptionTest()1677   public void undeployModelExceptionTest() throws Exception {
1678     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1679     mockAutoMl.addException(exception);
1680 
1681     try {
1682       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1683       client.undeployModelAsync(name).get();
1684       Assert.fail("No exception raised");
1685     } catch (ExecutionException e) {
1686       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1687       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1688       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1689     }
1690   }
1691 
1692   @Test
undeployModelTest2()1693   public void undeployModelTest2() throws Exception {
1694     Empty expectedResponse = Empty.newBuilder().build();
1695     Operation resultOperation =
1696         Operation.newBuilder()
1697             .setName("undeployModelTest")
1698             .setDone(true)
1699             .setResponse(Any.pack(expectedResponse))
1700             .build();
1701     mockAutoMl.addResponse(resultOperation);
1702 
1703     String name = "name3373707";
1704 
1705     client.undeployModelAsync(name).get();
1706 
1707     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1708     Assert.assertEquals(1, actualRequests.size());
1709     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
1710 
1711     Assert.assertEquals(name, actualRequest.getName());
1712     Assert.assertTrue(
1713         channelProvider.isHeaderSent(
1714             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1715             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1716   }
1717 
1718   @Test
undeployModelExceptionTest2()1719   public void undeployModelExceptionTest2() throws Exception {
1720     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1721     mockAutoMl.addException(exception);
1722 
1723     try {
1724       String name = "name3373707";
1725       client.undeployModelAsync(name).get();
1726       Assert.fail("No exception raised");
1727     } catch (ExecutionException e) {
1728       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1729       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1730       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1731     }
1732   }
1733 
1734   @Test
exportModelTest()1735   public void exportModelTest() throws Exception {
1736     Empty expectedResponse = Empty.newBuilder().build();
1737     Operation resultOperation =
1738         Operation.newBuilder()
1739             .setName("exportModelTest")
1740             .setDone(true)
1741             .setResponse(Any.pack(expectedResponse))
1742             .build();
1743     mockAutoMl.addResponse(resultOperation);
1744 
1745     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1746     ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1747 
1748     client.exportModelAsync(name, outputConfig).get();
1749 
1750     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1751     Assert.assertEquals(1, actualRequests.size());
1752     ExportModelRequest actualRequest = ((ExportModelRequest) actualRequests.get(0));
1753 
1754     Assert.assertEquals(name.toString(), actualRequest.getName());
1755     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1756     Assert.assertTrue(
1757         channelProvider.isHeaderSent(
1758             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1759             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1760   }
1761 
1762   @Test
exportModelExceptionTest()1763   public void exportModelExceptionTest() throws Exception {
1764     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1765     mockAutoMl.addException(exception);
1766 
1767     try {
1768       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1769       ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1770       client.exportModelAsync(name, outputConfig).get();
1771       Assert.fail("No exception raised");
1772     } catch (ExecutionException e) {
1773       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1774       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1775       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1776     }
1777   }
1778 
1779   @Test
exportModelTest2()1780   public void exportModelTest2() throws Exception {
1781     Empty expectedResponse = Empty.newBuilder().build();
1782     Operation resultOperation =
1783         Operation.newBuilder()
1784             .setName("exportModelTest")
1785             .setDone(true)
1786             .setResponse(Any.pack(expectedResponse))
1787             .build();
1788     mockAutoMl.addResponse(resultOperation);
1789 
1790     String name = "name3373707";
1791     ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1792 
1793     client.exportModelAsync(name, outputConfig).get();
1794 
1795     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1796     Assert.assertEquals(1, actualRequests.size());
1797     ExportModelRequest actualRequest = ((ExportModelRequest) actualRequests.get(0));
1798 
1799     Assert.assertEquals(name, actualRequest.getName());
1800     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1801     Assert.assertTrue(
1802         channelProvider.isHeaderSent(
1803             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1804             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1805   }
1806 
1807   @Test
exportModelExceptionTest2()1808   public void exportModelExceptionTest2() throws Exception {
1809     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1810     mockAutoMl.addException(exception);
1811 
1812     try {
1813       String name = "name3373707";
1814       ModelExportOutputConfig outputConfig = ModelExportOutputConfig.newBuilder().build();
1815       client.exportModelAsync(name, outputConfig).get();
1816       Assert.fail("No exception raised");
1817     } catch (ExecutionException e) {
1818       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1819       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1820       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1821     }
1822   }
1823 
1824   @Test
exportEvaluatedExamplesTest()1825   public void exportEvaluatedExamplesTest() throws Exception {
1826     Empty expectedResponse = Empty.newBuilder().build();
1827     Operation resultOperation =
1828         Operation.newBuilder()
1829             .setName("exportEvaluatedExamplesTest")
1830             .setDone(true)
1831             .setResponse(Any.pack(expectedResponse))
1832             .build();
1833     mockAutoMl.addResponse(resultOperation);
1834 
1835     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1836     ExportEvaluatedExamplesOutputConfig outputConfig =
1837         ExportEvaluatedExamplesOutputConfig.newBuilder().build();
1838 
1839     client.exportEvaluatedExamplesAsync(name, outputConfig).get();
1840 
1841     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1842     Assert.assertEquals(1, actualRequests.size());
1843     ExportEvaluatedExamplesRequest actualRequest =
1844         ((ExportEvaluatedExamplesRequest) actualRequests.get(0));
1845 
1846     Assert.assertEquals(name.toString(), actualRequest.getName());
1847     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1848     Assert.assertTrue(
1849         channelProvider.isHeaderSent(
1850             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1851             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1852   }
1853 
1854   @Test
exportEvaluatedExamplesExceptionTest()1855   public void exportEvaluatedExamplesExceptionTest() throws Exception {
1856     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1857     mockAutoMl.addException(exception);
1858 
1859     try {
1860       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
1861       ExportEvaluatedExamplesOutputConfig outputConfig =
1862           ExportEvaluatedExamplesOutputConfig.newBuilder().build();
1863       client.exportEvaluatedExamplesAsync(name, outputConfig).get();
1864       Assert.fail("No exception raised");
1865     } catch (ExecutionException e) {
1866       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1867       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1868       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1869     }
1870   }
1871 
1872   @Test
exportEvaluatedExamplesTest2()1873   public void exportEvaluatedExamplesTest2() throws Exception {
1874     Empty expectedResponse = Empty.newBuilder().build();
1875     Operation resultOperation =
1876         Operation.newBuilder()
1877             .setName("exportEvaluatedExamplesTest")
1878             .setDone(true)
1879             .setResponse(Any.pack(expectedResponse))
1880             .build();
1881     mockAutoMl.addResponse(resultOperation);
1882 
1883     String name = "name3373707";
1884     ExportEvaluatedExamplesOutputConfig outputConfig =
1885         ExportEvaluatedExamplesOutputConfig.newBuilder().build();
1886 
1887     client.exportEvaluatedExamplesAsync(name, outputConfig).get();
1888 
1889     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1890     Assert.assertEquals(1, actualRequests.size());
1891     ExportEvaluatedExamplesRequest actualRequest =
1892         ((ExportEvaluatedExamplesRequest) actualRequests.get(0));
1893 
1894     Assert.assertEquals(name, actualRequest.getName());
1895     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
1896     Assert.assertTrue(
1897         channelProvider.isHeaderSent(
1898             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1899             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1900   }
1901 
1902   @Test
exportEvaluatedExamplesExceptionTest2()1903   public void exportEvaluatedExamplesExceptionTest2() throws Exception {
1904     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1905     mockAutoMl.addException(exception);
1906 
1907     try {
1908       String name = "name3373707";
1909       ExportEvaluatedExamplesOutputConfig outputConfig =
1910           ExportEvaluatedExamplesOutputConfig.newBuilder().build();
1911       client.exportEvaluatedExamplesAsync(name, outputConfig).get();
1912       Assert.fail("No exception raised");
1913     } catch (ExecutionException e) {
1914       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1915       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1916       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1917     }
1918   }
1919 
1920   @Test
getModelEvaluationTest()1921   public void getModelEvaluationTest() throws Exception {
1922     ModelEvaluation expectedResponse =
1923         ModelEvaluation.newBuilder()
1924             .setName(
1925                 ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]")
1926                     .toString())
1927             .setAnnotationSpecId("annotationSpecId1320449605")
1928             .setDisplayName("displayName1714148973")
1929             .setCreateTime(Timestamp.newBuilder().build())
1930             .setEvaluatedExampleCount(277565350)
1931             .build();
1932     mockAutoMl.addResponse(expectedResponse);
1933 
1934     ModelEvaluationName name =
1935         ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]");
1936 
1937     ModelEvaluation actualResponse = client.getModelEvaluation(name);
1938     Assert.assertEquals(expectedResponse, actualResponse);
1939 
1940     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1941     Assert.assertEquals(1, actualRequests.size());
1942     GetModelEvaluationRequest actualRequest = ((GetModelEvaluationRequest) actualRequests.get(0));
1943 
1944     Assert.assertEquals(name.toString(), actualRequest.getName());
1945     Assert.assertTrue(
1946         channelProvider.isHeaderSent(
1947             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1948             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1949   }
1950 
1951   @Test
getModelEvaluationExceptionTest()1952   public void getModelEvaluationExceptionTest() throws Exception {
1953     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1954     mockAutoMl.addException(exception);
1955 
1956     try {
1957       ModelEvaluationName name =
1958           ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]");
1959       client.getModelEvaluation(name);
1960       Assert.fail("No exception raised");
1961     } catch (InvalidArgumentException e) {
1962       // Expected exception.
1963     }
1964   }
1965 
1966   @Test
getModelEvaluationTest2()1967   public void getModelEvaluationTest2() throws Exception {
1968     ModelEvaluation expectedResponse =
1969         ModelEvaluation.newBuilder()
1970             .setName(
1971                 ModelEvaluationName.of("[PROJECT]", "[LOCATION]", "[MODEL]", "[MODEL_EVALUATION]")
1972                     .toString())
1973             .setAnnotationSpecId("annotationSpecId1320449605")
1974             .setDisplayName("displayName1714148973")
1975             .setCreateTime(Timestamp.newBuilder().build())
1976             .setEvaluatedExampleCount(277565350)
1977             .build();
1978     mockAutoMl.addResponse(expectedResponse);
1979 
1980     String name = "name3373707";
1981 
1982     ModelEvaluation actualResponse = client.getModelEvaluation(name);
1983     Assert.assertEquals(expectedResponse, actualResponse);
1984 
1985     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
1986     Assert.assertEquals(1, actualRequests.size());
1987     GetModelEvaluationRequest actualRequest = ((GetModelEvaluationRequest) actualRequests.get(0));
1988 
1989     Assert.assertEquals(name, actualRequest.getName());
1990     Assert.assertTrue(
1991         channelProvider.isHeaderSent(
1992             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1993             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1994   }
1995 
1996   @Test
getModelEvaluationExceptionTest2()1997   public void getModelEvaluationExceptionTest2() throws Exception {
1998     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1999     mockAutoMl.addException(exception);
2000 
2001     try {
2002       String name = "name3373707";
2003       client.getModelEvaluation(name);
2004       Assert.fail("No exception raised");
2005     } catch (InvalidArgumentException e) {
2006       // Expected exception.
2007     }
2008   }
2009 
2010   @Test
listModelEvaluationsTest()2011   public void listModelEvaluationsTest() throws Exception {
2012     ModelEvaluation responsesElement = ModelEvaluation.newBuilder().build();
2013     ListModelEvaluationsResponse expectedResponse =
2014         ListModelEvaluationsResponse.newBuilder()
2015             .setNextPageToken("")
2016             .addAllModelEvaluation(Arrays.asList(responsesElement))
2017             .build();
2018     mockAutoMl.addResponse(expectedResponse);
2019 
2020     ModelName parent = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
2021 
2022     ListModelEvaluationsPagedResponse pagedListResponse = client.listModelEvaluations(parent);
2023 
2024     List<ModelEvaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2025 
2026     Assert.assertEquals(1, resources.size());
2027     Assert.assertEquals(expectedResponse.getModelEvaluationList().get(0), resources.get(0));
2028 
2029     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
2030     Assert.assertEquals(1, actualRequests.size());
2031     ListModelEvaluationsRequest actualRequest =
2032         ((ListModelEvaluationsRequest) actualRequests.get(0));
2033 
2034     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2035     Assert.assertTrue(
2036         channelProvider.isHeaderSent(
2037             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2038             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2039   }
2040 
2041   @Test
listModelEvaluationsExceptionTest()2042   public void listModelEvaluationsExceptionTest() throws Exception {
2043     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2044     mockAutoMl.addException(exception);
2045 
2046     try {
2047       ModelName parent = ModelName.of("[PROJECT]", "[LOCATION]", "[MODEL]");
2048       client.listModelEvaluations(parent);
2049       Assert.fail("No exception raised");
2050     } catch (InvalidArgumentException e) {
2051       // Expected exception.
2052     }
2053   }
2054 
2055   @Test
listModelEvaluationsTest2()2056   public void listModelEvaluationsTest2() throws Exception {
2057     ModelEvaluation responsesElement = ModelEvaluation.newBuilder().build();
2058     ListModelEvaluationsResponse expectedResponse =
2059         ListModelEvaluationsResponse.newBuilder()
2060             .setNextPageToken("")
2061             .addAllModelEvaluation(Arrays.asList(responsesElement))
2062             .build();
2063     mockAutoMl.addResponse(expectedResponse);
2064 
2065     String parent = "parent-995424086";
2066 
2067     ListModelEvaluationsPagedResponse pagedListResponse = client.listModelEvaluations(parent);
2068 
2069     List<ModelEvaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2070 
2071     Assert.assertEquals(1, resources.size());
2072     Assert.assertEquals(expectedResponse.getModelEvaluationList().get(0), resources.get(0));
2073 
2074     List<AbstractMessage> actualRequests = mockAutoMl.getRequests();
2075     Assert.assertEquals(1, actualRequests.size());
2076     ListModelEvaluationsRequest actualRequest =
2077         ((ListModelEvaluationsRequest) actualRequests.get(0));
2078 
2079     Assert.assertEquals(parent, actualRequest.getParent());
2080     Assert.assertTrue(
2081         channelProvider.isHeaderSent(
2082             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2083             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2084   }
2085 
2086   @Test
listModelEvaluationsExceptionTest2()2087   public void listModelEvaluationsExceptionTest2() throws Exception {
2088     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2089     mockAutoMl.addException(exception);
2090 
2091     try {
2092       String parent = "parent-995424086";
2093       client.listModelEvaluations(parent);
2094       Assert.fail("No exception raised");
2095     } catch (InvalidArgumentException e) {
2096       // Expected exception.
2097     }
2098   }
2099 }
2100