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