• 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.devtools.cloudbuild.v1;
18 
19 import static com.google.cloud.devtools.cloudbuild.v1.CloudBuildClient.ListBuildTriggersPagedResponse;
20 import static com.google.cloud.devtools.cloudbuild.v1.CloudBuildClient.ListBuildsPagedResponse;
21 import static com.google.cloud.devtools.cloudbuild.v1.CloudBuildClient.ListWorkerPoolsPagedResponse;
22 
23 import com.google.api.HttpBody;
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
26 import com.google.api.gax.httpjson.testing.MockHttpService;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.ApiException;
29 import com.google.api.gax.rpc.ApiExceptionFactory;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.api.gax.rpc.testing.FakeStatusCode;
33 import com.google.cloud.devtools.cloudbuild.v1.stub.HttpJsonCloudBuildStub;
34 import com.google.cloudbuild.v1.ApprovalResult;
35 import com.google.cloudbuild.v1.Artifacts;
36 import com.google.cloudbuild.v1.Build;
37 import com.google.cloudbuild.v1.BuildApproval;
38 import com.google.cloudbuild.v1.BuildName;
39 import com.google.cloudbuild.v1.BuildOptions;
40 import com.google.cloudbuild.v1.BuildStep;
41 import com.google.cloudbuild.v1.BuildTrigger;
42 import com.google.cloudbuild.v1.BuildTriggerName;
43 import com.google.cloudbuild.v1.GitHubEventsConfig;
44 import com.google.cloudbuild.v1.ListBuildTriggersResponse;
45 import com.google.cloudbuild.v1.ListBuildsResponse;
46 import com.google.cloudbuild.v1.ListWorkerPoolsResponse;
47 import com.google.cloudbuild.v1.LocationName;
48 import com.google.cloudbuild.v1.PubsubConfig;
49 import com.google.cloudbuild.v1.ReceiveTriggerWebhookRequest;
50 import com.google.cloudbuild.v1.ReceiveTriggerWebhookResponse;
51 import com.google.cloudbuild.v1.RepoSource;
52 import com.google.cloudbuild.v1.Results;
53 import com.google.cloudbuild.v1.Secret;
54 import com.google.cloudbuild.v1.Secrets;
55 import com.google.cloudbuild.v1.Source;
56 import com.google.cloudbuild.v1.SourceProvenance;
57 import com.google.cloudbuild.v1.TimeSpan;
58 import com.google.cloudbuild.v1.WebhookConfig;
59 import com.google.cloudbuild.v1.WorkerPool;
60 import com.google.cloudbuild.v1.WorkerPoolName;
61 import com.google.common.collect.Lists;
62 import com.google.longrunning.Operation;
63 import com.google.protobuf.Any;
64 import com.google.protobuf.Duration;
65 import com.google.protobuf.Empty;
66 import com.google.protobuf.FieldMask;
67 import com.google.protobuf.Timestamp;
68 import java.io.IOException;
69 import java.util.ArrayList;
70 import java.util.Arrays;
71 import java.util.HashMap;
72 import java.util.List;
73 import java.util.concurrent.ExecutionException;
74 import javax.annotation.Generated;
75 import org.junit.After;
76 import org.junit.AfterClass;
77 import org.junit.Assert;
78 import org.junit.Before;
79 import org.junit.BeforeClass;
80 import org.junit.Test;
81 
82 @Generated("by gapic-generator-java")
83 public class CloudBuildClientHttpJsonTest {
84   private static MockHttpService mockService;
85   private static CloudBuildClient client;
86 
87   @BeforeClass
startStaticServer()88   public static void startStaticServer() throws IOException {
89     mockService =
90         new MockHttpService(
91             HttpJsonCloudBuildStub.getMethodDescriptors(), CloudBuildSettings.getDefaultEndpoint());
92     CloudBuildSettings settings =
93         CloudBuildSettings.newHttpJsonBuilder()
94             .setTransportChannelProvider(
95                 CloudBuildSettings.defaultHttpJsonTransportProviderBuilder()
96                     .setHttpTransport(mockService)
97                     .build())
98             .setCredentialsProvider(NoCredentialsProvider.create())
99             .build();
100     client = CloudBuildClient.create(settings);
101   }
102 
103   @AfterClass
stopServer()104   public static void stopServer() {
105     client.close();
106   }
107 
108   @Before
setUp()109   public void setUp() {}
110 
111   @After
tearDown()112   public void tearDown() throws Exception {
113     mockService.reset();
114   }
115 
116   @Test
createBuildTest()117   public void createBuildTest() throws Exception {
118     Build expectedResponse =
119         Build.newBuilder()
120             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
121             .setId("id3355")
122             .setProjectId("projectId-894832108")
123             .setStatusDetail("statusDetail1651087075")
124             .setSource(Source.newBuilder().build())
125             .addAllSteps(new ArrayList<BuildStep>())
126             .setResults(Results.newBuilder().build())
127             .setCreateTime(Timestamp.newBuilder().build())
128             .setStartTime(Timestamp.newBuilder().build())
129             .setFinishTime(Timestamp.newBuilder().build())
130             .setTimeout(Duration.newBuilder().build())
131             .addAllImages(new ArrayList<String>())
132             .setQueueTtl(Duration.newBuilder().build())
133             .setArtifacts(Artifacts.newBuilder().build())
134             .setLogsBucket("logsBucket1592573049")
135             .setSourceProvenance(SourceProvenance.newBuilder().build())
136             .setBuildTriggerId("buildTriggerId781747749")
137             .setOptions(BuildOptions.newBuilder().build())
138             .setLogUrl("logUrl-1097354357")
139             .putAllSubstitutions(new HashMap<String, String>())
140             .addAllTags(new ArrayList<String>())
141             .addAllSecrets(new ArrayList<Secret>())
142             .putAllTiming(new HashMap<String, TimeSpan>())
143             .setApproval(BuildApproval.newBuilder().build())
144             .setServiceAccount("serviceAccount1079137720")
145             .setAvailableSecrets(Secrets.newBuilder().build())
146             .addAllWarnings(new ArrayList<Build.Warning>())
147             .setFailureInfo(Build.FailureInfo.newBuilder().build())
148             .build();
149     Operation resultOperation =
150         Operation.newBuilder()
151             .setName("createBuildTest")
152             .setDone(true)
153             .setResponse(Any.pack(expectedResponse))
154             .build();
155     mockService.addResponse(resultOperation);
156 
157     String projectId = "projectId-1530";
158     Build build = Build.newBuilder().build();
159 
160     Build actualResponse = client.createBuildAsync(projectId, build).get();
161     Assert.assertEquals(expectedResponse, actualResponse);
162 
163     List<String> actualRequests = mockService.getRequestPaths();
164     Assert.assertEquals(1, actualRequests.size());
165 
166     String apiClientHeaderKey =
167         mockService
168             .getRequestHeaders()
169             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
170             .iterator()
171             .next();
172     Assert.assertTrue(
173         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
174             .matcher(apiClientHeaderKey)
175             .matches());
176   }
177 
178   @Test
createBuildExceptionTest()179   public void createBuildExceptionTest() throws Exception {
180     ApiException exception =
181         ApiExceptionFactory.createException(
182             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
183     mockService.addException(exception);
184 
185     try {
186       String projectId = "projectId-1530";
187       Build build = Build.newBuilder().build();
188       client.createBuildAsync(projectId, build).get();
189       Assert.fail("No exception raised");
190     } catch (ExecutionException e) {
191     }
192   }
193 
194   @Test
getBuildTest()195   public void getBuildTest() throws Exception {
196     Build expectedResponse =
197         Build.newBuilder()
198             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
199             .setId("id3355")
200             .setProjectId("projectId-894832108")
201             .setStatusDetail("statusDetail1651087075")
202             .setSource(Source.newBuilder().build())
203             .addAllSteps(new ArrayList<BuildStep>())
204             .setResults(Results.newBuilder().build())
205             .setCreateTime(Timestamp.newBuilder().build())
206             .setStartTime(Timestamp.newBuilder().build())
207             .setFinishTime(Timestamp.newBuilder().build())
208             .setTimeout(Duration.newBuilder().build())
209             .addAllImages(new ArrayList<String>())
210             .setQueueTtl(Duration.newBuilder().build())
211             .setArtifacts(Artifacts.newBuilder().build())
212             .setLogsBucket("logsBucket1592573049")
213             .setSourceProvenance(SourceProvenance.newBuilder().build())
214             .setBuildTriggerId("buildTriggerId781747749")
215             .setOptions(BuildOptions.newBuilder().build())
216             .setLogUrl("logUrl-1097354357")
217             .putAllSubstitutions(new HashMap<String, String>())
218             .addAllTags(new ArrayList<String>())
219             .addAllSecrets(new ArrayList<Secret>())
220             .putAllTiming(new HashMap<String, TimeSpan>())
221             .setApproval(BuildApproval.newBuilder().build())
222             .setServiceAccount("serviceAccount1079137720")
223             .setAvailableSecrets(Secrets.newBuilder().build())
224             .addAllWarnings(new ArrayList<Build.Warning>())
225             .setFailureInfo(Build.FailureInfo.newBuilder().build())
226             .build();
227     mockService.addResponse(expectedResponse);
228 
229     String projectId = "projectId-1530";
230     String id = "id-4047";
231 
232     Build actualResponse = client.getBuild(projectId, id);
233     Assert.assertEquals(expectedResponse, actualResponse);
234 
235     List<String> actualRequests = mockService.getRequestPaths();
236     Assert.assertEquals(1, actualRequests.size());
237 
238     String apiClientHeaderKey =
239         mockService
240             .getRequestHeaders()
241             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
242             .iterator()
243             .next();
244     Assert.assertTrue(
245         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
246             .matcher(apiClientHeaderKey)
247             .matches());
248   }
249 
250   @Test
getBuildExceptionTest()251   public void getBuildExceptionTest() throws Exception {
252     ApiException exception =
253         ApiExceptionFactory.createException(
254             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
255     mockService.addException(exception);
256 
257     try {
258       String projectId = "projectId-1530";
259       String id = "id-4047";
260       client.getBuild(projectId, id);
261       Assert.fail("No exception raised");
262     } catch (InvalidArgumentException e) {
263       // Expected exception.
264     }
265   }
266 
267   @Test
listBuildsTest()268   public void listBuildsTest() throws Exception {
269     Build responsesElement = Build.newBuilder().build();
270     ListBuildsResponse expectedResponse =
271         ListBuildsResponse.newBuilder()
272             .setNextPageToken("")
273             .addAllBuilds(Arrays.asList(responsesElement))
274             .build();
275     mockService.addResponse(expectedResponse);
276 
277     String projectId = "projectId-1530";
278     String filter = "filter-1274492040";
279 
280     ListBuildsPagedResponse pagedListResponse = client.listBuilds(projectId, filter);
281 
282     List<Build> resources = Lists.newArrayList(pagedListResponse.iterateAll());
283 
284     Assert.assertEquals(1, resources.size());
285     Assert.assertEquals(expectedResponse.getBuildsList().get(0), resources.get(0));
286 
287     List<String> actualRequests = mockService.getRequestPaths();
288     Assert.assertEquals(1, actualRequests.size());
289 
290     String apiClientHeaderKey =
291         mockService
292             .getRequestHeaders()
293             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
294             .iterator()
295             .next();
296     Assert.assertTrue(
297         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
298             .matcher(apiClientHeaderKey)
299             .matches());
300   }
301 
302   @Test
listBuildsExceptionTest()303   public void listBuildsExceptionTest() throws Exception {
304     ApiException exception =
305         ApiExceptionFactory.createException(
306             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
307     mockService.addException(exception);
308 
309     try {
310       String projectId = "projectId-1530";
311       String filter = "filter-1274492040";
312       client.listBuilds(projectId, filter);
313       Assert.fail("No exception raised");
314     } catch (InvalidArgumentException e) {
315       // Expected exception.
316     }
317   }
318 
319   @Test
cancelBuildTest()320   public void cancelBuildTest() throws Exception {
321     Build expectedResponse =
322         Build.newBuilder()
323             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
324             .setId("id3355")
325             .setProjectId("projectId-894832108")
326             .setStatusDetail("statusDetail1651087075")
327             .setSource(Source.newBuilder().build())
328             .addAllSteps(new ArrayList<BuildStep>())
329             .setResults(Results.newBuilder().build())
330             .setCreateTime(Timestamp.newBuilder().build())
331             .setStartTime(Timestamp.newBuilder().build())
332             .setFinishTime(Timestamp.newBuilder().build())
333             .setTimeout(Duration.newBuilder().build())
334             .addAllImages(new ArrayList<String>())
335             .setQueueTtl(Duration.newBuilder().build())
336             .setArtifacts(Artifacts.newBuilder().build())
337             .setLogsBucket("logsBucket1592573049")
338             .setSourceProvenance(SourceProvenance.newBuilder().build())
339             .setBuildTriggerId("buildTriggerId781747749")
340             .setOptions(BuildOptions.newBuilder().build())
341             .setLogUrl("logUrl-1097354357")
342             .putAllSubstitutions(new HashMap<String, String>())
343             .addAllTags(new ArrayList<String>())
344             .addAllSecrets(new ArrayList<Secret>())
345             .putAllTiming(new HashMap<String, TimeSpan>())
346             .setApproval(BuildApproval.newBuilder().build())
347             .setServiceAccount("serviceAccount1079137720")
348             .setAvailableSecrets(Secrets.newBuilder().build())
349             .addAllWarnings(new ArrayList<Build.Warning>())
350             .setFailureInfo(Build.FailureInfo.newBuilder().build())
351             .build();
352     mockService.addResponse(expectedResponse);
353 
354     String projectId = "projectId-1530";
355     String id = "id-4047";
356 
357     Build actualResponse = client.cancelBuild(projectId, id);
358     Assert.assertEquals(expectedResponse, actualResponse);
359 
360     List<String> actualRequests = mockService.getRequestPaths();
361     Assert.assertEquals(1, actualRequests.size());
362 
363     String apiClientHeaderKey =
364         mockService
365             .getRequestHeaders()
366             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
367             .iterator()
368             .next();
369     Assert.assertTrue(
370         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
371             .matcher(apiClientHeaderKey)
372             .matches());
373   }
374 
375   @Test
cancelBuildExceptionTest()376   public void cancelBuildExceptionTest() throws Exception {
377     ApiException exception =
378         ApiExceptionFactory.createException(
379             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
380     mockService.addException(exception);
381 
382     try {
383       String projectId = "projectId-1530";
384       String id = "id-4047";
385       client.cancelBuild(projectId, id);
386       Assert.fail("No exception raised");
387     } catch (InvalidArgumentException e) {
388       // Expected exception.
389     }
390   }
391 
392   @Test
retryBuildTest()393   public void retryBuildTest() throws Exception {
394     Build expectedResponse =
395         Build.newBuilder()
396             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
397             .setId("id3355")
398             .setProjectId("projectId-894832108")
399             .setStatusDetail("statusDetail1651087075")
400             .setSource(Source.newBuilder().build())
401             .addAllSteps(new ArrayList<BuildStep>())
402             .setResults(Results.newBuilder().build())
403             .setCreateTime(Timestamp.newBuilder().build())
404             .setStartTime(Timestamp.newBuilder().build())
405             .setFinishTime(Timestamp.newBuilder().build())
406             .setTimeout(Duration.newBuilder().build())
407             .addAllImages(new ArrayList<String>())
408             .setQueueTtl(Duration.newBuilder().build())
409             .setArtifacts(Artifacts.newBuilder().build())
410             .setLogsBucket("logsBucket1592573049")
411             .setSourceProvenance(SourceProvenance.newBuilder().build())
412             .setBuildTriggerId("buildTriggerId781747749")
413             .setOptions(BuildOptions.newBuilder().build())
414             .setLogUrl("logUrl-1097354357")
415             .putAllSubstitutions(new HashMap<String, String>())
416             .addAllTags(new ArrayList<String>())
417             .addAllSecrets(new ArrayList<Secret>())
418             .putAllTiming(new HashMap<String, TimeSpan>())
419             .setApproval(BuildApproval.newBuilder().build())
420             .setServiceAccount("serviceAccount1079137720")
421             .setAvailableSecrets(Secrets.newBuilder().build())
422             .addAllWarnings(new ArrayList<Build.Warning>())
423             .setFailureInfo(Build.FailureInfo.newBuilder().build())
424             .build();
425     Operation resultOperation =
426         Operation.newBuilder()
427             .setName("retryBuildTest")
428             .setDone(true)
429             .setResponse(Any.pack(expectedResponse))
430             .build();
431     mockService.addResponse(resultOperation);
432 
433     String projectId = "projectId-1530";
434     String id = "id-4047";
435 
436     Build actualResponse = client.retryBuildAsync(projectId, id).get();
437     Assert.assertEquals(expectedResponse, actualResponse);
438 
439     List<String> actualRequests = mockService.getRequestPaths();
440     Assert.assertEquals(1, actualRequests.size());
441 
442     String apiClientHeaderKey =
443         mockService
444             .getRequestHeaders()
445             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
446             .iterator()
447             .next();
448     Assert.assertTrue(
449         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
450             .matcher(apiClientHeaderKey)
451             .matches());
452   }
453 
454   @Test
retryBuildExceptionTest()455   public void retryBuildExceptionTest() throws Exception {
456     ApiException exception =
457         ApiExceptionFactory.createException(
458             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
459     mockService.addException(exception);
460 
461     try {
462       String projectId = "projectId-1530";
463       String id = "id-4047";
464       client.retryBuildAsync(projectId, id).get();
465       Assert.fail("No exception raised");
466     } catch (ExecutionException e) {
467     }
468   }
469 
470   @Test
approveBuildTest()471   public void approveBuildTest() throws Exception {
472     Build expectedResponse =
473         Build.newBuilder()
474             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
475             .setId("id3355")
476             .setProjectId("projectId-894832108")
477             .setStatusDetail("statusDetail1651087075")
478             .setSource(Source.newBuilder().build())
479             .addAllSteps(new ArrayList<BuildStep>())
480             .setResults(Results.newBuilder().build())
481             .setCreateTime(Timestamp.newBuilder().build())
482             .setStartTime(Timestamp.newBuilder().build())
483             .setFinishTime(Timestamp.newBuilder().build())
484             .setTimeout(Duration.newBuilder().build())
485             .addAllImages(new ArrayList<String>())
486             .setQueueTtl(Duration.newBuilder().build())
487             .setArtifacts(Artifacts.newBuilder().build())
488             .setLogsBucket("logsBucket1592573049")
489             .setSourceProvenance(SourceProvenance.newBuilder().build())
490             .setBuildTriggerId("buildTriggerId781747749")
491             .setOptions(BuildOptions.newBuilder().build())
492             .setLogUrl("logUrl-1097354357")
493             .putAllSubstitutions(new HashMap<String, String>())
494             .addAllTags(new ArrayList<String>())
495             .addAllSecrets(new ArrayList<Secret>())
496             .putAllTiming(new HashMap<String, TimeSpan>())
497             .setApproval(BuildApproval.newBuilder().build())
498             .setServiceAccount("serviceAccount1079137720")
499             .setAvailableSecrets(Secrets.newBuilder().build())
500             .addAllWarnings(new ArrayList<Build.Warning>())
501             .setFailureInfo(Build.FailureInfo.newBuilder().build())
502             .build();
503     Operation resultOperation =
504         Operation.newBuilder()
505             .setName("approveBuildTest")
506             .setDone(true)
507             .setResponse(Any.pack(expectedResponse))
508             .build();
509     mockService.addResponse(resultOperation);
510 
511     String name = "projects/project-3679/builds/build-3679";
512     ApprovalResult approvalResult = ApprovalResult.newBuilder().build();
513 
514     Build actualResponse = client.approveBuildAsync(name, approvalResult).get();
515     Assert.assertEquals(expectedResponse, actualResponse);
516 
517     List<String> actualRequests = mockService.getRequestPaths();
518     Assert.assertEquals(1, actualRequests.size());
519 
520     String apiClientHeaderKey =
521         mockService
522             .getRequestHeaders()
523             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
524             .iterator()
525             .next();
526     Assert.assertTrue(
527         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
528             .matcher(apiClientHeaderKey)
529             .matches());
530   }
531 
532   @Test
approveBuildExceptionTest()533   public void approveBuildExceptionTest() throws Exception {
534     ApiException exception =
535         ApiExceptionFactory.createException(
536             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
537     mockService.addException(exception);
538 
539     try {
540       String name = "projects/project-3679/builds/build-3679";
541       ApprovalResult approvalResult = ApprovalResult.newBuilder().build();
542       client.approveBuildAsync(name, approvalResult).get();
543       Assert.fail("No exception raised");
544     } catch (ExecutionException e) {
545     }
546   }
547 
548   @Test
createBuildTriggerTest()549   public void createBuildTriggerTest() throws Exception {
550     BuildTrigger expectedResponse =
551         BuildTrigger.newBuilder()
552             .setResourceName("resourceName-384566343")
553             .setId("id3355")
554             .setDescription("description-1724546052")
555             .setName(BuildTriggerName.ofProjectTriggerName("[PROJECT]", "[TRIGGER]").toString())
556             .addAllTags(new ArrayList<String>())
557             .setTriggerTemplate(RepoSource.newBuilder().build())
558             .setGithub(GitHubEventsConfig.newBuilder().build())
559             .setPubsubConfig(PubsubConfig.newBuilder().build())
560             .setWebhookConfig(WebhookConfig.newBuilder().build())
561             .setCreateTime(Timestamp.newBuilder().build())
562             .setDisabled(true)
563             .putAllSubstitutions(new HashMap<String, String>())
564             .addAllIgnoredFiles(new ArrayList<String>())
565             .addAllIncludedFiles(new ArrayList<String>())
566             .setFilter("filter-1274492040")
567             .setServiceAccount("serviceAccount1079137720")
568             .build();
569     mockService.addResponse(expectedResponse);
570 
571     String projectId = "projectId-1530";
572     BuildTrigger trigger = BuildTrigger.newBuilder().build();
573 
574     BuildTrigger actualResponse = client.createBuildTrigger(projectId, trigger);
575     Assert.assertEquals(expectedResponse, actualResponse);
576 
577     List<String> actualRequests = mockService.getRequestPaths();
578     Assert.assertEquals(1, actualRequests.size());
579 
580     String apiClientHeaderKey =
581         mockService
582             .getRequestHeaders()
583             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
584             .iterator()
585             .next();
586     Assert.assertTrue(
587         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
588             .matcher(apiClientHeaderKey)
589             .matches());
590   }
591 
592   @Test
createBuildTriggerExceptionTest()593   public void createBuildTriggerExceptionTest() throws Exception {
594     ApiException exception =
595         ApiExceptionFactory.createException(
596             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
597     mockService.addException(exception);
598 
599     try {
600       String projectId = "projectId-1530";
601       BuildTrigger trigger = BuildTrigger.newBuilder().build();
602       client.createBuildTrigger(projectId, trigger);
603       Assert.fail("No exception raised");
604     } catch (InvalidArgumentException e) {
605       // Expected exception.
606     }
607   }
608 
609   @Test
getBuildTriggerTest()610   public void getBuildTriggerTest() throws Exception {
611     BuildTrigger expectedResponse =
612         BuildTrigger.newBuilder()
613             .setResourceName("resourceName-384566343")
614             .setId("id3355")
615             .setDescription("description-1724546052")
616             .setName(BuildTriggerName.ofProjectTriggerName("[PROJECT]", "[TRIGGER]").toString())
617             .addAllTags(new ArrayList<String>())
618             .setTriggerTemplate(RepoSource.newBuilder().build())
619             .setGithub(GitHubEventsConfig.newBuilder().build())
620             .setPubsubConfig(PubsubConfig.newBuilder().build())
621             .setWebhookConfig(WebhookConfig.newBuilder().build())
622             .setCreateTime(Timestamp.newBuilder().build())
623             .setDisabled(true)
624             .putAllSubstitutions(new HashMap<String, String>())
625             .addAllIgnoredFiles(new ArrayList<String>())
626             .addAllIncludedFiles(new ArrayList<String>())
627             .setFilter("filter-1274492040")
628             .setServiceAccount("serviceAccount1079137720")
629             .build();
630     mockService.addResponse(expectedResponse);
631 
632     String projectId = "projectId-1530";
633     String triggerId = "triggerId-6343";
634 
635     BuildTrigger actualResponse = client.getBuildTrigger(projectId, triggerId);
636     Assert.assertEquals(expectedResponse, actualResponse);
637 
638     List<String> actualRequests = mockService.getRequestPaths();
639     Assert.assertEquals(1, actualRequests.size());
640 
641     String apiClientHeaderKey =
642         mockService
643             .getRequestHeaders()
644             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
645             .iterator()
646             .next();
647     Assert.assertTrue(
648         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
649             .matcher(apiClientHeaderKey)
650             .matches());
651   }
652 
653   @Test
getBuildTriggerExceptionTest()654   public void getBuildTriggerExceptionTest() throws Exception {
655     ApiException exception =
656         ApiExceptionFactory.createException(
657             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
658     mockService.addException(exception);
659 
660     try {
661       String projectId = "projectId-1530";
662       String triggerId = "triggerId-6343";
663       client.getBuildTrigger(projectId, triggerId);
664       Assert.fail("No exception raised");
665     } catch (InvalidArgumentException e) {
666       // Expected exception.
667     }
668   }
669 
670   @Test
listBuildTriggersTest()671   public void listBuildTriggersTest() throws Exception {
672     BuildTrigger responsesElement = BuildTrigger.newBuilder().build();
673     ListBuildTriggersResponse expectedResponse =
674         ListBuildTriggersResponse.newBuilder()
675             .setNextPageToken("")
676             .addAllTriggers(Arrays.asList(responsesElement))
677             .build();
678     mockService.addResponse(expectedResponse);
679 
680     String projectId = "projectId-1530";
681 
682     ListBuildTriggersPagedResponse pagedListResponse = client.listBuildTriggers(projectId);
683 
684     List<BuildTrigger> resources = Lists.newArrayList(pagedListResponse.iterateAll());
685 
686     Assert.assertEquals(1, resources.size());
687     Assert.assertEquals(expectedResponse.getTriggersList().get(0), resources.get(0));
688 
689     List<String> actualRequests = mockService.getRequestPaths();
690     Assert.assertEquals(1, actualRequests.size());
691 
692     String apiClientHeaderKey =
693         mockService
694             .getRequestHeaders()
695             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
696             .iterator()
697             .next();
698     Assert.assertTrue(
699         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
700             .matcher(apiClientHeaderKey)
701             .matches());
702   }
703 
704   @Test
listBuildTriggersExceptionTest()705   public void listBuildTriggersExceptionTest() throws Exception {
706     ApiException exception =
707         ApiExceptionFactory.createException(
708             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
709     mockService.addException(exception);
710 
711     try {
712       String projectId = "projectId-1530";
713       client.listBuildTriggers(projectId);
714       Assert.fail("No exception raised");
715     } catch (InvalidArgumentException e) {
716       // Expected exception.
717     }
718   }
719 
720   @Test
deleteBuildTriggerTest()721   public void deleteBuildTriggerTest() throws Exception {
722     Empty expectedResponse = Empty.newBuilder().build();
723     mockService.addResponse(expectedResponse);
724 
725     String projectId = "projectId-1530";
726     String triggerId = "triggerId-6343";
727 
728     client.deleteBuildTrigger(projectId, triggerId);
729 
730     List<String> actualRequests = mockService.getRequestPaths();
731     Assert.assertEquals(1, actualRequests.size());
732 
733     String apiClientHeaderKey =
734         mockService
735             .getRequestHeaders()
736             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
737             .iterator()
738             .next();
739     Assert.assertTrue(
740         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
741             .matcher(apiClientHeaderKey)
742             .matches());
743   }
744 
745   @Test
deleteBuildTriggerExceptionTest()746   public void deleteBuildTriggerExceptionTest() throws Exception {
747     ApiException exception =
748         ApiExceptionFactory.createException(
749             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
750     mockService.addException(exception);
751 
752     try {
753       String projectId = "projectId-1530";
754       String triggerId = "triggerId-6343";
755       client.deleteBuildTrigger(projectId, triggerId);
756       Assert.fail("No exception raised");
757     } catch (InvalidArgumentException e) {
758       // Expected exception.
759     }
760   }
761 
762   @Test
updateBuildTriggerTest()763   public void updateBuildTriggerTest() throws Exception {
764     BuildTrigger expectedResponse =
765         BuildTrigger.newBuilder()
766             .setResourceName("resourceName-384566343")
767             .setId("id3355")
768             .setDescription("description-1724546052")
769             .setName(BuildTriggerName.ofProjectTriggerName("[PROJECT]", "[TRIGGER]").toString())
770             .addAllTags(new ArrayList<String>())
771             .setTriggerTemplate(RepoSource.newBuilder().build())
772             .setGithub(GitHubEventsConfig.newBuilder().build())
773             .setPubsubConfig(PubsubConfig.newBuilder().build())
774             .setWebhookConfig(WebhookConfig.newBuilder().build())
775             .setCreateTime(Timestamp.newBuilder().build())
776             .setDisabled(true)
777             .putAllSubstitutions(new HashMap<String, String>())
778             .addAllIgnoredFiles(new ArrayList<String>())
779             .addAllIncludedFiles(new ArrayList<String>())
780             .setFilter("filter-1274492040")
781             .setServiceAccount("serviceAccount1079137720")
782             .build();
783     mockService.addResponse(expectedResponse);
784 
785     String projectId = "projectId-1530";
786     String triggerId = "triggerId-6343";
787     BuildTrigger trigger =
788         BuildTrigger.newBuilder()
789             .setResourceName("resourceName-384566343")
790             .setId("id3355")
791             .setDescription("description-1724546052")
792             .setName(BuildTriggerName.ofProjectTriggerName("[PROJECT]", "[TRIGGER]").toString())
793             .addAllTags(new ArrayList<String>())
794             .setTriggerTemplate(RepoSource.newBuilder().build())
795             .setGithub(GitHubEventsConfig.newBuilder().build())
796             .setPubsubConfig(PubsubConfig.newBuilder().build())
797             .setWebhookConfig(WebhookConfig.newBuilder().build())
798             .setCreateTime(Timestamp.newBuilder().build())
799             .setDisabled(true)
800             .putAllSubstitutions(new HashMap<String, String>())
801             .addAllIgnoredFiles(new ArrayList<String>())
802             .addAllIncludedFiles(new ArrayList<String>())
803             .setFilter("filter-1274492040")
804             .setServiceAccount("serviceAccount1079137720")
805             .build();
806 
807     BuildTrigger actualResponse = client.updateBuildTrigger(projectId, triggerId, trigger);
808     Assert.assertEquals(expectedResponse, actualResponse);
809 
810     List<String> actualRequests = mockService.getRequestPaths();
811     Assert.assertEquals(1, actualRequests.size());
812 
813     String apiClientHeaderKey =
814         mockService
815             .getRequestHeaders()
816             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
817             .iterator()
818             .next();
819     Assert.assertTrue(
820         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
821             .matcher(apiClientHeaderKey)
822             .matches());
823   }
824 
825   @Test
updateBuildTriggerExceptionTest()826   public void updateBuildTriggerExceptionTest() throws Exception {
827     ApiException exception =
828         ApiExceptionFactory.createException(
829             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
830     mockService.addException(exception);
831 
832     try {
833       String projectId = "projectId-1530";
834       String triggerId = "triggerId-6343";
835       BuildTrigger trigger =
836           BuildTrigger.newBuilder()
837               .setResourceName("resourceName-384566343")
838               .setId("id3355")
839               .setDescription("description-1724546052")
840               .setName(BuildTriggerName.ofProjectTriggerName("[PROJECT]", "[TRIGGER]").toString())
841               .addAllTags(new ArrayList<String>())
842               .setTriggerTemplate(RepoSource.newBuilder().build())
843               .setGithub(GitHubEventsConfig.newBuilder().build())
844               .setPubsubConfig(PubsubConfig.newBuilder().build())
845               .setWebhookConfig(WebhookConfig.newBuilder().build())
846               .setCreateTime(Timestamp.newBuilder().build())
847               .setDisabled(true)
848               .putAllSubstitutions(new HashMap<String, String>())
849               .addAllIgnoredFiles(new ArrayList<String>())
850               .addAllIncludedFiles(new ArrayList<String>())
851               .setFilter("filter-1274492040")
852               .setServiceAccount("serviceAccount1079137720")
853               .build();
854       client.updateBuildTrigger(projectId, triggerId, trigger);
855       Assert.fail("No exception raised");
856     } catch (InvalidArgumentException e) {
857       // Expected exception.
858     }
859   }
860 
861   @Test
runBuildTriggerTest()862   public void runBuildTriggerTest() throws Exception {
863     Build expectedResponse =
864         Build.newBuilder()
865             .setName(BuildName.ofProjectBuildName("[PROJECT]", "[BUILD]").toString())
866             .setId("id3355")
867             .setProjectId("projectId-894832108")
868             .setStatusDetail("statusDetail1651087075")
869             .setSource(Source.newBuilder().build())
870             .addAllSteps(new ArrayList<BuildStep>())
871             .setResults(Results.newBuilder().build())
872             .setCreateTime(Timestamp.newBuilder().build())
873             .setStartTime(Timestamp.newBuilder().build())
874             .setFinishTime(Timestamp.newBuilder().build())
875             .setTimeout(Duration.newBuilder().build())
876             .addAllImages(new ArrayList<String>())
877             .setQueueTtl(Duration.newBuilder().build())
878             .setArtifacts(Artifacts.newBuilder().build())
879             .setLogsBucket("logsBucket1592573049")
880             .setSourceProvenance(SourceProvenance.newBuilder().build())
881             .setBuildTriggerId("buildTriggerId781747749")
882             .setOptions(BuildOptions.newBuilder().build())
883             .setLogUrl("logUrl-1097354357")
884             .putAllSubstitutions(new HashMap<String, String>())
885             .addAllTags(new ArrayList<String>())
886             .addAllSecrets(new ArrayList<Secret>())
887             .putAllTiming(new HashMap<String, TimeSpan>())
888             .setApproval(BuildApproval.newBuilder().build())
889             .setServiceAccount("serviceAccount1079137720")
890             .setAvailableSecrets(Secrets.newBuilder().build())
891             .addAllWarnings(new ArrayList<Build.Warning>())
892             .setFailureInfo(Build.FailureInfo.newBuilder().build())
893             .build();
894     Operation resultOperation =
895         Operation.newBuilder()
896             .setName("runBuildTriggerTest")
897             .setDone(true)
898             .setResponse(Any.pack(expectedResponse))
899             .build();
900     mockService.addResponse(resultOperation);
901 
902     String projectId = "projectId-1530";
903     String triggerId = "triggerId-6343";
904     RepoSource source = RepoSource.newBuilder().build();
905 
906     Build actualResponse = client.runBuildTriggerAsync(projectId, triggerId, source).get();
907     Assert.assertEquals(expectedResponse, actualResponse);
908 
909     List<String> actualRequests = mockService.getRequestPaths();
910     Assert.assertEquals(1, actualRequests.size());
911 
912     String apiClientHeaderKey =
913         mockService
914             .getRequestHeaders()
915             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
916             .iterator()
917             .next();
918     Assert.assertTrue(
919         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
920             .matcher(apiClientHeaderKey)
921             .matches());
922   }
923 
924   @Test
runBuildTriggerExceptionTest()925   public void runBuildTriggerExceptionTest() throws Exception {
926     ApiException exception =
927         ApiExceptionFactory.createException(
928             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
929     mockService.addException(exception);
930 
931     try {
932       String projectId = "projectId-1530";
933       String triggerId = "triggerId-6343";
934       RepoSource source = RepoSource.newBuilder().build();
935       client.runBuildTriggerAsync(projectId, triggerId, source).get();
936       Assert.fail("No exception raised");
937     } catch (ExecutionException e) {
938     }
939   }
940 
941   @Test
receiveTriggerWebhookTest()942   public void receiveTriggerWebhookTest() throws Exception {
943     ReceiveTriggerWebhookResponse expectedResponse =
944         ReceiveTriggerWebhookResponse.newBuilder().build();
945     mockService.addResponse(expectedResponse);
946 
947     ReceiveTriggerWebhookRequest request =
948         ReceiveTriggerWebhookRequest.newBuilder()
949             .setName("name3373707")
950             .setBody(HttpBody.newBuilder().build())
951             .setProjectId("projectId-1530")
952             .setTrigger("trigger-3106")
953             .setSecret("secret-906277200")
954             .build();
955 
956     ReceiveTriggerWebhookResponse actualResponse = client.receiveTriggerWebhook(request);
957     Assert.assertEquals(expectedResponse, actualResponse);
958 
959     List<String> actualRequests = mockService.getRequestPaths();
960     Assert.assertEquals(1, actualRequests.size());
961 
962     String apiClientHeaderKey =
963         mockService
964             .getRequestHeaders()
965             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
966             .iterator()
967             .next();
968     Assert.assertTrue(
969         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
970             .matcher(apiClientHeaderKey)
971             .matches());
972   }
973 
974   @Test
receiveTriggerWebhookExceptionTest()975   public void receiveTriggerWebhookExceptionTest() throws Exception {
976     ApiException exception =
977         ApiExceptionFactory.createException(
978             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
979     mockService.addException(exception);
980 
981     try {
982       ReceiveTriggerWebhookRequest request =
983           ReceiveTriggerWebhookRequest.newBuilder()
984               .setName("name3373707")
985               .setBody(HttpBody.newBuilder().build())
986               .setProjectId("projectId-1530")
987               .setTrigger("trigger-3106")
988               .setSecret("secret-906277200")
989               .build();
990       client.receiveTriggerWebhook(request);
991       Assert.fail("No exception raised");
992     } catch (InvalidArgumentException e) {
993       // Expected exception.
994     }
995   }
996 
997   @Test
createWorkerPoolTest()998   public void createWorkerPoolTest() throws Exception {
999     WorkerPool expectedResponse =
1000         WorkerPool.newBuilder()
1001             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1002             .setDisplayName("displayName1714148973")
1003             .setUid("uid115792")
1004             .putAllAnnotations(new HashMap<String, String>())
1005             .setCreateTime(Timestamp.newBuilder().build())
1006             .setUpdateTime(Timestamp.newBuilder().build())
1007             .setDeleteTime(Timestamp.newBuilder().build())
1008             .setEtag("etag3123477")
1009             .build();
1010     Operation resultOperation =
1011         Operation.newBuilder()
1012             .setName("createWorkerPoolTest")
1013             .setDone(true)
1014             .setResponse(Any.pack(expectedResponse))
1015             .build();
1016     mockService.addResponse(resultOperation);
1017 
1018     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1019     WorkerPool workerPool = WorkerPool.newBuilder().build();
1020     String workerPoolId = "workerPoolId-46320779";
1021 
1022     WorkerPool actualResponse =
1023         client.createWorkerPoolAsync(parent, workerPool, workerPoolId).get();
1024     Assert.assertEquals(expectedResponse, actualResponse);
1025 
1026     List<String> actualRequests = mockService.getRequestPaths();
1027     Assert.assertEquals(1, actualRequests.size());
1028 
1029     String apiClientHeaderKey =
1030         mockService
1031             .getRequestHeaders()
1032             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1033             .iterator()
1034             .next();
1035     Assert.assertTrue(
1036         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1037             .matcher(apiClientHeaderKey)
1038             .matches());
1039   }
1040 
1041   @Test
createWorkerPoolExceptionTest()1042   public void createWorkerPoolExceptionTest() throws Exception {
1043     ApiException exception =
1044         ApiExceptionFactory.createException(
1045             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1046     mockService.addException(exception);
1047 
1048     try {
1049       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1050       WorkerPool workerPool = WorkerPool.newBuilder().build();
1051       String workerPoolId = "workerPoolId-46320779";
1052       client.createWorkerPoolAsync(parent, workerPool, workerPoolId).get();
1053       Assert.fail("No exception raised");
1054     } catch (ExecutionException e) {
1055     }
1056   }
1057 
1058   @Test
createWorkerPoolTest2()1059   public void createWorkerPoolTest2() throws Exception {
1060     WorkerPool expectedResponse =
1061         WorkerPool.newBuilder()
1062             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1063             .setDisplayName("displayName1714148973")
1064             .setUid("uid115792")
1065             .putAllAnnotations(new HashMap<String, String>())
1066             .setCreateTime(Timestamp.newBuilder().build())
1067             .setUpdateTime(Timestamp.newBuilder().build())
1068             .setDeleteTime(Timestamp.newBuilder().build())
1069             .setEtag("etag3123477")
1070             .build();
1071     Operation resultOperation =
1072         Operation.newBuilder()
1073             .setName("createWorkerPoolTest")
1074             .setDone(true)
1075             .setResponse(Any.pack(expectedResponse))
1076             .build();
1077     mockService.addResponse(resultOperation);
1078 
1079     String parent = "projects/project-5833/locations/location-5833";
1080     WorkerPool workerPool = WorkerPool.newBuilder().build();
1081     String workerPoolId = "workerPoolId-46320779";
1082 
1083     WorkerPool actualResponse =
1084         client.createWorkerPoolAsync(parent, workerPool, workerPoolId).get();
1085     Assert.assertEquals(expectedResponse, actualResponse);
1086 
1087     List<String> actualRequests = mockService.getRequestPaths();
1088     Assert.assertEquals(1, actualRequests.size());
1089 
1090     String apiClientHeaderKey =
1091         mockService
1092             .getRequestHeaders()
1093             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1094             .iterator()
1095             .next();
1096     Assert.assertTrue(
1097         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1098             .matcher(apiClientHeaderKey)
1099             .matches());
1100   }
1101 
1102   @Test
createWorkerPoolExceptionTest2()1103   public void createWorkerPoolExceptionTest2() throws Exception {
1104     ApiException exception =
1105         ApiExceptionFactory.createException(
1106             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1107     mockService.addException(exception);
1108 
1109     try {
1110       String parent = "projects/project-5833/locations/location-5833";
1111       WorkerPool workerPool = WorkerPool.newBuilder().build();
1112       String workerPoolId = "workerPoolId-46320779";
1113       client.createWorkerPoolAsync(parent, workerPool, workerPoolId).get();
1114       Assert.fail("No exception raised");
1115     } catch (ExecutionException e) {
1116     }
1117   }
1118 
1119   @Test
getWorkerPoolTest()1120   public void getWorkerPoolTest() throws Exception {
1121     WorkerPool expectedResponse =
1122         WorkerPool.newBuilder()
1123             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1124             .setDisplayName("displayName1714148973")
1125             .setUid("uid115792")
1126             .putAllAnnotations(new HashMap<String, String>())
1127             .setCreateTime(Timestamp.newBuilder().build())
1128             .setUpdateTime(Timestamp.newBuilder().build())
1129             .setDeleteTime(Timestamp.newBuilder().build())
1130             .setEtag("etag3123477")
1131             .build();
1132     mockService.addResponse(expectedResponse);
1133 
1134     WorkerPoolName name = WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]");
1135 
1136     WorkerPool actualResponse = client.getWorkerPool(name);
1137     Assert.assertEquals(expectedResponse, actualResponse);
1138 
1139     List<String> actualRequests = mockService.getRequestPaths();
1140     Assert.assertEquals(1, actualRequests.size());
1141 
1142     String apiClientHeaderKey =
1143         mockService
1144             .getRequestHeaders()
1145             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1146             .iterator()
1147             .next();
1148     Assert.assertTrue(
1149         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1150             .matcher(apiClientHeaderKey)
1151             .matches());
1152   }
1153 
1154   @Test
getWorkerPoolExceptionTest()1155   public void getWorkerPoolExceptionTest() throws Exception {
1156     ApiException exception =
1157         ApiExceptionFactory.createException(
1158             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1159     mockService.addException(exception);
1160 
1161     try {
1162       WorkerPoolName name = WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]");
1163       client.getWorkerPool(name);
1164       Assert.fail("No exception raised");
1165     } catch (InvalidArgumentException e) {
1166       // Expected exception.
1167     }
1168   }
1169 
1170   @Test
getWorkerPoolTest2()1171   public void getWorkerPoolTest2() throws Exception {
1172     WorkerPool expectedResponse =
1173         WorkerPool.newBuilder()
1174             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1175             .setDisplayName("displayName1714148973")
1176             .setUid("uid115792")
1177             .putAllAnnotations(new HashMap<String, String>())
1178             .setCreateTime(Timestamp.newBuilder().build())
1179             .setUpdateTime(Timestamp.newBuilder().build())
1180             .setDeleteTime(Timestamp.newBuilder().build())
1181             .setEtag("etag3123477")
1182             .build();
1183     mockService.addResponse(expectedResponse);
1184 
1185     String name = "projects/project-9807/locations/location-9807/workerPools/workerPool-9807";
1186 
1187     WorkerPool actualResponse = client.getWorkerPool(name);
1188     Assert.assertEquals(expectedResponse, actualResponse);
1189 
1190     List<String> actualRequests = mockService.getRequestPaths();
1191     Assert.assertEquals(1, actualRequests.size());
1192 
1193     String apiClientHeaderKey =
1194         mockService
1195             .getRequestHeaders()
1196             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1197             .iterator()
1198             .next();
1199     Assert.assertTrue(
1200         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1201             .matcher(apiClientHeaderKey)
1202             .matches());
1203   }
1204 
1205   @Test
getWorkerPoolExceptionTest2()1206   public void getWorkerPoolExceptionTest2() throws Exception {
1207     ApiException exception =
1208         ApiExceptionFactory.createException(
1209             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1210     mockService.addException(exception);
1211 
1212     try {
1213       String name = "projects/project-9807/locations/location-9807/workerPools/workerPool-9807";
1214       client.getWorkerPool(name);
1215       Assert.fail("No exception raised");
1216     } catch (InvalidArgumentException e) {
1217       // Expected exception.
1218     }
1219   }
1220 
1221   @Test
deleteWorkerPoolTest()1222   public void deleteWorkerPoolTest() throws Exception {
1223     Empty expectedResponse = Empty.newBuilder().build();
1224     Operation resultOperation =
1225         Operation.newBuilder()
1226             .setName("deleteWorkerPoolTest")
1227             .setDone(true)
1228             .setResponse(Any.pack(expectedResponse))
1229             .build();
1230     mockService.addResponse(resultOperation);
1231 
1232     WorkerPoolName name = WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]");
1233 
1234     client.deleteWorkerPoolAsync(name).get();
1235 
1236     List<String> actualRequests = mockService.getRequestPaths();
1237     Assert.assertEquals(1, actualRequests.size());
1238 
1239     String apiClientHeaderKey =
1240         mockService
1241             .getRequestHeaders()
1242             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1243             .iterator()
1244             .next();
1245     Assert.assertTrue(
1246         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1247             .matcher(apiClientHeaderKey)
1248             .matches());
1249   }
1250 
1251   @Test
deleteWorkerPoolExceptionTest()1252   public void deleteWorkerPoolExceptionTest() throws Exception {
1253     ApiException exception =
1254         ApiExceptionFactory.createException(
1255             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1256     mockService.addException(exception);
1257 
1258     try {
1259       WorkerPoolName name = WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]");
1260       client.deleteWorkerPoolAsync(name).get();
1261       Assert.fail("No exception raised");
1262     } catch (ExecutionException e) {
1263     }
1264   }
1265 
1266   @Test
deleteWorkerPoolTest2()1267   public void deleteWorkerPoolTest2() throws Exception {
1268     Empty expectedResponse = Empty.newBuilder().build();
1269     Operation resultOperation =
1270         Operation.newBuilder()
1271             .setName("deleteWorkerPoolTest")
1272             .setDone(true)
1273             .setResponse(Any.pack(expectedResponse))
1274             .build();
1275     mockService.addResponse(resultOperation);
1276 
1277     String name = "projects/project-9807/locations/location-9807/workerPools/workerPool-9807";
1278 
1279     client.deleteWorkerPoolAsync(name).get();
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
deleteWorkerPoolExceptionTest2()1297   public void deleteWorkerPoolExceptionTest2() 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 = "projects/project-9807/locations/location-9807/workerPools/workerPool-9807";
1305       client.deleteWorkerPoolAsync(name).get();
1306       Assert.fail("No exception raised");
1307     } catch (ExecutionException e) {
1308     }
1309   }
1310 
1311   @Test
updateWorkerPoolTest()1312   public void updateWorkerPoolTest() throws Exception {
1313     WorkerPool expectedResponse =
1314         WorkerPool.newBuilder()
1315             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1316             .setDisplayName("displayName1714148973")
1317             .setUid("uid115792")
1318             .putAllAnnotations(new HashMap<String, String>())
1319             .setCreateTime(Timestamp.newBuilder().build())
1320             .setUpdateTime(Timestamp.newBuilder().build())
1321             .setDeleteTime(Timestamp.newBuilder().build())
1322             .setEtag("etag3123477")
1323             .build();
1324     Operation resultOperation =
1325         Operation.newBuilder()
1326             .setName("updateWorkerPoolTest")
1327             .setDone(true)
1328             .setResponse(Any.pack(expectedResponse))
1329             .build();
1330     mockService.addResponse(resultOperation);
1331 
1332     WorkerPool workerPool =
1333         WorkerPool.newBuilder()
1334             .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1335             .setDisplayName("displayName1714148973")
1336             .setUid("uid115792")
1337             .putAllAnnotations(new HashMap<String, String>())
1338             .setCreateTime(Timestamp.newBuilder().build())
1339             .setUpdateTime(Timestamp.newBuilder().build())
1340             .setDeleteTime(Timestamp.newBuilder().build())
1341             .setEtag("etag3123477")
1342             .build();
1343     FieldMask updateMask = FieldMask.newBuilder().build();
1344 
1345     WorkerPool actualResponse = client.updateWorkerPoolAsync(workerPool, updateMask).get();
1346     Assert.assertEquals(expectedResponse, actualResponse);
1347 
1348     List<String> actualRequests = mockService.getRequestPaths();
1349     Assert.assertEquals(1, actualRequests.size());
1350 
1351     String apiClientHeaderKey =
1352         mockService
1353             .getRequestHeaders()
1354             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1355             .iterator()
1356             .next();
1357     Assert.assertTrue(
1358         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1359             .matcher(apiClientHeaderKey)
1360             .matches());
1361   }
1362 
1363   @Test
updateWorkerPoolExceptionTest()1364   public void updateWorkerPoolExceptionTest() throws Exception {
1365     ApiException exception =
1366         ApiExceptionFactory.createException(
1367             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1368     mockService.addException(exception);
1369 
1370     try {
1371       WorkerPool workerPool =
1372           WorkerPool.newBuilder()
1373               .setName(WorkerPoolName.of("[PROJECT]", "[LOCATION]", "[WORKER_POOL]").toString())
1374               .setDisplayName("displayName1714148973")
1375               .setUid("uid115792")
1376               .putAllAnnotations(new HashMap<String, String>())
1377               .setCreateTime(Timestamp.newBuilder().build())
1378               .setUpdateTime(Timestamp.newBuilder().build())
1379               .setDeleteTime(Timestamp.newBuilder().build())
1380               .setEtag("etag3123477")
1381               .build();
1382       FieldMask updateMask = FieldMask.newBuilder().build();
1383       client.updateWorkerPoolAsync(workerPool, updateMask).get();
1384       Assert.fail("No exception raised");
1385     } catch (ExecutionException e) {
1386     }
1387   }
1388 
1389   @Test
listWorkerPoolsTest()1390   public void listWorkerPoolsTest() throws Exception {
1391     WorkerPool responsesElement = WorkerPool.newBuilder().build();
1392     ListWorkerPoolsResponse expectedResponse =
1393         ListWorkerPoolsResponse.newBuilder()
1394             .setNextPageToken("")
1395             .addAllWorkerPools(Arrays.asList(responsesElement))
1396             .build();
1397     mockService.addResponse(expectedResponse);
1398 
1399     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1400 
1401     ListWorkerPoolsPagedResponse pagedListResponse = client.listWorkerPools(parent);
1402 
1403     List<WorkerPool> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1404 
1405     Assert.assertEquals(1, resources.size());
1406     Assert.assertEquals(expectedResponse.getWorkerPoolsList().get(0), resources.get(0));
1407 
1408     List<String> actualRequests = mockService.getRequestPaths();
1409     Assert.assertEquals(1, actualRequests.size());
1410 
1411     String apiClientHeaderKey =
1412         mockService
1413             .getRequestHeaders()
1414             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1415             .iterator()
1416             .next();
1417     Assert.assertTrue(
1418         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1419             .matcher(apiClientHeaderKey)
1420             .matches());
1421   }
1422 
1423   @Test
listWorkerPoolsExceptionTest()1424   public void listWorkerPoolsExceptionTest() throws Exception {
1425     ApiException exception =
1426         ApiExceptionFactory.createException(
1427             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1428     mockService.addException(exception);
1429 
1430     try {
1431       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1432       client.listWorkerPools(parent);
1433       Assert.fail("No exception raised");
1434     } catch (InvalidArgumentException e) {
1435       // Expected exception.
1436     }
1437   }
1438 
1439   @Test
listWorkerPoolsTest2()1440   public void listWorkerPoolsTest2() throws Exception {
1441     WorkerPool responsesElement = WorkerPool.newBuilder().build();
1442     ListWorkerPoolsResponse expectedResponse =
1443         ListWorkerPoolsResponse.newBuilder()
1444             .setNextPageToken("")
1445             .addAllWorkerPools(Arrays.asList(responsesElement))
1446             .build();
1447     mockService.addResponse(expectedResponse);
1448 
1449     String parent = "projects/project-5833/locations/location-5833";
1450 
1451     ListWorkerPoolsPagedResponse pagedListResponse = client.listWorkerPools(parent);
1452 
1453     List<WorkerPool> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1454 
1455     Assert.assertEquals(1, resources.size());
1456     Assert.assertEquals(expectedResponse.getWorkerPoolsList().get(0), resources.get(0));
1457 
1458     List<String> actualRequests = mockService.getRequestPaths();
1459     Assert.assertEquals(1, actualRequests.size());
1460 
1461     String apiClientHeaderKey =
1462         mockService
1463             .getRequestHeaders()
1464             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1465             .iterator()
1466             .next();
1467     Assert.assertTrue(
1468         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1469             .matcher(apiClientHeaderKey)
1470             .matches());
1471   }
1472 
1473   @Test
listWorkerPoolsExceptionTest2()1474   public void listWorkerPoolsExceptionTest2() throws Exception {
1475     ApiException exception =
1476         ApiExceptionFactory.createException(
1477             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1478     mockService.addException(exception);
1479 
1480     try {
1481       String parent = "projects/project-5833/locations/location-5833";
1482       client.listWorkerPools(parent);
1483       Assert.fail("No exception raised");
1484     } catch (InvalidArgumentException e) {
1485       // Expected exception.
1486     }
1487   }
1488 }
1489