• 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.bigquery.datatransfer.v1;
18 
19 import static com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient.ListDataSourcesPagedResponse;
20 import static com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient.ListLocationsPagedResponse;
21 import static com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient.ListTransferConfigsPagedResponse;
22 import static com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient.ListTransferLogsPagedResponse;
23 import static com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient.ListTransferRunsPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
27 import com.google.api.gax.httpjson.testing.MockHttpService;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.ApiException;
30 import com.google.api.gax.rpc.ApiExceptionFactory;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.api.gax.rpc.StatusCode;
33 import com.google.api.gax.rpc.testing.FakeStatusCode;
34 import com.google.cloud.bigquery.datatransfer.v1.stub.HttpJsonDataTransferServiceStub;
35 import com.google.cloud.location.GetLocationRequest;
36 import com.google.cloud.location.ListLocationsRequest;
37 import com.google.cloud.location.ListLocationsResponse;
38 import com.google.cloud.location.Location;
39 import com.google.common.collect.Lists;
40 import com.google.protobuf.Any;
41 import com.google.protobuf.Duration;
42 import com.google.protobuf.Empty;
43 import com.google.protobuf.FieldMask;
44 import com.google.protobuf.Struct;
45 import com.google.protobuf.Timestamp;
46 import com.google.rpc.Status;
47 import java.io.IOException;
48 import java.util.ArrayList;
49 import java.util.Arrays;
50 import java.util.HashMap;
51 import java.util.List;
52 import javax.annotation.Generated;
53 import org.junit.After;
54 import org.junit.AfterClass;
55 import org.junit.Assert;
56 import org.junit.Before;
57 import org.junit.BeforeClass;
58 import org.junit.Test;
59 
60 @Generated("by gapic-generator-java")
61 public class DataTransferServiceClientHttpJsonTest {
62   private static MockHttpService mockService;
63   private static DataTransferServiceClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() throws IOException {
67     mockService =
68         new MockHttpService(
69             HttpJsonDataTransferServiceStub.getMethodDescriptors(),
70             DataTransferServiceSettings.getDefaultEndpoint());
71     DataTransferServiceSettings settings =
72         DataTransferServiceSettings.newHttpJsonBuilder()
73             .setTransportChannelProvider(
74                 DataTransferServiceSettings.defaultHttpJsonTransportProviderBuilder()
75                     .setHttpTransport(mockService)
76                     .build())
77             .setCredentialsProvider(NoCredentialsProvider.create())
78             .build();
79     client = DataTransferServiceClient.create(settings);
80   }
81 
82   @AfterClass
stopServer()83   public static void stopServer() {
84     client.close();
85   }
86 
87   @Before
setUp()88   public void setUp() {}
89 
90   @After
tearDown()91   public void tearDown() throws Exception {
92     mockService.reset();
93   }
94 
95   @Test
getDataSourceTest()96   public void getDataSourceTest() throws Exception {
97     DataSource expectedResponse =
98         DataSource.newBuilder()
99             .setName(
100                 DataSourceName.ofProjectLocationDataSourceName(
101                         "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
102                     .toString())
103             .setDataSourceId("dataSourceId-1221402528")
104             .setDisplayName("displayName1714148973")
105             .setDescription("description-1724546052")
106             .setClientId("clientId908408390")
107             .addAllScopes(new ArrayList<String>())
108             .setTransferType(TransferType.forNumber(0))
109             .setSupportsMultipleTransfers(true)
110             .setUpdateDeadlineSeconds(991471694)
111             .setDefaultSchedule("defaultSchedule1300167672")
112             .setSupportsCustomSchedule(true)
113             .addAllParameters(new ArrayList<DataSourceParameter>())
114             .setHelpUrl("helpUrl805808750")
115             .setDefaultDataRefreshWindowDays(-1804935157)
116             .setManualRunsDisabled(true)
117             .setMinimumScheduleInterval(Duration.newBuilder().build())
118             .build();
119     mockService.addResponse(expectedResponse);
120 
121     DataSourceName name =
122         DataSourceName.ofProjectLocationDataSourceName("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]");
123 
124     DataSource actualResponse = client.getDataSource(name);
125     Assert.assertEquals(expectedResponse, actualResponse);
126 
127     List<String> actualRequests = mockService.getRequestPaths();
128     Assert.assertEquals(1, actualRequests.size());
129 
130     String apiClientHeaderKey =
131         mockService
132             .getRequestHeaders()
133             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
134             .iterator()
135             .next();
136     Assert.assertTrue(
137         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
138             .matcher(apiClientHeaderKey)
139             .matches());
140   }
141 
142   @Test
getDataSourceExceptionTest()143   public void getDataSourceExceptionTest() throws Exception {
144     ApiException exception =
145         ApiExceptionFactory.createException(
146             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
147     mockService.addException(exception);
148 
149     try {
150       DataSourceName name =
151           DataSourceName.ofProjectLocationDataSourceName(
152               "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]");
153       client.getDataSource(name);
154       Assert.fail("No exception raised");
155     } catch (InvalidArgumentException e) {
156       // Expected exception.
157     }
158   }
159 
160   @Test
getDataSourceTest2()161   public void getDataSourceTest2() throws Exception {
162     DataSource expectedResponse =
163         DataSource.newBuilder()
164             .setName(
165                 DataSourceName.ofProjectLocationDataSourceName(
166                         "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
167                     .toString())
168             .setDataSourceId("dataSourceId-1221402528")
169             .setDisplayName("displayName1714148973")
170             .setDescription("description-1724546052")
171             .setClientId("clientId908408390")
172             .addAllScopes(new ArrayList<String>())
173             .setTransferType(TransferType.forNumber(0))
174             .setSupportsMultipleTransfers(true)
175             .setUpdateDeadlineSeconds(991471694)
176             .setDefaultSchedule("defaultSchedule1300167672")
177             .setSupportsCustomSchedule(true)
178             .addAllParameters(new ArrayList<DataSourceParameter>())
179             .setHelpUrl("helpUrl805808750")
180             .setDefaultDataRefreshWindowDays(-1804935157)
181             .setManualRunsDisabled(true)
182             .setMinimumScheduleInterval(Duration.newBuilder().build())
183             .build();
184     mockService.addResponse(expectedResponse);
185 
186     String name = "projects/project-6044/locations/location-6044/dataSources/dataSource-6044";
187 
188     DataSource actualResponse = client.getDataSource(name);
189     Assert.assertEquals(expectedResponse, actualResponse);
190 
191     List<String> actualRequests = mockService.getRequestPaths();
192     Assert.assertEquals(1, actualRequests.size());
193 
194     String apiClientHeaderKey =
195         mockService
196             .getRequestHeaders()
197             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
198             .iterator()
199             .next();
200     Assert.assertTrue(
201         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
202             .matcher(apiClientHeaderKey)
203             .matches());
204   }
205 
206   @Test
getDataSourceExceptionTest2()207   public void getDataSourceExceptionTest2() throws Exception {
208     ApiException exception =
209         ApiExceptionFactory.createException(
210             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
211     mockService.addException(exception);
212 
213     try {
214       String name = "projects/project-6044/locations/location-6044/dataSources/dataSource-6044";
215       client.getDataSource(name);
216       Assert.fail("No exception raised");
217     } catch (InvalidArgumentException e) {
218       // Expected exception.
219     }
220   }
221 
222   @Test
listDataSourcesTest()223   public void listDataSourcesTest() throws Exception {
224     DataSource responsesElement = DataSource.newBuilder().build();
225     ListDataSourcesResponse expectedResponse =
226         ListDataSourcesResponse.newBuilder()
227             .setNextPageToken("")
228             .addAllDataSources(Arrays.asList(responsesElement))
229             .build();
230     mockService.addResponse(expectedResponse);
231 
232     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
233 
234     ListDataSourcesPagedResponse pagedListResponse = client.listDataSources(parent);
235 
236     List<DataSource> resources = Lists.newArrayList(pagedListResponse.iterateAll());
237 
238     Assert.assertEquals(1, resources.size());
239     Assert.assertEquals(expectedResponse.getDataSourcesList().get(0), resources.get(0));
240 
241     List<String> actualRequests = mockService.getRequestPaths();
242     Assert.assertEquals(1, actualRequests.size());
243 
244     String apiClientHeaderKey =
245         mockService
246             .getRequestHeaders()
247             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
248             .iterator()
249             .next();
250     Assert.assertTrue(
251         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
252             .matcher(apiClientHeaderKey)
253             .matches());
254   }
255 
256   @Test
listDataSourcesExceptionTest()257   public void listDataSourcesExceptionTest() throws Exception {
258     ApiException exception =
259         ApiExceptionFactory.createException(
260             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
261     mockService.addException(exception);
262 
263     try {
264       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
265       client.listDataSources(parent);
266       Assert.fail("No exception raised");
267     } catch (InvalidArgumentException e) {
268       // Expected exception.
269     }
270   }
271 
272   @Test
listDataSourcesTest2()273   public void listDataSourcesTest2() throws Exception {
274     DataSource responsesElement = DataSource.newBuilder().build();
275     ListDataSourcesResponse expectedResponse =
276         ListDataSourcesResponse.newBuilder()
277             .setNextPageToken("")
278             .addAllDataSources(Arrays.asList(responsesElement))
279             .build();
280     mockService.addResponse(expectedResponse);
281 
282     ProjectName parent = ProjectName.of("[PROJECT]");
283 
284     ListDataSourcesPagedResponse pagedListResponse = client.listDataSources(parent);
285 
286     List<DataSource> resources = Lists.newArrayList(pagedListResponse.iterateAll());
287 
288     Assert.assertEquals(1, resources.size());
289     Assert.assertEquals(expectedResponse.getDataSourcesList().get(0), resources.get(0));
290 
291     List<String> actualRequests = mockService.getRequestPaths();
292     Assert.assertEquals(1, actualRequests.size());
293 
294     String apiClientHeaderKey =
295         mockService
296             .getRequestHeaders()
297             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
298             .iterator()
299             .next();
300     Assert.assertTrue(
301         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
302             .matcher(apiClientHeaderKey)
303             .matches());
304   }
305 
306   @Test
listDataSourcesExceptionTest2()307   public void listDataSourcesExceptionTest2() throws Exception {
308     ApiException exception =
309         ApiExceptionFactory.createException(
310             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
311     mockService.addException(exception);
312 
313     try {
314       ProjectName parent = ProjectName.of("[PROJECT]");
315       client.listDataSources(parent);
316       Assert.fail("No exception raised");
317     } catch (InvalidArgumentException e) {
318       // Expected exception.
319     }
320   }
321 
322   @Test
listDataSourcesTest3()323   public void listDataSourcesTest3() throws Exception {
324     DataSource responsesElement = DataSource.newBuilder().build();
325     ListDataSourcesResponse expectedResponse =
326         ListDataSourcesResponse.newBuilder()
327             .setNextPageToken("")
328             .addAllDataSources(Arrays.asList(responsesElement))
329             .build();
330     mockService.addResponse(expectedResponse);
331 
332     String parent = "projects/project-5833/locations/location-5833";
333 
334     ListDataSourcesPagedResponse pagedListResponse = client.listDataSources(parent);
335 
336     List<DataSource> resources = Lists.newArrayList(pagedListResponse.iterateAll());
337 
338     Assert.assertEquals(1, resources.size());
339     Assert.assertEquals(expectedResponse.getDataSourcesList().get(0), resources.get(0));
340 
341     List<String> actualRequests = mockService.getRequestPaths();
342     Assert.assertEquals(1, actualRequests.size());
343 
344     String apiClientHeaderKey =
345         mockService
346             .getRequestHeaders()
347             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
348             .iterator()
349             .next();
350     Assert.assertTrue(
351         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
352             .matcher(apiClientHeaderKey)
353             .matches());
354   }
355 
356   @Test
listDataSourcesExceptionTest3()357   public void listDataSourcesExceptionTest3() throws Exception {
358     ApiException exception =
359         ApiExceptionFactory.createException(
360             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
361     mockService.addException(exception);
362 
363     try {
364       String parent = "projects/project-5833/locations/location-5833";
365       client.listDataSources(parent);
366       Assert.fail("No exception raised");
367     } catch (InvalidArgumentException e) {
368       // Expected exception.
369     }
370   }
371 
372   @Test
createTransferConfigTest()373   public void createTransferConfigTest() throws Exception {
374     TransferConfig expectedResponse =
375         TransferConfig.newBuilder()
376             .setName(
377                 TransferConfigName.ofProjectTransferConfigName("[PROJECT]", "[TRANSFER_CONFIG]")
378                     .toString())
379             .setDisplayName("displayName1714148973")
380             .setDataSourceId("dataSourceId-1221402528")
381             .setParams(Struct.newBuilder().build())
382             .setSchedule("schedule-697920873")
383             .setScheduleOptions(ScheduleOptions.newBuilder().build())
384             .setDataRefreshWindowDays(327632845)
385             .setDisabled(true)
386             .setUpdateTime(Timestamp.newBuilder().build())
387             .setNextRunTime(Timestamp.newBuilder().build())
388             .setState(TransferState.forNumber(0))
389             .setUserId(-147132913)
390             .setDatasetRegion("datasetRegion1032293772")
391             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
392             .setEmailPreferences(EmailPreferences.newBuilder().build())
393             .setOwnerInfo(UserInfo.newBuilder().build())
394             .build();
395     mockService.addResponse(expectedResponse);
396 
397     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
398     TransferConfig transferConfig = TransferConfig.newBuilder().build();
399 
400     TransferConfig actualResponse = client.createTransferConfig(parent, transferConfig);
401     Assert.assertEquals(expectedResponse, actualResponse);
402 
403     List<String> actualRequests = mockService.getRequestPaths();
404     Assert.assertEquals(1, actualRequests.size());
405 
406     String apiClientHeaderKey =
407         mockService
408             .getRequestHeaders()
409             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
410             .iterator()
411             .next();
412     Assert.assertTrue(
413         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
414             .matcher(apiClientHeaderKey)
415             .matches());
416   }
417 
418   @Test
createTransferConfigExceptionTest()419   public void createTransferConfigExceptionTest() throws Exception {
420     ApiException exception =
421         ApiExceptionFactory.createException(
422             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
423     mockService.addException(exception);
424 
425     try {
426       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
427       TransferConfig transferConfig = TransferConfig.newBuilder().build();
428       client.createTransferConfig(parent, transferConfig);
429       Assert.fail("No exception raised");
430     } catch (InvalidArgumentException e) {
431       // Expected exception.
432     }
433   }
434 
435   @Test
createTransferConfigTest2()436   public void createTransferConfigTest2() throws Exception {
437     TransferConfig expectedResponse =
438         TransferConfig.newBuilder()
439             .setName(
440                 TransferConfigName.ofProjectTransferConfigName("[PROJECT]", "[TRANSFER_CONFIG]")
441                     .toString())
442             .setDisplayName("displayName1714148973")
443             .setDataSourceId("dataSourceId-1221402528")
444             .setParams(Struct.newBuilder().build())
445             .setSchedule("schedule-697920873")
446             .setScheduleOptions(ScheduleOptions.newBuilder().build())
447             .setDataRefreshWindowDays(327632845)
448             .setDisabled(true)
449             .setUpdateTime(Timestamp.newBuilder().build())
450             .setNextRunTime(Timestamp.newBuilder().build())
451             .setState(TransferState.forNumber(0))
452             .setUserId(-147132913)
453             .setDatasetRegion("datasetRegion1032293772")
454             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
455             .setEmailPreferences(EmailPreferences.newBuilder().build())
456             .setOwnerInfo(UserInfo.newBuilder().build())
457             .build();
458     mockService.addResponse(expectedResponse);
459 
460     ProjectName parent = ProjectName.of("[PROJECT]");
461     TransferConfig transferConfig = TransferConfig.newBuilder().build();
462 
463     TransferConfig actualResponse = client.createTransferConfig(parent, transferConfig);
464     Assert.assertEquals(expectedResponse, actualResponse);
465 
466     List<String> actualRequests = mockService.getRequestPaths();
467     Assert.assertEquals(1, actualRequests.size());
468 
469     String apiClientHeaderKey =
470         mockService
471             .getRequestHeaders()
472             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
473             .iterator()
474             .next();
475     Assert.assertTrue(
476         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
477             .matcher(apiClientHeaderKey)
478             .matches());
479   }
480 
481   @Test
createTransferConfigExceptionTest2()482   public void createTransferConfigExceptionTest2() throws Exception {
483     ApiException exception =
484         ApiExceptionFactory.createException(
485             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
486     mockService.addException(exception);
487 
488     try {
489       ProjectName parent = ProjectName.of("[PROJECT]");
490       TransferConfig transferConfig = TransferConfig.newBuilder().build();
491       client.createTransferConfig(parent, transferConfig);
492       Assert.fail("No exception raised");
493     } catch (InvalidArgumentException e) {
494       // Expected exception.
495     }
496   }
497 
498   @Test
createTransferConfigTest3()499   public void createTransferConfigTest3() throws Exception {
500     TransferConfig expectedResponse =
501         TransferConfig.newBuilder()
502             .setName(
503                 TransferConfigName.ofProjectTransferConfigName("[PROJECT]", "[TRANSFER_CONFIG]")
504                     .toString())
505             .setDisplayName("displayName1714148973")
506             .setDataSourceId("dataSourceId-1221402528")
507             .setParams(Struct.newBuilder().build())
508             .setSchedule("schedule-697920873")
509             .setScheduleOptions(ScheduleOptions.newBuilder().build())
510             .setDataRefreshWindowDays(327632845)
511             .setDisabled(true)
512             .setUpdateTime(Timestamp.newBuilder().build())
513             .setNextRunTime(Timestamp.newBuilder().build())
514             .setState(TransferState.forNumber(0))
515             .setUserId(-147132913)
516             .setDatasetRegion("datasetRegion1032293772")
517             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
518             .setEmailPreferences(EmailPreferences.newBuilder().build())
519             .setOwnerInfo(UserInfo.newBuilder().build())
520             .build();
521     mockService.addResponse(expectedResponse);
522 
523     String parent = "projects/project-5833/locations/location-5833";
524     TransferConfig transferConfig = TransferConfig.newBuilder().build();
525 
526     TransferConfig actualResponse = client.createTransferConfig(parent, transferConfig);
527     Assert.assertEquals(expectedResponse, actualResponse);
528 
529     List<String> actualRequests = mockService.getRequestPaths();
530     Assert.assertEquals(1, actualRequests.size());
531 
532     String apiClientHeaderKey =
533         mockService
534             .getRequestHeaders()
535             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
536             .iterator()
537             .next();
538     Assert.assertTrue(
539         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
540             .matcher(apiClientHeaderKey)
541             .matches());
542   }
543 
544   @Test
createTransferConfigExceptionTest3()545   public void createTransferConfigExceptionTest3() throws Exception {
546     ApiException exception =
547         ApiExceptionFactory.createException(
548             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
549     mockService.addException(exception);
550 
551     try {
552       String parent = "projects/project-5833/locations/location-5833";
553       TransferConfig transferConfig = TransferConfig.newBuilder().build();
554       client.createTransferConfig(parent, transferConfig);
555       Assert.fail("No exception raised");
556     } catch (InvalidArgumentException e) {
557       // Expected exception.
558     }
559   }
560 
561   @Test
updateTransferConfigTest()562   public void updateTransferConfigTest() throws Exception {
563     TransferConfig expectedResponse =
564         TransferConfig.newBuilder()
565             .setName(
566                 TransferConfigName.ofProjectLocationTransferConfigName(
567                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
568                     .toString())
569             .setDisplayName("displayName1714148973")
570             .setDataSourceId("dataSourceId-1221402528")
571             .setParams(Struct.newBuilder().build())
572             .setSchedule("schedule-697920873")
573             .setScheduleOptions(ScheduleOptions.newBuilder().build())
574             .setDataRefreshWindowDays(327632845)
575             .setDisabled(true)
576             .setUpdateTime(Timestamp.newBuilder().build())
577             .setNextRunTime(Timestamp.newBuilder().build())
578             .setState(TransferState.forNumber(0))
579             .setUserId(-147132913)
580             .setDatasetRegion("datasetRegion1032293772")
581             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
582             .setEmailPreferences(EmailPreferences.newBuilder().build())
583             .setOwnerInfo(UserInfo.newBuilder().build())
584             .build();
585     mockService.addResponse(expectedResponse);
586 
587     TransferConfig transferConfig =
588         TransferConfig.newBuilder()
589             .setName(
590                 TransferConfigName.ofProjectTransferConfigName("[PROJECT]", "[TRANSFER_CONFIG]")
591                     .toString())
592             .setDisplayName("displayName1714148973")
593             .setDataSourceId("dataSourceId-1221402528")
594             .setParams(Struct.newBuilder().build())
595             .setSchedule("schedule-697920873")
596             .setScheduleOptions(ScheduleOptions.newBuilder().build())
597             .setDataRefreshWindowDays(327632845)
598             .setDisabled(true)
599             .setUpdateTime(Timestamp.newBuilder().build())
600             .setNextRunTime(Timestamp.newBuilder().build())
601             .setState(TransferState.forNumber(0))
602             .setUserId(-147132913)
603             .setDatasetRegion("datasetRegion1032293772")
604             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
605             .setEmailPreferences(EmailPreferences.newBuilder().build())
606             .setOwnerInfo(UserInfo.newBuilder().build())
607             .build();
608     FieldMask updateMask = FieldMask.newBuilder().build();
609 
610     TransferConfig actualResponse = client.updateTransferConfig(transferConfig, updateMask);
611     Assert.assertEquals(expectedResponse, actualResponse);
612 
613     List<String> actualRequests = mockService.getRequestPaths();
614     Assert.assertEquals(1, actualRequests.size());
615 
616     String apiClientHeaderKey =
617         mockService
618             .getRequestHeaders()
619             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
620             .iterator()
621             .next();
622     Assert.assertTrue(
623         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
624             .matcher(apiClientHeaderKey)
625             .matches());
626   }
627 
628   @Test
updateTransferConfigExceptionTest()629   public void updateTransferConfigExceptionTest() throws Exception {
630     ApiException exception =
631         ApiExceptionFactory.createException(
632             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
633     mockService.addException(exception);
634 
635     try {
636       TransferConfig transferConfig =
637           TransferConfig.newBuilder()
638               .setName(
639                   TransferConfigName.ofProjectTransferConfigName("[PROJECT]", "[TRANSFER_CONFIG]")
640                       .toString())
641               .setDisplayName("displayName1714148973")
642               .setDataSourceId("dataSourceId-1221402528")
643               .setParams(Struct.newBuilder().build())
644               .setSchedule("schedule-697920873")
645               .setScheduleOptions(ScheduleOptions.newBuilder().build())
646               .setDataRefreshWindowDays(327632845)
647               .setDisabled(true)
648               .setUpdateTime(Timestamp.newBuilder().build())
649               .setNextRunTime(Timestamp.newBuilder().build())
650               .setState(TransferState.forNumber(0))
651               .setUserId(-147132913)
652               .setDatasetRegion("datasetRegion1032293772")
653               .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
654               .setEmailPreferences(EmailPreferences.newBuilder().build())
655               .setOwnerInfo(UserInfo.newBuilder().build())
656               .build();
657       FieldMask updateMask = FieldMask.newBuilder().build();
658       client.updateTransferConfig(transferConfig, updateMask);
659       Assert.fail("No exception raised");
660     } catch (InvalidArgumentException e) {
661       // Expected exception.
662     }
663   }
664 
665   @Test
deleteTransferConfigTest()666   public void deleteTransferConfigTest() throws Exception {
667     Empty expectedResponse = Empty.newBuilder().build();
668     mockService.addResponse(expectedResponse);
669 
670     TransferConfigName name =
671         TransferConfigName.ofProjectLocationTransferConfigName(
672             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
673 
674     client.deleteTransferConfig(name);
675 
676     List<String> actualRequests = mockService.getRequestPaths();
677     Assert.assertEquals(1, actualRequests.size());
678 
679     String apiClientHeaderKey =
680         mockService
681             .getRequestHeaders()
682             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
683             .iterator()
684             .next();
685     Assert.assertTrue(
686         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
687             .matcher(apiClientHeaderKey)
688             .matches());
689   }
690 
691   @Test
deleteTransferConfigExceptionTest()692   public void deleteTransferConfigExceptionTest() throws Exception {
693     ApiException exception =
694         ApiExceptionFactory.createException(
695             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
696     mockService.addException(exception);
697 
698     try {
699       TransferConfigName name =
700           TransferConfigName.ofProjectLocationTransferConfigName(
701               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
702       client.deleteTransferConfig(name);
703       Assert.fail("No exception raised");
704     } catch (InvalidArgumentException e) {
705       // Expected exception.
706     }
707   }
708 
709   @Test
deleteTransferConfigTest2()710   public void deleteTransferConfigTest2() throws Exception {
711     Empty expectedResponse = Empty.newBuilder().build();
712     mockService.addResponse(expectedResponse);
713 
714     String name =
715         "projects/project-8868/locations/location-8868/transferConfigs/transferConfig-8868";
716 
717     client.deleteTransferConfig(name);
718 
719     List<String> actualRequests = mockService.getRequestPaths();
720     Assert.assertEquals(1, actualRequests.size());
721 
722     String apiClientHeaderKey =
723         mockService
724             .getRequestHeaders()
725             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
726             .iterator()
727             .next();
728     Assert.assertTrue(
729         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
730             .matcher(apiClientHeaderKey)
731             .matches());
732   }
733 
734   @Test
deleteTransferConfigExceptionTest2()735   public void deleteTransferConfigExceptionTest2() throws Exception {
736     ApiException exception =
737         ApiExceptionFactory.createException(
738             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
739     mockService.addException(exception);
740 
741     try {
742       String name =
743           "projects/project-8868/locations/location-8868/transferConfigs/transferConfig-8868";
744       client.deleteTransferConfig(name);
745       Assert.fail("No exception raised");
746     } catch (InvalidArgumentException e) {
747       // Expected exception.
748     }
749   }
750 
751   @Test
getTransferConfigTest()752   public void getTransferConfigTest() throws Exception {
753     TransferConfig expectedResponse =
754         TransferConfig.newBuilder()
755             .setName(
756                 TransferConfigName.ofProjectLocationTransferConfigName(
757                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
758                     .toString())
759             .setDisplayName("displayName1714148973")
760             .setDataSourceId("dataSourceId-1221402528")
761             .setParams(Struct.newBuilder().build())
762             .setSchedule("schedule-697920873")
763             .setScheduleOptions(ScheduleOptions.newBuilder().build())
764             .setDataRefreshWindowDays(327632845)
765             .setDisabled(true)
766             .setUpdateTime(Timestamp.newBuilder().build())
767             .setNextRunTime(Timestamp.newBuilder().build())
768             .setState(TransferState.forNumber(0))
769             .setUserId(-147132913)
770             .setDatasetRegion("datasetRegion1032293772")
771             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
772             .setEmailPreferences(EmailPreferences.newBuilder().build())
773             .setOwnerInfo(UserInfo.newBuilder().build())
774             .build();
775     mockService.addResponse(expectedResponse);
776 
777     TransferConfigName name =
778         TransferConfigName.ofProjectLocationTransferConfigName(
779             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
780 
781     TransferConfig actualResponse = client.getTransferConfig(name);
782     Assert.assertEquals(expectedResponse, actualResponse);
783 
784     List<String> actualRequests = mockService.getRequestPaths();
785     Assert.assertEquals(1, actualRequests.size());
786 
787     String apiClientHeaderKey =
788         mockService
789             .getRequestHeaders()
790             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
791             .iterator()
792             .next();
793     Assert.assertTrue(
794         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
795             .matcher(apiClientHeaderKey)
796             .matches());
797   }
798 
799   @Test
getTransferConfigExceptionTest()800   public void getTransferConfigExceptionTest() throws Exception {
801     ApiException exception =
802         ApiExceptionFactory.createException(
803             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
804     mockService.addException(exception);
805 
806     try {
807       TransferConfigName name =
808           TransferConfigName.ofProjectLocationTransferConfigName(
809               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
810       client.getTransferConfig(name);
811       Assert.fail("No exception raised");
812     } catch (InvalidArgumentException e) {
813       // Expected exception.
814     }
815   }
816 
817   @Test
getTransferConfigTest2()818   public void getTransferConfigTest2() throws Exception {
819     TransferConfig expectedResponse =
820         TransferConfig.newBuilder()
821             .setName(
822                 TransferConfigName.ofProjectLocationTransferConfigName(
823                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
824                     .toString())
825             .setDisplayName("displayName1714148973")
826             .setDataSourceId("dataSourceId-1221402528")
827             .setParams(Struct.newBuilder().build())
828             .setSchedule("schedule-697920873")
829             .setScheduleOptions(ScheduleOptions.newBuilder().build())
830             .setDataRefreshWindowDays(327632845)
831             .setDisabled(true)
832             .setUpdateTime(Timestamp.newBuilder().build())
833             .setNextRunTime(Timestamp.newBuilder().build())
834             .setState(TransferState.forNumber(0))
835             .setUserId(-147132913)
836             .setDatasetRegion("datasetRegion1032293772")
837             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
838             .setEmailPreferences(EmailPreferences.newBuilder().build())
839             .setOwnerInfo(UserInfo.newBuilder().build())
840             .build();
841     mockService.addResponse(expectedResponse);
842 
843     String name =
844         "projects/project-8868/locations/location-8868/transferConfigs/transferConfig-8868";
845 
846     TransferConfig actualResponse = client.getTransferConfig(name);
847     Assert.assertEquals(expectedResponse, actualResponse);
848 
849     List<String> actualRequests = mockService.getRequestPaths();
850     Assert.assertEquals(1, actualRequests.size());
851 
852     String apiClientHeaderKey =
853         mockService
854             .getRequestHeaders()
855             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
856             .iterator()
857             .next();
858     Assert.assertTrue(
859         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
860             .matcher(apiClientHeaderKey)
861             .matches());
862   }
863 
864   @Test
getTransferConfigExceptionTest2()865   public void getTransferConfigExceptionTest2() throws Exception {
866     ApiException exception =
867         ApiExceptionFactory.createException(
868             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
869     mockService.addException(exception);
870 
871     try {
872       String name =
873           "projects/project-8868/locations/location-8868/transferConfigs/transferConfig-8868";
874       client.getTransferConfig(name);
875       Assert.fail("No exception raised");
876     } catch (InvalidArgumentException e) {
877       // Expected exception.
878     }
879   }
880 
881   @Test
listTransferConfigsTest()882   public void listTransferConfigsTest() throws Exception {
883     TransferConfig responsesElement = TransferConfig.newBuilder().build();
884     ListTransferConfigsResponse expectedResponse =
885         ListTransferConfigsResponse.newBuilder()
886             .setNextPageToken("")
887             .addAllTransferConfigs(Arrays.asList(responsesElement))
888             .build();
889     mockService.addResponse(expectedResponse);
890 
891     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
892 
893     ListTransferConfigsPagedResponse pagedListResponse = client.listTransferConfigs(parent);
894 
895     List<TransferConfig> resources = Lists.newArrayList(pagedListResponse.iterateAll());
896 
897     Assert.assertEquals(1, resources.size());
898     Assert.assertEquals(expectedResponse.getTransferConfigsList().get(0), resources.get(0));
899 
900     List<String> actualRequests = mockService.getRequestPaths();
901     Assert.assertEquals(1, actualRequests.size());
902 
903     String apiClientHeaderKey =
904         mockService
905             .getRequestHeaders()
906             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
907             .iterator()
908             .next();
909     Assert.assertTrue(
910         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
911             .matcher(apiClientHeaderKey)
912             .matches());
913   }
914 
915   @Test
listTransferConfigsExceptionTest()916   public void listTransferConfigsExceptionTest() throws Exception {
917     ApiException exception =
918         ApiExceptionFactory.createException(
919             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
920     mockService.addException(exception);
921 
922     try {
923       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
924       client.listTransferConfigs(parent);
925       Assert.fail("No exception raised");
926     } catch (InvalidArgumentException e) {
927       // Expected exception.
928     }
929   }
930 
931   @Test
listTransferConfigsTest2()932   public void listTransferConfigsTest2() throws Exception {
933     TransferConfig responsesElement = TransferConfig.newBuilder().build();
934     ListTransferConfigsResponse expectedResponse =
935         ListTransferConfigsResponse.newBuilder()
936             .setNextPageToken("")
937             .addAllTransferConfigs(Arrays.asList(responsesElement))
938             .build();
939     mockService.addResponse(expectedResponse);
940 
941     ProjectName parent = ProjectName.of("[PROJECT]");
942 
943     ListTransferConfigsPagedResponse pagedListResponse = client.listTransferConfigs(parent);
944 
945     List<TransferConfig> resources = Lists.newArrayList(pagedListResponse.iterateAll());
946 
947     Assert.assertEquals(1, resources.size());
948     Assert.assertEquals(expectedResponse.getTransferConfigsList().get(0), resources.get(0));
949 
950     List<String> actualRequests = mockService.getRequestPaths();
951     Assert.assertEquals(1, actualRequests.size());
952 
953     String apiClientHeaderKey =
954         mockService
955             .getRequestHeaders()
956             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
957             .iterator()
958             .next();
959     Assert.assertTrue(
960         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
961             .matcher(apiClientHeaderKey)
962             .matches());
963   }
964 
965   @Test
listTransferConfigsExceptionTest2()966   public void listTransferConfigsExceptionTest2() throws Exception {
967     ApiException exception =
968         ApiExceptionFactory.createException(
969             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
970     mockService.addException(exception);
971 
972     try {
973       ProjectName parent = ProjectName.of("[PROJECT]");
974       client.listTransferConfigs(parent);
975       Assert.fail("No exception raised");
976     } catch (InvalidArgumentException e) {
977       // Expected exception.
978     }
979   }
980 
981   @Test
listTransferConfigsTest3()982   public void listTransferConfigsTest3() throws Exception {
983     TransferConfig responsesElement = TransferConfig.newBuilder().build();
984     ListTransferConfigsResponse expectedResponse =
985         ListTransferConfigsResponse.newBuilder()
986             .setNextPageToken("")
987             .addAllTransferConfigs(Arrays.asList(responsesElement))
988             .build();
989     mockService.addResponse(expectedResponse);
990 
991     String parent = "projects/project-5833/locations/location-5833";
992 
993     ListTransferConfigsPagedResponse pagedListResponse = client.listTransferConfigs(parent);
994 
995     List<TransferConfig> resources = Lists.newArrayList(pagedListResponse.iterateAll());
996 
997     Assert.assertEquals(1, resources.size());
998     Assert.assertEquals(expectedResponse.getTransferConfigsList().get(0), resources.get(0));
999 
1000     List<String> actualRequests = mockService.getRequestPaths();
1001     Assert.assertEquals(1, actualRequests.size());
1002 
1003     String apiClientHeaderKey =
1004         mockService
1005             .getRequestHeaders()
1006             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1007             .iterator()
1008             .next();
1009     Assert.assertTrue(
1010         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1011             .matcher(apiClientHeaderKey)
1012             .matches());
1013   }
1014 
1015   @Test
listTransferConfigsExceptionTest3()1016   public void listTransferConfigsExceptionTest3() throws Exception {
1017     ApiException exception =
1018         ApiExceptionFactory.createException(
1019             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1020     mockService.addException(exception);
1021 
1022     try {
1023       String parent = "projects/project-5833/locations/location-5833";
1024       client.listTransferConfigs(parent);
1025       Assert.fail("No exception raised");
1026     } catch (InvalidArgumentException e) {
1027       // Expected exception.
1028     }
1029   }
1030 
1031   @Test
scheduleTransferRunsTest()1032   public void scheduleTransferRunsTest() throws Exception {
1033     ScheduleTransferRunsResponse expectedResponse =
1034         ScheduleTransferRunsResponse.newBuilder().addAllRuns(new ArrayList<TransferRun>()).build();
1035     mockService.addResponse(expectedResponse);
1036 
1037     TransferConfigName parent =
1038         TransferConfigName.ofProjectLocationTransferConfigName(
1039             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
1040     Timestamp startTime = Timestamp.newBuilder().build();
1041     Timestamp endTime = Timestamp.newBuilder().build();
1042 
1043     ScheduleTransferRunsResponse actualResponse =
1044         client.scheduleTransferRuns(parent, startTime, endTime);
1045     Assert.assertEquals(expectedResponse, actualResponse);
1046 
1047     List<String> actualRequests = mockService.getRequestPaths();
1048     Assert.assertEquals(1, actualRequests.size());
1049 
1050     String apiClientHeaderKey =
1051         mockService
1052             .getRequestHeaders()
1053             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1054             .iterator()
1055             .next();
1056     Assert.assertTrue(
1057         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1058             .matcher(apiClientHeaderKey)
1059             .matches());
1060   }
1061 
1062   @Test
scheduleTransferRunsExceptionTest()1063   public void scheduleTransferRunsExceptionTest() throws Exception {
1064     ApiException exception =
1065         ApiExceptionFactory.createException(
1066             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1067     mockService.addException(exception);
1068 
1069     try {
1070       TransferConfigName parent =
1071           TransferConfigName.ofProjectLocationTransferConfigName(
1072               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
1073       Timestamp startTime = Timestamp.newBuilder().build();
1074       Timestamp endTime = Timestamp.newBuilder().build();
1075       client.scheduleTransferRuns(parent, startTime, endTime);
1076       Assert.fail("No exception raised");
1077     } catch (InvalidArgumentException e) {
1078       // Expected exception.
1079     }
1080   }
1081 
1082   @Test
scheduleTransferRunsTest2()1083   public void scheduleTransferRunsTest2() throws Exception {
1084     ScheduleTransferRunsResponse expectedResponse =
1085         ScheduleTransferRunsResponse.newBuilder().addAllRuns(new ArrayList<TransferRun>()).build();
1086     mockService.addResponse(expectedResponse);
1087 
1088     String parent =
1089         "projects/project-3195/locations/location-3195/transferConfigs/transferConfig-3195";
1090     Timestamp startTime = Timestamp.newBuilder().build();
1091     Timestamp endTime = Timestamp.newBuilder().build();
1092 
1093     ScheduleTransferRunsResponse actualResponse =
1094         client.scheduleTransferRuns(parent, startTime, endTime);
1095     Assert.assertEquals(expectedResponse, actualResponse);
1096 
1097     List<String> actualRequests = mockService.getRequestPaths();
1098     Assert.assertEquals(1, actualRequests.size());
1099 
1100     String apiClientHeaderKey =
1101         mockService
1102             .getRequestHeaders()
1103             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1104             .iterator()
1105             .next();
1106     Assert.assertTrue(
1107         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1108             .matcher(apiClientHeaderKey)
1109             .matches());
1110   }
1111 
1112   @Test
scheduleTransferRunsExceptionTest2()1113   public void scheduleTransferRunsExceptionTest2() throws Exception {
1114     ApiException exception =
1115         ApiExceptionFactory.createException(
1116             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1117     mockService.addException(exception);
1118 
1119     try {
1120       String parent =
1121           "projects/project-3195/locations/location-3195/transferConfigs/transferConfig-3195";
1122       Timestamp startTime = Timestamp.newBuilder().build();
1123       Timestamp endTime = Timestamp.newBuilder().build();
1124       client.scheduleTransferRuns(parent, startTime, endTime);
1125       Assert.fail("No exception raised");
1126     } catch (InvalidArgumentException e) {
1127       // Expected exception.
1128     }
1129   }
1130 
1131   @Test
startManualTransferRunsTest()1132   public void startManualTransferRunsTest() throws Exception {
1133     StartManualTransferRunsResponse expectedResponse =
1134         StartManualTransferRunsResponse.newBuilder()
1135             .addAllRuns(new ArrayList<TransferRun>())
1136             .build();
1137     mockService.addResponse(expectedResponse);
1138 
1139     StartManualTransferRunsRequest request =
1140         StartManualTransferRunsRequest.newBuilder()
1141             .setParent(
1142                 TransferConfigName.ofProjectLocationTransferConfigName(
1143                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
1144                     .toString())
1145             .build();
1146 
1147     StartManualTransferRunsResponse actualResponse = client.startManualTransferRuns(request);
1148     Assert.assertEquals(expectedResponse, actualResponse);
1149 
1150     List<String> actualRequests = mockService.getRequestPaths();
1151     Assert.assertEquals(1, actualRequests.size());
1152 
1153     String apiClientHeaderKey =
1154         mockService
1155             .getRequestHeaders()
1156             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1157             .iterator()
1158             .next();
1159     Assert.assertTrue(
1160         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1161             .matcher(apiClientHeaderKey)
1162             .matches());
1163   }
1164 
1165   @Test
startManualTransferRunsExceptionTest()1166   public void startManualTransferRunsExceptionTest() throws Exception {
1167     ApiException exception =
1168         ApiExceptionFactory.createException(
1169             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1170     mockService.addException(exception);
1171 
1172     try {
1173       StartManualTransferRunsRequest request =
1174           StartManualTransferRunsRequest.newBuilder()
1175               .setParent(
1176                   TransferConfigName.ofProjectLocationTransferConfigName(
1177                           "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
1178                       .toString())
1179               .build();
1180       client.startManualTransferRuns(request);
1181       Assert.fail("No exception raised");
1182     } catch (InvalidArgumentException e) {
1183       // Expected exception.
1184     }
1185   }
1186 
1187   @Test
getTransferRunTest()1188   public void getTransferRunTest() throws Exception {
1189     TransferRun expectedResponse =
1190         TransferRun.newBuilder()
1191             .setName(
1192                 RunName.ofProjectLocationTransferConfigRunName(
1193                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
1194                     .toString())
1195             .setScheduleTime(Timestamp.newBuilder().build())
1196             .setRunTime(Timestamp.newBuilder().build())
1197             .setErrorStatus(Status.newBuilder().build())
1198             .setStartTime(Timestamp.newBuilder().build())
1199             .setEndTime(Timestamp.newBuilder().build())
1200             .setUpdateTime(Timestamp.newBuilder().build())
1201             .setParams(Struct.newBuilder().build())
1202             .setDataSourceId("dataSourceId-1221402528")
1203             .setState(TransferState.forNumber(0))
1204             .setUserId(-147132913)
1205             .setSchedule("schedule-697920873")
1206             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
1207             .setEmailPreferences(EmailPreferences.newBuilder().build())
1208             .build();
1209     mockService.addResponse(expectedResponse);
1210 
1211     RunName name =
1212         RunName.ofProjectLocationTransferConfigRunName(
1213             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1214 
1215     TransferRun actualResponse = client.getTransferRun(name);
1216     Assert.assertEquals(expectedResponse, actualResponse);
1217 
1218     List<String> actualRequests = mockService.getRequestPaths();
1219     Assert.assertEquals(1, actualRequests.size());
1220 
1221     String apiClientHeaderKey =
1222         mockService
1223             .getRequestHeaders()
1224             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1225             .iterator()
1226             .next();
1227     Assert.assertTrue(
1228         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1229             .matcher(apiClientHeaderKey)
1230             .matches());
1231   }
1232 
1233   @Test
getTransferRunExceptionTest()1234   public void getTransferRunExceptionTest() throws Exception {
1235     ApiException exception =
1236         ApiExceptionFactory.createException(
1237             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1238     mockService.addException(exception);
1239 
1240     try {
1241       RunName name =
1242           RunName.ofProjectLocationTransferConfigRunName(
1243               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1244       client.getTransferRun(name);
1245       Assert.fail("No exception raised");
1246     } catch (InvalidArgumentException e) {
1247       // Expected exception.
1248     }
1249   }
1250 
1251   @Test
getTransferRunTest2()1252   public void getTransferRunTest2() throws Exception {
1253     TransferRun expectedResponse =
1254         TransferRun.newBuilder()
1255             .setName(
1256                 RunName.ofProjectLocationTransferConfigRunName(
1257                         "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
1258                     .toString())
1259             .setScheduleTime(Timestamp.newBuilder().build())
1260             .setRunTime(Timestamp.newBuilder().build())
1261             .setErrorStatus(Status.newBuilder().build())
1262             .setStartTime(Timestamp.newBuilder().build())
1263             .setEndTime(Timestamp.newBuilder().build())
1264             .setUpdateTime(Timestamp.newBuilder().build())
1265             .setParams(Struct.newBuilder().build())
1266             .setDataSourceId("dataSourceId-1221402528")
1267             .setState(TransferState.forNumber(0))
1268             .setUserId(-147132913)
1269             .setSchedule("schedule-697920873")
1270             .setNotificationPubsubTopic("notificationPubsubTopic-1361224991")
1271             .setEmailPreferences(EmailPreferences.newBuilder().build())
1272             .build();
1273     mockService.addResponse(expectedResponse);
1274 
1275     String name =
1276         "projects/project-9834/locations/location-9834/transferConfigs/transferConfig-9834/runs/run-9834";
1277 
1278     TransferRun actualResponse = client.getTransferRun(name);
1279     Assert.assertEquals(expectedResponse, actualResponse);
1280 
1281     List<String> actualRequests = mockService.getRequestPaths();
1282     Assert.assertEquals(1, actualRequests.size());
1283 
1284     String apiClientHeaderKey =
1285         mockService
1286             .getRequestHeaders()
1287             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1288             .iterator()
1289             .next();
1290     Assert.assertTrue(
1291         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1292             .matcher(apiClientHeaderKey)
1293             .matches());
1294   }
1295 
1296   @Test
getTransferRunExceptionTest2()1297   public void getTransferRunExceptionTest2() throws Exception {
1298     ApiException exception =
1299         ApiExceptionFactory.createException(
1300             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1301     mockService.addException(exception);
1302 
1303     try {
1304       String name =
1305           "projects/project-9834/locations/location-9834/transferConfigs/transferConfig-9834/runs/run-9834";
1306       client.getTransferRun(name);
1307       Assert.fail("No exception raised");
1308     } catch (InvalidArgumentException e) {
1309       // Expected exception.
1310     }
1311   }
1312 
1313   @Test
deleteTransferRunTest()1314   public void deleteTransferRunTest() throws Exception {
1315     Empty expectedResponse = Empty.newBuilder().build();
1316     mockService.addResponse(expectedResponse);
1317 
1318     RunName name =
1319         RunName.ofProjectLocationTransferConfigRunName(
1320             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1321 
1322     client.deleteTransferRun(name);
1323 
1324     List<String> actualRequests = mockService.getRequestPaths();
1325     Assert.assertEquals(1, actualRequests.size());
1326 
1327     String apiClientHeaderKey =
1328         mockService
1329             .getRequestHeaders()
1330             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1331             .iterator()
1332             .next();
1333     Assert.assertTrue(
1334         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1335             .matcher(apiClientHeaderKey)
1336             .matches());
1337   }
1338 
1339   @Test
deleteTransferRunExceptionTest()1340   public void deleteTransferRunExceptionTest() throws Exception {
1341     ApiException exception =
1342         ApiExceptionFactory.createException(
1343             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1344     mockService.addException(exception);
1345 
1346     try {
1347       RunName name =
1348           RunName.ofProjectLocationTransferConfigRunName(
1349               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1350       client.deleteTransferRun(name);
1351       Assert.fail("No exception raised");
1352     } catch (InvalidArgumentException e) {
1353       // Expected exception.
1354     }
1355   }
1356 
1357   @Test
deleteTransferRunTest2()1358   public void deleteTransferRunTest2() throws Exception {
1359     Empty expectedResponse = Empty.newBuilder().build();
1360     mockService.addResponse(expectedResponse);
1361 
1362     String name =
1363         "projects/project-9834/locations/location-9834/transferConfigs/transferConfig-9834/runs/run-9834";
1364 
1365     client.deleteTransferRun(name);
1366 
1367     List<String> actualRequests = mockService.getRequestPaths();
1368     Assert.assertEquals(1, actualRequests.size());
1369 
1370     String apiClientHeaderKey =
1371         mockService
1372             .getRequestHeaders()
1373             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1374             .iterator()
1375             .next();
1376     Assert.assertTrue(
1377         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1378             .matcher(apiClientHeaderKey)
1379             .matches());
1380   }
1381 
1382   @Test
deleteTransferRunExceptionTest2()1383   public void deleteTransferRunExceptionTest2() throws Exception {
1384     ApiException exception =
1385         ApiExceptionFactory.createException(
1386             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1387     mockService.addException(exception);
1388 
1389     try {
1390       String name =
1391           "projects/project-9834/locations/location-9834/transferConfigs/transferConfig-9834/runs/run-9834";
1392       client.deleteTransferRun(name);
1393       Assert.fail("No exception raised");
1394     } catch (InvalidArgumentException e) {
1395       // Expected exception.
1396     }
1397   }
1398 
1399   @Test
listTransferRunsTest()1400   public void listTransferRunsTest() throws Exception {
1401     TransferRun responsesElement = TransferRun.newBuilder().build();
1402     ListTransferRunsResponse expectedResponse =
1403         ListTransferRunsResponse.newBuilder()
1404             .setNextPageToken("")
1405             .addAllTransferRuns(Arrays.asList(responsesElement))
1406             .build();
1407     mockService.addResponse(expectedResponse);
1408 
1409     TransferConfigName parent =
1410         TransferConfigName.ofProjectLocationTransferConfigName(
1411             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
1412 
1413     ListTransferRunsPagedResponse pagedListResponse = client.listTransferRuns(parent);
1414 
1415     List<TransferRun> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1416 
1417     Assert.assertEquals(1, resources.size());
1418     Assert.assertEquals(expectedResponse.getTransferRunsList().get(0), resources.get(0));
1419 
1420     List<String> actualRequests = mockService.getRequestPaths();
1421     Assert.assertEquals(1, actualRequests.size());
1422 
1423     String apiClientHeaderKey =
1424         mockService
1425             .getRequestHeaders()
1426             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1427             .iterator()
1428             .next();
1429     Assert.assertTrue(
1430         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1431             .matcher(apiClientHeaderKey)
1432             .matches());
1433   }
1434 
1435   @Test
listTransferRunsExceptionTest()1436   public void listTransferRunsExceptionTest() throws Exception {
1437     ApiException exception =
1438         ApiExceptionFactory.createException(
1439             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1440     mockService.addException(exception);
1441 
1442     try {
1443       TransferConfigName parent =
1444           TransferConfigName.ofProjectLocationTransferConfigName(
1445               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]");
1446       client.listTransferRuns(parent);
1447       Assert.fail("No exception raised");
1448     } catch (InvalidArgumentException e) {
1449       // Expected exception.
1450     }
1451   }
1452 
1453   @Test
listTransferRunsTest2()1454   public void listTransferRunsTest2() throws Exception {
1455     TransferRun responsesElement = TransferRun.newBuilder().build();
1456     ListTransferRunsResponse expectedResponse =
1457         ListTransferRunsResponse.newBuilder()
1458             .setNextPageToken("")
1459             .addAllTransferRuns(Arrays.asList(responsesElement))
1460             .build();
1461     mockService.addResponse(expectedResponse);
1462 
1463     String parent =
1464         "projects/project-3195/locations/location-3195/transferConfigs/transferConfig-3195";
1465 
1466     ListTransferRunsPagedResponse pagedListResponse = client.listTransferRuns(parent);
1467 
1468     List<TransferRun> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1469 
1470     Assert.assertEquals(1, resources.size());
1471     Assert.assertEquals(expectedResponse.getTransferRunsList().get(0), resources.get(0));
1472 
1473     List<String> actualRequests = mockService.getRequestPaths();
1474     Assert.assertEquals(1, actualRequests.size());
1475 
1476     String apiClientHeaderKey =
1477         mockService
1478             .getRequestHeaders()
1479             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1480             .iterator()
1481             .next();
1482     Assert.assertTrue(
1483         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1484             .matcher(apiClientHeaderKey)
1485             .matches());
1486   }
1487 
1488   @Test
listTransferRunsExceptionTest2()1489   public void listTransferRunsExceptionTest2() throws Exception {
1490     ApiException exception =
1491         ApiExceptionFactory.createException(
1492             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1493     mockService.addException(exception);
1494 
1495     try {
1496       String parent =
1497           "projects/project-3195/locations/location-3195/transferConfigs/transferConfig-3195";
1498       client.listTransferRuns(parent);
1499       Assert.fail("No exception raised");
1500     } catch (InvalidArgumentException e) {
1501       // Expected exception.
1502     }
1503   }
1504 
1505   @Test
listTransferLogsTest()1506   public void listTransferLogsTest() throws Exception {
1507     TransferMessage responsesElement = TransferMessage.newBuilder().build();
1508     ListTransferLogsResponse expectedResponse =
1509         ListTransferLogsResponse.newBuilder()
1510             .setNextPageToken("")
1511             .addAllTransferMessages(Arrays.asList(responsesElement))
1512             .build();
1513     mockService.addResponse(expectedResponse);
1514 
1515     RunName parent =
1516         RunName.ofProjectLocationTransferConfigRunName(
1517             "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1518 
1519     ListTransferLogsPagedResponse pagedListResponse = client.listTransferLogs(parent);
1520 
1521     List<TransferMessage> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1522 
1523     Assert.assertEquals(1, resources.size());
1524     Assert.assertEquals(expectedResponse.getTransferMessagesList().get(0), resources.get(0));
1525 
1526     List<String> actualRequests = mockService.getRequestPaths();
1527     Assert.assertEquals(1, actualRequests.size());
1528 
1529     String apiClientHeaderKey =
1530         mockService
1531             .getRequestHeaders()
1532             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1533             .iterator()
1534             .next();
1535     Assert.assertTrue(
1536         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1537             .matcher(apiClientHeaderKey)
1538             .matches());
1539   }
1540 
1541   @Test
listTransferLogsExceptionTest()1542   public void listTransferLogsExceptionTest() throws Exception {
1543     ApiException exception =
1544         ApiExceptionFactory.createException(
1545             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1546     mockService.addException(exception);
1547 
1548     try {
1549       RunName parent =
1550           RunName.ofProjectLocationTransferConfigRunName(
1551               "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]");
1552       client.listTransferLogs(parent);
1553       Assert.fail("No exception raised");
1554     } catch (InvalidArgumentException e) {
1555       // Expected exception.
1556     }
1557   }
1558 
1559   @Test
listTransferLogsTest2()1560   public void listTransferLogsTest2() throws Exception {
1561     TransferMessage responsesElement = TransferMessage.newBuilder().build();
1562     ListTransferLogsResponse expectedResponse =
1563         ListTransferLogsResponse.newBuilder()
1564             .setNextPageToken("")
1565             .addAllTransferMessages(Arrays.asList(responsesElement))
1566             .build();
1567     mockService.addResponse(expectedResponse);
1568 
1569     String parent =
1570         "projects/project-215/locations/location-215/transferConfigs/transferConfig-215/runs/run-215";
1571 
1572     ListTransferLogsPagedResponse pagedListResponse = client.listTransferLogs(parent);
1573 
1574     List<TransferMessage> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1575 
1576     Assert.assertEquals(1, resources.size());
1577     Assert.assertEquals(expectedResponse.getTransferMessagesList().get(0), resources.get(0));
1578 
1579     List<String> actualRequests = mockService.getRequestPaths();
1580     Assert.assertEquals(1, actualRequests.size());
1581 
1582     String apiClientHeaderKey =
1583         mockService
1584             .getRequestHeaders()
1585             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1586             .iterator()
1587             .next();
1588     Assert.assertTrue(
1589         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1590             .matcher(apiClientHeaderKey)
1591             .matches());
1592   }
1593 
1594   @Test
listTransferLogsExceptionTest2()1595   public void listTransferLogsExceptionTest2() throws Exception {
1596     ApiException exception =
1597         ApiExceptionFactory.createException(
1598             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1599     mockService.addException(exception);
1600 
1601     try {
1602       String parent =
1603           "projects/project-215/locations/location-215/transferConfigs/transferConfig-215/runs/run-215";
1604       client.listTransferLogs(parent);
1605       Assert.fail("No exception raised");
1606     } catch (InvalidArgumentException e) {
1607       // Expected exception.
1608     }
1609   }
1610 
1611   @Test
checkValidCredsTest()1612   public void checkValidCredsTest() throws Exception {
1613     CheckValidCredsResponse expectedResponse =
1614         CheckValidCredsResponse.newBuilder().setHasValidCreds(true).build();
1615     mockService.addResponse(expectedResponse);
1616 
1617     DataSourceName name =
1618         DataSourceName.ofProjectLocationDataSourceName("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]");
1619 
1620     CheckValidCredsResponse actualResponse = client.checkValidCreds(name);
1621     Assert.assertEquals(expectedResponse, actualResponse);
1622 
1623     List<String> actualRequests = mockService.getRequestPaths();
1624     Assert.assertEquals(1, actualRequests.size());
1625 
1626     String apiClientHeaderKey =
1627         mockService
1628             .getRequestHeaders()
1629             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1630             .iterator()
1631             .next();
1632     Assert.assertTrue(
1633         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1634             .matcher(apiClientHeaderKey)
1635             .matches());
1636   }
1637 
1638   @Test
checkValidCredsExceptionTest()1639   public void checkValidCredsExceptionTest() throws Exception {
1640     ApiException exception =
1641         ApiExceptionFactory.createException(
1642             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1643     mockService.addException(exception);
1644 
1645     try {
1646       DataSourceName name =
1647           DataSourceName.ofProjectLocationDataSourceName(
1648               "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]");
1649       client.checkValidCreds(name);
1650       Assert.fail("No exception raised");
1651     } catch (InvalidArgumentException e) {
1652       // Expected exception.
1653     }
1654   }
1655 
1656   @Test
checkValidCredsTest2()1657   public void checkValidCredsTest2() throws Exception {
1658     CheckValidCredsResponse expectedResponse =
1659         CheckValidCredsResponse.newBuilder().setHasValidCreds(true).build();
1660     mockService.addResponse(expectedResponse);
1661 
1662     String name = "projects/project-6044/locations/location-6044/dataSources/dataSource-6044";
1663 
1664     CheckValidCredsResponse actualResponse = client.checkValidCreds(name);
1665     Assert.assertEquals(expectedResponse, actualResponse);
1666 
1667     List<String> actualRequests = mockService.getRequestPaths();
1668     Assert.assertEquals(1, actualRequests.size());
1669 
1670     String apiClientHeaderKey =
1671         mockService
1672             .getRequestHeaders()
1673             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1674             .iterator()
1675             .next();
1676     Assert.assertTrue(
1677         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1678             .matcher(apiClientHeaderKey)
1679             .matches());
1680   }
1681 
1682   @Test
checkValidCredsExceptionTest2()1683   public void checkValidCredsExceptionTest2() throws Exception {
1684     ApiException exception =
1685         ApiExceptionFactory.createException(
1686             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1687     mockService.addException(exception);
1688 
1689     try {
1690       String name = "projects/project-6044/locations/location-6044/dataSources/dataSource-6044";
1691       client.checkValidCreds(name);
1692       Assert.fail("No exception raised");
1693     } catch (InvalidArgumentException e) {
1694       // Expected exception.
1695     }
1696   }
1697 
1698   @Test
enrollDataSourcesTest()1699   public void enrollDataSourcesTest() throws Exception {
1700     Empty expectedResponse = Empty.newBuilder().build();
1701     mockService.addResponse(expectedResponse);
1702 
1703     EnrollDataSourcesRequest request =
1704         EnrollDataSourcesRequest.newBuilder()
1705             .setName("projects/project-9062/locations/location-9062")
1706             .addAllDataSourceIds(new ArrayList<String>())
1707             .build();
1708 
1709     client.enrollDataSources(request);
1710 
1711     List<String> actualRequests = mockService.getRequestPaths();
1712     Assert.assertEquals(1, actualRequests.size());
1713 
1714     String apiClientHeaderKey =
1715         mockService
1716             .getRequestHeaders()
1717             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1718             .iterator()
1719             .next();
1720     Assert.assertTrue(
1721         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1722             .matcher(apiClientHeaderKey)
1723             .matches());
1724   }
1725 
1726   @Test
enrollDataSourcesExceptionTest()1727   public void enrollDataSourcesExceptionTest() throws Exception {
1728     ApiException exception =
1729         ApiExceptionFactory.createException(
1730             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1731     mockService.addException(exception);
1732 
1733     try {
1734       EnrollDataSourcesRequest request =
1735           EnrollDataSourcesRequest.newBuilder()
1736               .setName("projects/project-9062/locations/location-9062")
1737               .addAllDataSourceIds(new ArrayList<String>())
1738               .build();
1739       client.enrollDataSources(request);
1740       Assert.fail("No exception raised");
1741     } catch (InvalidArgumentException e) {
1742       // Expected exception.
1743     }
1744   }
1745 
1746   @Test
listLocationsTest()1747   public void listLocationsTest() throws Exception {
1748     Location responsesElement = Location.newBuilder().build();
1749     ListLocationsResponse expectedResponse =
1750         ListLocationsResponse.newBuilder()
1751             .setNextPageToken("")
1752             .addAllLocations(Arrays.asList(responsesElement))
1753             .build();
1754     mockService.addResponse(expectedResponse);
1755 
1756     ListLocationsRequest request =
1757         ListLocationsRequest.newBuilder()
1758             .setName("projects/project-3664")
1759             .setFilter("filter-1274492040")
1760             .setPageSize(883849137)
1761             .setPageToken("pageToken873572522")
1762             .build();
1763 
1764     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1765 
1766     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1767 
1768     Assert.assertEquals(1, resources.size());
1769     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1770 
1771     List<String> actualRequests = mockService.getRequestPaths();
1772     Assert.assertEquals(1, actualRequests.size());
1773 
1774     String apiClientHeaderKey =
1775         mockService
1776             .getRequestHeaders()
1777             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1778             .iterator()
1779             .next();
1780     Assert.assertTrue(
1781         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1782             .matcher(apiClientHeaderKey)
1783             .matches());
1784   }
1785 
1786   @Test
listLocationsExceptionTest()1787   public void listLocationsExceptionTest() throws Exception {
1788     ApiException exception =
1789         ApiExceptionFactory.createException(
1790             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1791     mockService.addException(exception);
1792 
1793     try {
1794       ListLocationsRequest request =
1795           ListLocationsRequest.newBuilder()
1796               .setName("projects/project-3664")
1797               .setFilter("filter-1274492040")
1798               .setPageSize(883849137)
1799               .setPageToken("pageToken873572522")
1800               .build();
1801       client.listLocations(request);
1802       Assert.fail("No exception raised");
1803     } catch (InvalidArgumentException e) {
1804       // Expected exception.
1805     }
1806   }
1807 
1808   @Test
getLocationTest()1809   public void getLocationTest() throws Exception {
1810     Location expectedResponse =
1811         Location.newBuilder()
1812             .setName("name3373707")
1813             .setLocationId("locationId1541836720")
1814             .setDisplayName("displayName1714148973")
1815             .putAllLabels(new HashMap<String, String>())
1816             .setMetadata(Any.newBuilder().build())
1817             .build();
1818     mockService.addResponse(expectedResponse);
1819 
1820     GetLocationRequest request =
1821         GetLocationRequest.newBuilder()
1822             .setName("projects/project-9062/locations/location-9062")
1823             .build();
1824 
1825     Location actualResponse = client.getLocation(request);
1826     Assert.assertEquals(expectedResponse, actualResponse);
1827 
1828     List<String> actualRequests = mockService.getRequestPaths();
1829     Assert.assertEquals(1, actualRequests.size());
1830 
1831     String apiClientHeaderKey =
1832         mockService
1833             .getRequestHeaders()
1834             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1835             .iterator()
1836             .next();
1837     Assert.assertTrue(
1838         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1839             .matcher(apiClientHeaderKey)
1840             .matches());
1841   }
1842 
1843   @Test
getLocationExceptionTest()1844   public void getLocationExceptionTest() throws Exception {
1845     ApiException exception =
1846         ApiExceptionFactory.createException(
1847             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1848     mockService.addException(exception);
1849 
1850     try {
1851       GetLocationRequest request =
1852           GetLocationRequest.newBuilder()
1853               .setName("projects/project-9062/locations/location-9062")
1854               .build();
1855       client.getLocation(request);
1856       Assert.fail("No exception raised");
1857     } catch (InvalidArgumentException e) {
1858       // Expected exception.
1859     }
1860   }
1861 }
1862