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