• 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.maps.mapsplatformdatasets.v1alpha;
18 
19 import static com.google.maps.mapsplatformdatasets.v1alpha.MapsPlatformDatasetsV1AlphaClient.ListDatasetVersionsPagedResponse;
20 import static com.google.maps.mapsplatformdatasets.v1alpha.MapsPlatformDatasetsV1AlphaClient.ListDatasetsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.common.collect.Lists;
32 import com.google.maps.mapsplatformdatasets.v1alpha.stub.HttpJsonMapsPlatformDatasetsV1AlphaStub;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Timestamp;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
40 import javax.annotation.Generated;
41 import org.junit.After;
42 import org.junit.AfterClass;
43 import org.junit.Assert;
44 import org.junit.Before;
45 import org.junit.BeforeClass;
46 import org.junit.Test;
47 
48 @Generated("by gapic-generator-java")
49 public class MapsPlatformDatasetsV1AlphaClientHttpJsonTest {
50   private static MockHttpService mockService;
51   private static MapsPlatformDatasetsV1AlphaClient client;
52 
53   @BeforeClass
startStaticServer()54   public static void startStaticServer() throws IOException {
55     mockService =
56         new MockHttpService(
57             HttpJsonMapsPlatformDatasetsV1AlphaStub.getMethodDescriptors(),
58             MapsPlatformDatasetsV1AlphaSettings.getDefaultEndpoint());
59     MapsPlatformDatasetsV1AlphaSettings settings =
60         MapsPlatformDatasetsV1AlphaSettings.newHttpJsonBuilder()
61             .setTransportChannelProvider(
62                 MapsPlatformDatasetsV1AlphaSettings.defaultHttpJsonTransportProviderBuilder()
63                     .setHttpTransport(mockService)
64                     .build())
65             .setCredentialsProvider(NoCredentialsProvider.create())
66             .build();
67     client = MapsPlatformDatasetsV1AlphaClient.create(settings);
68   }
69 
70   @AfterClass
stopServer()71   public static void stopServer() {
72     client.close();
73   }
74 
75   @Before
setUp()76   public void setUp() {}
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     mockService.reset();
81   }
82 
83   @Test
createDatasetTest()84   public void createDatasetTest() throws Exception {
85     Dataset expectedResponse =
86         Dataset.newBuilder()
87             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
88             .setDisplayName("displayName1714148973")
89             .setDescription("description-1724546052")
90             .setVersionId("versionId-1407102957")
91             .addAllUsage(new ArrayList<Usage>())
92             .setStatus(State.forNumber(0))
93             .setCreateTime(Timestamp.newBuilder().build())
94             .setUpdateTime(Timestamp.newBuilder().build())
95             .setVersionCreateTime(Timestamp.newBuilder().build())
96             .setVersionDescription("versionDescription-1736173564")
97             .build();
98     mockService.addResponse(expectedResponse);
99 
100     ProjectName parent = ProjectName.of("[PROJECT]");
101     Dataset dataset = Dataset.newBuilder().build();
102 
103     Dataset actualResponse = client.createDataset(parent, dataset);
104     Assert.assertEquals(expectedResponse, actualResponse);
105 
106     List<String> actualRequests = mockService.getRequestPaths();
107     Assert.assertEquals(1, actualRequests.size());
108 
109     String apiClientHeaderKey =
110         mockService
111             .getRequestHeaders()
112             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
113             .iterator()
114             .next();
115     Assert.assertTrue(
116         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
117             .matcher(apiClientHeaderKey)
118             .matches());
119   }
120 
121   @Test
createDatasetExceptionTest()122   public void createDatasetExceptionTest() throws Exception {
123     ApiException exception =
124         ApiExceptionFactory.createException(
125             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
126     mockService.addException(exception);
127 
128     try {
129       ProjectName parent = ProjectName.of("[PROJECT]");
130       Dataset dataset = Dataset.newBuilder().build();
131       client.createDataset(parent, dataset);
132       Assert.fail("No exception raised");
133     } catch (InvalidArgumentException e) {
134       // Expected exception.
135     }
136   }
137 
138   @Test
createDatasetTest2()139   public void createDatasetTest2() throws Exception {
140     Dataset expectedResponse =
141         Dataset.newBuilder()
142             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
143             .setDisplayName("displayName1714148973")
144             .setDescription("description-1724546052")
145             .setVersionId("versionId-1407102957")
146             .addAllUsage(new ArrayList<Usage>())
147             .setStatus(State.forNumber(0))
148             .setCreateTime(Timestamp.newBuilder().build())
149             .setUpdateTime(Timestamp.newBuilder().build())
150             .setVersionCreateTime(Timestamp.newBuilder().build())
151             .setVersionDescription("versionDescription-1736173564")
152             .build();
153     mockService.addResponse(expectedResponse);
154 
155     String parent = "projects/project-2353";
156     Dataset dataset = Dataset.newBuilder().build();
157 
158     Dataset actualResponse = client.createDataset(parent, dataset);
159     Assert.assertEquals(expectedResponse, actualResponse);
160 
161     List<String> actualRequests = mockService.getRequestPaths();
162     Assert.assertEquals(1, actualRequests.size());
163 
164     String apiClientHeaderKey =
165         mockService
166             .getRequestHeaders()
167             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
168             .iterator()
169             .next();
170     Assert.assertTrue(
171         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
172             .matcher(apiClientHeaderKey)
173             .matches());
174   }
175 
176   @Test
createDatasetExceptionTest2()177   public void createDatasetExceptionTest2() throws Exception {
178     ApiException exception =
179         ApiExceptionFactory.createException(
180             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
181     mockService.addException(exception);
182 
183     try {
184       String parent = "projects/project-2353";
185       Dataset dataset = Dataset.newBuilder().build();
186       client.createDataset(parent, dataset);
187       Assert.fail("No exception raised");
188     } catch (InvalidArgumentException e) {
189       // Expected exception.
190     }
191   }
192 
193   @Test
updateDatasetMetadataTest()194   public void updateDatasetMetadataTest() throws Exception {
195     Dataset expectedResponse =
196         Dataset.newBuilder()
197             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
198             .setDisplayName("displayName1714148973")
199             .setDescription("description-1724546052")
200             .setVersionId("versionId-1407102957")
201             .addAllUsage(new ArrayList<Usage>())
202             .setStatus(State.forNumber(0))
203             .setCreateTime(Timestamp.newBuilder().build())
204             .setUpdateTime(Timestamp.newBuilder().build())
205             .setVersionCreateTime(Timestamp.newBuilder().build())
206             .setVersionDescription("versionDescription-1736173564")
207             .build();
208     mockService.addResponse(expectedResponse);
209 
210     Dataset dataset =
211         Dataset.newBuilder()
212             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
213             .setDisplayName("displayName1714148973")
214             .setDescription("description-1724546052")
215             .setVersionId("versionId-1407102957")
216             .addAllUsage(new ArrayList<Usage>())
217             .setStatus(State.forNumber(0))
218             .setCreateTime(Timestamp.newBuilder().build())
219             .setUpdateTime(Timestamp.newBuilder().build())
220             .setVersionCreateTime(Timestamp.newBuilder().build())
221             .setVersionDescription("versionDescription-1736173564")
222             .build();
223     FieldMask updateMask = FieldMask.newBuilder().build();
224 
225     Dataset actualResponse = client.updateDatasetMetadata(dataset, updateMask);
226     Assert.assertEquals(expectedResponse, actualResponse);
227 
228     List<String> actualRequests = mockService.getRequestPaths();
229     Assert.assertEquals(1, actualRequests.size());
230 
231     String apiClientHeaderKey =
232         mockService
233             .getRequestHeaders()
234             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
235             .iterator()
236             .next();
237     Assert.assertTrue(
238         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
239             .matcher(apiClientHeaderKey)
240             .matches());
241   }
242 
243   @Test
updateDatasetMetadataExceptionTest()244   public void updateDatasetMetadataExceptionTest() throws Exception {
245     ApiException exception =
246         ApiExceptionFactory.createException(
247             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
248     mockService.addException(exception);
249 
250     try {
251       Dataset dataset =
252           Dataset.newBuilder()
253               .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
254               .setDisplayName("displayName1714148973")
255               .setDescription("description-1724546052")
256               .setVersionId("versionId-1407102957")
257               .addAllUsage(new ArrayList<Usage>())
258               .setStatus(State.forNumber(0))
259               .setCreateTime(Timestamp.newBuilder().build())
260               .setUpdateTime(Timestamp.newBuilder().build())
261               .setVersionCreateTime(Timestamp.newBuilder().build())
262               .setVersionDescription("versionDescription-1736173564")
263               .build();
264       FieldMask updateMask = FieldMask.newBuilder().build();
265       client.updateDatasetMetadata(dataset, updateMask);
266       Assert.fail("No exception raised");
267     } catch (InvalidArgumentException e) {
268       // Expected exception.
269     }
270   }
271 
272   @Test
getDatasetTest()273   public void getDatasetTest() throws Exception {
274     Dataset expectedResponse =
275         Dataset.newBuilder()
276             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
277             .setDisplayName("displayName1714148973")
278             .setDescription("description-1724546052")
279             .setVersionId("versionId-1407102957")
280             .addAllUsage(new ArrayList<Usage>())
281             .setStatus(State.forNumber(0))
282             .setCreateTime(Timestamp.newBuilder().build())
283             .setUpdateTime(Timestamp.newBuilder().build())
284             .setVersionCreateTime(Timestamp.newBuilder().build())
285             .setVersionDescription("versionDescription-1736173564")
286             .build();
287     mockService.addResponse(expectedResponse);
288 
289     DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
290 
291     Dataset actualResponse = client.getDataset(name);
292     Assert.assertEquals(expectedResponse, actualResponse);
293 
294     List<String> actualRequests = mockService.getRequestPaths();
295     Assert.assertEquals(1, actualRequests.size());
296 
297     String apiClientHeaderKey =
298         mockService
299             .getRequestHeaders()
300             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
301             .iterator()
302             .next();
303     Assert.assertTrue(
304         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
305             .matcher(apiClientHeaderKey)
306             .matches());
307   }
308 
309   @Test
getDatasetExceptionTest()310   public void getDatasetExceptionTest() throws Exception {
311     ApiException exception =
312         ApiExceptionFactory.createException(
313             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
314     mockService.addException(exception);
315 
316     try {
317       DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
318       client.getDataset(name);
319       Assert.fail("No exception raised");
320     } catch (InvalidArgumentException e) {
321       // Expected exception.
322     }
323   }
324 
325   @Test
getDatasetTest2()326   public void getDatasetTest2() throws Exception {
327     Dataset expectedResponse =
328         Dataset.newBuilder()
329             .setName(DatasetName.of("[PROJECT]", "[DATASET]").toString())
330             .setDisplayName("displayName1714148973")
331             .setDescription("description-1724546052")
332             .setVersionId("versionId-1407102957")
333             .addAllUsage(new ArrayList<Usage>())
334             .setStatus(State.forNumber(0))
335             .setCreateTime(Timestamp.newBuilder().build())
336             .setUpdateTime(Timestamp.newBuilder().build())
337             .setVersionCreateTime(Timestamp.newBuilder().build())
338             .setVersionDescription("versionDescription-1736173564")
339             .build();
340     mockService.addResponse(expectedResponse);
341 
342     String name = "projects/project-2277/datasets/dataset-2277";
343 
344     Dataset actualResponse = client.getDataset(name);
345     Assert.assertEquals(expectedResponse, actualResponse);
346 
347     List<String> actualRequests = mockService.getRequestPaths();
348     Assert.assertEquals(1, actualRequests.size());
349 
350     String apiClientHeaderKey =
351         mockService
352             .getRequestHeaders()
353             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
354             .iterator()
355             .next();
356     Assert.assertTrue(
357         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
358             .matcher(apiClientHeaderKey)
359             .matches());
360   }
361 
362   @Test
getDatasetExceptionTest2()363   public void getDatasetExceptionTest2() throws Exception {
364     ApiException exception =
365         ApiExceptionFactory.createException(
366             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
367     mockService.addException(exception);
368 
369     try {
370       String name = "projects/project-2277/datasets/dataset-2277";
371       client.getDataset(name);
372       Assert.fail("No exception raised");
373     } catch (InvalidArgumentException e) {
374       // Expected exception.
375     }
376   }
377 
378   @Test
listDatasetVersionsTest()379   public void listDatasetVersionsTest() throws Exception {
380     Dataset responsesElement = Dataset.newBuilder().build();
381     ListDatasetVersionsResponse expectedResponse =
382         ListDatasetVersionsResponse.newBuilder()
383             .setNextPageToken("")
384             .addAllDatasets(Arrays.asList(responsesElement))
385             .build();
386     mockService.addResponse(expectedResponse);
387 
388     DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
389 
390     ListDatasetVersionsPagedResponse pagedListResponse = client.listDatasetVersions(name);
391 
392     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
393 
394     Assert.assertEquals(1, resources.size());
395     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
396 
397     List<String> actualRequests = mockService.getRequestPaths();
398     Assert.assertEquals(1, actualRequests.size());
399 
400     String apiClientHeaderKey =
401         mockService
402             .getRequestHeaders()
403             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
404             .iterator()
405             .next();
406     Assert.assertTrue(
407         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
408             .matcher(apiClientHeaderKey)
409             .matches());
410   }
411 
412   @Test
listDatasetVersionsExceptionTest()413   public void listDatasetVersionsExceptionTest() throws Exception {
414     ApiException exception =
415         ApiExceptionFactory.createException(
416             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
417     mockService.addException(exception);
418 
419     try {
420       DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
421       client.listDatasetVersions(name);
422       Assert.fail("No exception raised");
423     } catch (InvalidArgumentException e) {
424       // Expected exception.
425     }
426   }
427 
428   @Test
listDatasetVersionsTest2()429   public void listDatasetVersionsTest2() throws Exception {
430     Dataset responsesElement = Dataset.newBuilder().build();
431     ListDatasetVersionsResponse expectedResponse =
432         ListDatasetVersionsResponse.newBuilder()
433             .setNextPageToken("")
434             .addAllDatasets(Arrays.asList(responsesElement))
435             .build();
436     mockService.addResponse(expectedResponse);
437 
438     String name = "projects/project-2277/datasets/dataset-2277";
439 
440     ListDatasetVersionsPagedResponse pagedListResponse = client.listDatasetVersions(name);
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<String> actualRequests = mockService.getRequestPaths();
448     Assert.assertEquals(1, actualRequests.size());
449 
450     String apiClientHeaderKey =
451         mockService
452             .getRequestHeaders()
453             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
454             .iterator()
455             .next();
456     Assert.assertTrue(
457         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
458             .matcher(apiClientHeaderKey)
459             .matches());
460   }
461 
462   @Test
listDatasetVersionsExceptionTest2()463   public void listDatasetVersionsExceptionTest2() throws Exception {
464     ApiException exception =
465         ApiExceptionFactory.createException(
466             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
467     mockService.addException(exception);
468 
469     try {
470       String name = "projects/project-2277/datasets/dataset-2277";
471       client.listDatasetVersions(name);
472       Assert.fail("No exception raised");
473     } catch (InvalidArgumentException e) {
474       // Expected exception.
475     }
476   }
477 
478   @Test
listDatasetsTest()479   public void listDatasetsTest() throws Exception {
480     Dataset responsesElement = Dataset.newBuilder().build();
481     ListDatasetsResponse expectedResponse =
482         ListDatasetsResponse.newBuilder()
483             .setNextPageToken("")
484             .addAllDatasets(Arrays.asList(responsesElement))
485             .build();
486     mockService.addResponse(expectedResponse);
487 
488     ProjectName parent = ProjectName.of("[PROJECT]");
489 
490     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
491 
492     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
493 
494     Assert.assertEquals(1, resources.size());
495     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
496 
497     List<String> actualRequests = mockService.getRequestPaths();
498     Assert.assertEquals(1, actualRequests.size());
499 
500     String apiClientHeaderKey =
501         mockService
502             .getRequestHeaders()
503             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
504             .iterator()
505             .next();
506     Assert.assertTrue(
507         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
508             .matcher(apiClientHeaderKey)
509             .matches());
510   }
511 
512   @Test
listDatasetsExceptionTest()513   public void listDatasetsExceptionTest() throws Exception {
514     ApiException exception =
515         ApiExceptionFactory.createException(
516             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
517     mockService.addException(exception);
518 
519     try {
520       ProjectName parent = ProjectName.of("[PROJECT]");
521       client.listDatasets(parent);
522       Assert.fail("No exception raised");
523     } catch (InvalidArgumentException e) {
524       // Expected exception.
525     }
526   }
527 
528   @Test
listDatasetsTest2()529   public void listDatasetsTest2() throws Exception {
530     Dataset responsesElement = Dataset.newBuilder().build();
531     ListDatasetsResponse expectedResponse =
532         ListDatasetsResponse.newBuilder()
533             .setNextPageToken("")
534             .addAllDatasets(Arrays.asList(responsesElement))
535             .build();
536     mockService.addResponse(expectedResponse);
537 
538     String parent = "projects/project-2353";
539 
540     ListDatasetsPagedResponse pagedListResponse = client.listDatasets(parent);
541 
542     List<Dataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
543 
544     Assert.assertEquals(1, resources.size());
545     Assert.assertEquals(expectedResponse.getDatasetsList().get(0), resources.get(0));
546 
547     List<String> actualRequests = mockService.getRequestPaths();
548     Assert.assertEquals(1, actualRequests.size());
549 
550     String apiClientHeaderKey =
551         mockService
552             .getRequestHeaders()
553             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
554             .iterator()
555             .next();
556     Assert.assertTrue(
557         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
558             .matcher(apiClientHeaderKey)
559             .matches());
560   }
561 
562   @Test
listDatasetsExceptionTest2()563   public void listDatasetsExceptionTest2() throws Exception {
564     ApiException exception =
565         ApiExceptionFactory.createException(
566             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
567     mockService.addException(exception);
568 
569     try {
570       String parent = "projects/project-2353";
571       client.listDatasets(parent);
572       Assert.fail("No exception raised");
573     } catch (InvalidArgumentException e) {
574       // Expected exception.
575     }
576   }
577 
578   @Test
deleteDatasetTest()579   public void deleteDatasetTest() throws Exception {
580     Empty expectedResponse = Empty.newBuilder().build();
581     mockService.addResponse(expectedResponse);
582 
583     DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
584 
585     client.deleteDataset(name);
586 
587     List<String> actualRequests = mockService.getRequestPaths();
588     Assert.assertEquals(1, actualRequests.size());
589 
590     String apiClientHeaderKey =
591         mockService
592             .getRequestHeaders()
593             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
594             .iterator()
595             .next();
596     Assert.assertTrue(
597         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
598             .matcher(apiClientHeaderKey)
599             .matches());
600   }
601 
602   @Test
deleteDatasetExceptionTest()603   public void deleteDatasetExceptionTest() throws Exception {
604     ApiException exception =
605         ApiExceptionFactory.createException(
606             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
607     mockService.addException(exception);
608 
609     try {
610       DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
611       client.deleteDataset(name);
612       Assert.fail("No exception raised");
613     } catch (InvalidArgumentException e) {
614       // Expected exception.
615     }
616   }
617 
618   @Test
deleteDatasetTest2()619   public void deleteDatasetTest2() throws Exception {
620     Empty expectedResponse = Empty.newBuilder().build();
621     mockService.addResponse(expectedResponse);
622 
623     String name = "projects/project-2277/datasets/dataset-2277";
624 
625     client.deleteDataset(name);
626 
627     List<String> actualRequests = mockService.getRequestPaths();
628     Assert.assertEquals(1, actualRequests.size());
629 
630     String apiClientHeaderKey =
631         mockService
632             .getRequestHeaders()
633             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
634             .iterator()
635             .next();
636     Assert.assertTrue(
637         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
638             .matcher(apiClientHeaderKey)
639             .matches());
640   }
641 
642   @Test
deleteDatasetExceptionTest2()643   public void deleteDatasetExceptionTest2() throws Exception {
644     ApiException exception =
645         ApiExceptionFactory.createException(
646             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
647     mockService.addException(exception);
648 
649     try {
650       String name = "projects/project-2277/datasets/dataset-2277";
651       client.deleteDataset(name);
652       Assert.fail("No exception raised");
653     } catch (InvalidArgumentException e) {
654       // Expected exception.
655     }
656   }
657 
658   @Test
deleteDatasetVersionTest()659   public void deleteDatasetVersionTest() throws Exception {
660     Empty expectedResponse = Empty.newBuilder().build();
661     mockService.addResponse(expectedResponse);
662 
663     DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
664 
665     client.deleteDatasetVersion(name);
666 
667     List<String> actualRequests = mockService.getRequestPaths();
668     Assert.assertEquals(1, actualRequests.size());
669 
670     String apiClientHeaderKey =
671         mockService
672             .getRequestHeaders()
673             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
674             .iterator()
675             .next();
676     Assert.assertTrue(
677         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
678             .matcher(apiClientHeaderKey)
679             .matches());
680   }
681 
682   @Test
deleteDatasetVersionExceptionTest()683   public void deleteDatasetVersionExceptionTest() throws Exception {
684     ApiException exception =
685         ApiExceptionFactory.createException(
686             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
687     mockService.addException(exception);
688 
689     try {
690       DatasetName name = DatasetName.of("[PROJECT]", "[DATASET]");
691       client.deleteDatasetVersion(name);
692       Assert.fail("No exception raised");
693     } catch (InvalidArgumentException e) {
694       // Expected exception.
695     }
696   }
697 
698   @Test
deleteDatasetVersionTest2()699   public void deleteDatasetVersionTest2() throws Exception {
700     Empty expectedResponse = Empty.newBuilder().build();
701     mockService.addResponse(expectedResponse);
702 
703     String name = "projects/project-2277/datasets/dataset-2277";
704 
705     client.deleteDatasetVersion(name);
706 
707     List<String> actualRequests = mockService.getRequestPaths();
708     Assert.assertEquals(1, actualRequests.size());
709 
710     String apiClientHeaderKey =
711         mockService
712             .getRequestHeaders()
713             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
714             .iterator()
715             .next();
716     Assert.assertTrue(
717         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
718             .matcher(apiClientHeaderKey)
719             .matches());
720   }
721 
722   @Test
deleteDatasetVersionExceptionTest2()723   public void deleteDatasetVersionExceptionTest2() throws Exception {
724     ApiException exception =
725         ApiExceptionFactory.createException(
726             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
727     mockService.addException(exception);
728 
729     try {
730       String name = "projects/project-2277/datasets/dataset-2277";
731       client.deleteDatasetVersion(name);
732       Assert.fail("No exception raised");
733     } catch (InvalidArgumentException e) {
734       // Expected exception.
735     }
736   }
737 }
738