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