• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.aiplatform.v1beta1;
18 
19 import static com.google.cloud.aiplatform.v1beta1.PipelineServiceClient.ListLocationsPagedResponse;
20 import static com.google.cloud.aiplatform.v1beta1.PipelineServiceClient.ListPipelineJobsPagedResponse;
21 import static com.google.cloud.aiplatform.v1beta1.PipelineServiceClient.ListTrainingPipelinesPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.grpc.GaxGrpcProperties;
25 import com.google.api.gax.grpc.testing.LocalChannelProvider;
26 import com.google.api.gax.grpc.testing.MockGrpcService;
27 import com.google.api.gax.grpc.testing.MockServiceHelper;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.cloud.location.GetLocationRequest;
32 import com.google.cloud.location.ListLocationsRequest;
33 import com.google.cloud.location.ListLocationsResponse;
34 import com.google.cloud.location.Location;
35 import com.google.common.collect.Lists;
36 import com.google.iam.v1.AuditConfig;
37 import com.google.iam.v1.Binding;
38 import com.google.iam.v1.GetIamPolicyRequest;
39 import com.google.iam.v1.GetPolicyOptions;
40 import com.google.iam.v1.Policy;
41 import com.google.iam.v1.SetIamPolicyRequest;
42 import com.google.iam.v1.TestIamPermissionsRequest;
43 import com.google.iam.v1.TestIamPermissionsResponse;
44 import com.google.longrunning.Operation;
45 import com.google.protobuf.AbstractMessage;
46 import com.google.protobuf.Any;
47 import com.google.protobuf.ByteString;
48 import com.google.protobuf.Empty;
49 import com.google.protobuf.FieldMask;
50 import com.google.protobuf.Struct;
51 import com.google.protobuf.Timestamp;
52 import com.google.protobuf.Value;
53 import com.google.rpc.Status;
54 import io.grpc.StatusRuntimeException;
55 import java.io.IOException;
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.HashMap;
59 import java.util.List;
60 import java.util.UUID;
61 import java.util.concurrent.ExecutionException;
62 import javax.annotation.Generated;
63 import org.junit.After;
64 import org.junit.AfterClass;
65 import org.junit.Assert;
66 import org.junit.Before;
67 import org.junit.BeforeClass;
68 import org.junit.Test;
69 
70 @Generated("by gapic-generator-java")
71 public class PipelineServiceClientTest {
72   private static MockIAMPolicy mockIAMPolicy;
73   private static MockLocations mockLocations;
74   private static MockPipelineService mockPipelineService;
75   private static MockServiceHelper mockServiceHelper;
76   private LocalChannelProvider channelProvider;
77   private PipelineServiceClient client;
78 
79   @BeforeClass
startStaticServer()80   public static void startStaticServer() {
81     mockPipelineService = new MockPipelineService();
82     mockLocations = new MockLocations();
83     mockIAMPolicy = new MockIAMPolicy();
84     mockServiceHelper =
85         new MockServiceHelper(
86             UUID.randomUUID().toString(),
87             Arrays.<MockGrpcService>asList(mockPipelineService, mockLocations, mockIAMPolicy));
88     mockServiceHelper.start();
89   }
90 
91   @AfterClass
stopServer()92   public static void stopServer() {
93     mockServiceHelper.stop();
94   }
95 
96   @Before
setUp()97   public void setUp() throws IOException {
98     mockServiceHelper.reset();
99     channelProvider = mockServiceHelper.createChannelProvider();
100     PipelineServiceSettings settings =
101         PipelineServiceSettings.newBuilder()
102             .setTransportChannelProvider(channelProvider)
103             .setCredentialsProvider(NoCredentialsProvider.create())
104             .build();
105     client = PipelineServiceClient.create(settings);
106   }
107 
108   @After
tearDown()109   public void tearDown() throws Exception {
110     client.close();
111   }
112 
113   @Test
createTrainingPipelineTest()114   public void createTrainingPipelineTest() throws Exception {
115     TrainingPipeline expectedResponse =
116         TrainingPipeline.newBuilder()
117             .setName(
118                 TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]")
119                     .toString())
120             .setDisplayName("displayName1714148973")
121             .setInputDataConfig(InputDataConfig.newBuilder().build())
122             .setTrainingTaskDefinition("trainingTaskDefinition-1218104270")
123             .setTrainingTaskInputs(Value.newBuilder().setBoolValue(true).build())
124             .setTrainingTaskMetadata(Value.newBuilder().setBoolValue(true).build())
125             .setModelToUpload(Model.newBuilder().build())
126             .setModelId("modelId1226956324")
127             .setParentModel("parentModel998431903")
128             .setState(PipelineState.forNumber(0))
129             .setError(Status.newBuilder().build())
130             .setCreateTime(Timestamp.newBuilder().build())
131             .setStartTime(Timestamp.newBuilder().build())
132             .setEndTime(Timestamp.newBuilder().build())
133             .setUpdateTime(Timestamp.newBuilder().build())
134             .putAllLabels(new HashMap<String, String>())
135             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
136             .build();
137     mockPipelineService.addResponse(expectedResponse);
138 
139     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
140     TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().build();
141 
142     TrainingPipeline actualResponse = client.createTrainingPipeline(parent, trainingPipeline);
143     Assert.assertEquals(expectedResponse, actualResponse);
144 
145     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
146     Assert.assertEquals(1, actualRequests.size());
147     CreateTrainingPipelineRequest actualRequest =
148         ((CreateTrainingPipelineRequest) actualRequests.get(0));
149 
150     Assert.assertEquals(parent.toString(), actualRequest.getParent());
151     Assert.assertEquals(trainingPipeline, actualRequest.getTrainingPipeline());
152     Assert.assertTrue(
153         channelProvider.isHeaderSent(
154             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
155             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
156   }
157 
158   @Test
createTrainingPipelineExceptionTest()159   public void createTrainingPipelineExceptionTest() throws Exception {
160     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
161     mockPipelineService.addException(exception);
162 
163     try {
164       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
165       TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().build();
166       client.createTrainingPipeline(parent, trainingPipeline);
167       Assert.fail("No exception raised");
168     } catch (InvalidArgumentException e) {
169       // Expected exception.
170     }
171   }
172 
173   @Test
createTrainingPipelineTest2()174   public void createTrainingPipelineTest2() throws Exception {
175     TrainingPipeline expectedResponse =
176         TrainingPipeline.newBuilder()
177             .setName(
178                 TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]")
179                     .toString())
180             .setDisplayName("displayName1714148973")
181             .setInputDataConfig(InputDataConfig.newBuilder().build())
182             .setTrainingTaskDefinition("trainingTaskDefinition-1218104270")
183             .setTrainingTaskInputs(Value.newBuilder().setBoolValue(true).build())
184             .setTrainingTaskMetadata(Value.newBuilder().setBoolValue(true).build())
185             .setModelToUpload(Model.newBuilder().build())
186             .setModelId("modelId1226956324")
187             .setParentModel("parentModel998431903")
188             .setState(PipelineState.forNumber(0))
189             .setError(Status.newBuilder().build())
190             .setCreateTime(Timestamp.newBuilder().build())
191             .setStartTime(Timestamp.newBuilder().build())
192             .setEndTime(Timestamp.newBuilder().build())
193             .setUpdateTime(Timestamp.newBuilder().build())
194             .putAllLabels(new HashMap<String, String>())
195             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
196             .build();
197     mockPipelineService.addResponse(expectedResponse);
198 
199     String parent = "parent-995424086";
200     TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().build();
201 
202     TrainingPipeline actualResponse = client.createTrainingPipeline(parent, trainingPipeline);
203     Assert.assertEquals(expectedResponse, actualResponse);
204 
205     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
206     Assert.assertEquals(1, actualRequests.size());
207     CreateTrainingPipelineRequest actualRequest =
208         ((CreateTrainingPipelineRequest) actualRequests.get(0));
209 
210     Assert.assertEquals(parent, actualRequest.getParent());
211     Assert.assertEquals(trainingPipeline, actualRequest.getTrainingPipeline());
212     Assert.assertTrue(
213         channelProvider.isHeaderSent(
214             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
215             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
216   }
217 
218   @Test
createTrainingPipelineExceptionTest2()219   public void createTrainingPipelineExceptionTest2() throws Exception {
220     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
221     mockPipelineService.addException(exception);
222 
223     try {
224       String parent = "parent-995424086";
225       TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().build();
226       client.createTrainingPipeline(parent, trainingPipeline);
227       Assert.fail("No exception raised");
228     } catch (InvalidArgumentException e) {
229       // Expected exception.
230     }
231   }
232 
233   @Test
getTrainingPipelineTest()234   public void getTrainingPipelineTest() throws Exception {
235     TrainingPipeline expectedResponse =
236         TrainingPipeline.newBuilder()
237             .setName(
238                 TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]")
239                     .toString())
240             .setDisplayName("displayName1714148973")
241             .setInputDataConfig(InputDataConfig.newBuilder().build())
242             .setTrainingTaskDefinition("trainingTaskDefinition-1218104270")
243             .setTrainingTaskInputs(Value.newBuilder().setBoolValue(true).build())
244             .setTrainingTaskMetadata(Value.newBuilder().setBoolValue(true).build())
245             .setModelToUpload(Model.newBuilder().build())
246             .setModelId("modelId1226956324")
247             .setParentModel("parentModel998431903")
248             .setState(PipelineState.forNumber(0))
249             .setError(Status.newBuilder().build())
250             .setCreateTime(Timestamp.newBuilder().build())
251             .setStartTime(Timestamp.newBuilder().build())
252             .setEndTime(Timestamp.newBuilder().build())
253             .setUpdateTime(Timestamp.newBuilder().build())
254             .putAllLabels(new HashMap<String, String>())
255             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
256             .build();
257     mockPipelineService.addResponse(expectedResponse);
258 
259     TrainingPipelineName name =
260         TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
261 
262     TrainingPipeline actualResponse = client.getTrainingPipeline(name);
263     Assert.assertEquals(expectedResponse, actualResponse);
264 
265     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
266     Assert.assertEquals(1, actualRequests.size());
267     GetTrainingPipelineRequest actualRequest = ((GetTrainingPipelineRequest) actualRequests.get(0));
268 
269     Assert.assertEquals(name.toString(), actualRequest.getName());
270     Assert.assertTrue(
271         channelProvider.isHeaderSent(
272             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
273             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
274   }
275 
276   @Test
getTrainingPipelineExceptionTest()277   public void getTrainingPipelineExceptionTest() throws Exception {
278     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
279     mockPipelineService.addException(exception);
280 
281     try {
282       TrainingPipelineName name =
283           TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
284       client.getTrainingPipeline(name);
285       Assert.fail("No exception raised");
286     } catch (InvalidArgumentException e) {
287       // Expected exception.
288     }
289   }
290 
291   @Test
getTrainingPipelineTest2()292   public void getTrainingPipelineTest2() throws Exception {
293     TrainingPipeline expectedResponse =
294         TrainingPipeline.newBuilder()
295             .setName(
296                 TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]")
297                     .toString())
298             .setDisplayName("displayName1714148973")
299             .setInputDataConfig(InputDataConfig.newBuilder().build())
300             .setTrainingTaskDefinition("trainingTaskDefinition-1218104270")
301             .setTrainingTaskInputs(Value.newBuilder().setBoolValue(true).build())
302             .setTrainingTaskMetadata(Value.newBuilder().setBoolValue(true).build())
303             .setModelToUpload(Model.newBuilder().build())
304             .setModelId("modelId1226956324")
305             .setParentModel("parentModel998431903")
306             .setState(PipelineState.forNumber(0))
307             .setError(Status.newBuilder().build())
308             .setCreateTime(Timestamp.newBuilder().build())
309             .setStartTime(Timestamp.newBuilder().build())
310             .setEndTime(Timestamp.newBuilder().build())
311             .setUpdateTime(Timestamp.newBuilder().build())
312             .putAllLabels(new HashMap<String, String>())
313             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
314             .build();
315     mockPipelineService.addResponse(expectedResponse);
316 
317     String name = "name3373707";
318 
319     TrainingPipeline actualResponse = client.getTrainingPipeline(name);
320     Assert.assertEquals(expectedResponse, actualResponse);
321 
322     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
323     Assert.assertEquals(1, actualRequests.size());
324     GetTrainingPipelineRequest actualRequest = ((GetTrainingPipelineRequest) actualRequests.get(0));
325 
326     Assert.assertEquals(name, actualRequest.getName());
327     Assert.assertTrue(
328         channelProvider.isHeaderSent(
329             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
330             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
331   }
332 
333   @Test
getTrainingPipelineExceptionTest2()334   public void getTrainingPipelineExceptionTest2() throws Exception {
335     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
336     mockPipelineService.addException(exception);
337 
338     try {
339       String name = "name3373707";
340       client.getTrainingPipeline(name);
341       Assert.fail("No exception raised");
342     } catch (InvalidArgumentException e) {
343       // Expected exception.
344     }
345   }
346 
347   @Test
listTrainingPipelinesTest()348   public void listTrainingPipelinesTest() throws Exception {
349     TrainingPipeline responsesElement = TrainingPipeline.newBuilder().build();
350     ListTrainingPipelinesResponse expectedResponse =
351         ListTrainingPipelinesResponse.newBuilder()
352             .setNextPageToken("")
353             .addAllTrainingPipelines(Arrays.asList(responsesElement))
354             .build();
355     mockPipelineService.addResponse(expectedResponse);
356 
357     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
358 
359     ListTrainingPipelinesPagedResponse pagedListResponse = client.listTrainingPipelines(parent);
360 
361     List<TrainingPipeline> resources = Lists.newArrayList(pagedListResponse.iterateAll());
362 
363     Assert.assertEquals(1, resources.size());
364     Assert.assertEquals(expectedResponse.getTrainingPipelinesList().get(0), resources.get(0));
365 
366     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
367     Assert.assertEquals(1, actualRequests.size());
368     ListTrainingPipelinesRequest actualRequest =
369         ((ListTrainingPipelinesRequest) actualRequests.get(0));
370 
371     Assert.assertEquals(parent.toString(), actualRequest.getParent());
372     Assert.assertTrue(
373         channelProvider.isHeaderSent(
374             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
375             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
376   }
377 
378   @Test
listTrainingPipelinesExceptionTest()379   public void listTrainingPipelinesExceptionTest() throws Exception {
380     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
381     mockPipelineService.addException(exception);
382 
383     try {
384       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
385       client.listTrainingPipelines(parent);
386       Assert.fail("No exception raised");
387     } catch (InvalidArgumentException e) {
388       // Expected exception.
389     }
390   }
391 
392   @Test
listTrainingPipelinesTest2()393   public void listTrainingPipelinesTest2() throws Exception {
394     TrainingPipeline responsesElement = TrainingPipeline.newBuilder().build();
395     ListTrainingPipelinesResponse expectedResponse =
396         ListTrainingPipelinesResponse.newBuilder()
397             .setNextPageToken("")
398             .addAllTrainingPipelines(Arrays.asList(responsesElement))
399             .build();
400     mockPipelineService.addResponse(expectedResponse);
401 
402     String parent = "parent-995424086";
403 
404     ListTrainingPipelinesPagedResponse pagedListResponse = client.listTrainingPipelines(parent);
405 
406     List<TrainingPipeline> resources = Lists.newArrayList(pagedListResponse.iterateAll());
407 
408     Assert.assertEquals(1, resources.size());
409     Assert.assertEquals(expectedResponse.getTrainingPipelinesList().get(0), resources.get(0));
410 
411     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
412     Assert.assertEquals(1, actualRequests.size());
413     ListTrainingPipelinesRequest actualRequest =
414         ((ListTrainingPipelinesRequest) actualRequests.get(0));
415 
416     Assert.assertEquals(parent, actualRequest.getParent());
417     Assert.assertTrue(
418         channelProvider.isHeaderSent(
419             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
420             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
421   }
422 
423   @Test
listTrainingPipelinesExceptionTest2()424   public void listTrainingPipelinesExceptionTest2() throws Exception {
425     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
426     mockPipelineService.addException(exception);
427 
428     try {
429       String parent = "parent-995424086";
430       client.listTrainingPipelines(parent);
431       Assert.fail("No exception raised");
432     } catch (InvalidArgumentException e) {
433       // Expected exception.
434     }
435   }
436 
437   @Test
deleteTrainingPipelineTest()438   public void deleteTrainingPipelineTest() throws Exception {
439     Empty expectedResponse = Empty.newBuilder().build();
440     Operation resultOperation =
441         Operation.newBuilder()
442             .setName("deleteTrainingPipelineTest")
443             .setDone(true)
444             .setResponse(Any.pack(expectedResponse))
445             .build();
446     mockPipelineService.addResponse(resultOperation);
447 
448     TrainingPipelineName name =
449         TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
450 
451     client.deleteTrainingPipelineAsync(name).get();
452 
453     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
454     Assert.assertEquals(1, actualRequests.size());
455     DeleteTrainingPipelineRequest actualRequest =
456         ((DeleteTrainingPipelineRequest) actualRequests.get(0));
457 
458     Assert.assertEquals(name.toString(), actualRequest.getName());
459     Assert.assertTrue(
460         channelProvider.isHeaderSent(
461             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
462             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
463   }
464 
465   @Test
deleteTrainingPipelineExceptionTest()466   public void deleteTrainingPipelineExceptionTest() throws Exception {
467     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
468     mockPipelineService.addException(exception);
469 
470     try {
471       TrainingPipelineName name =
472           TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
473       client.deleteTrainingPipelineAsync(name).get();
474       Assert.fail("No exception raised");
475     } catch (ExecutionException e) {
476       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
477       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
478       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
479     }
480   }
481 
482   @Test
deleteTrainingPipelineTest2()483   public void deleteTrainingPipelineTest2() throws Exception {
484     Empty expectedResponse = Empty.newBuilder().build();
485     Operation resultOperation =
486         Operation.newBuilder()
487             .setName("deleteTrainingPipelineTest")
488             .setDone(true)
489             .setResponse(Any.pack(expectedResponse))
490             .build();
491     mockPipelineService.addResponse(resultOperation);
492 
493     String name = "name3373707";
494 
495     client.deleteTrainingPipelineAsync(name).get();
496 
497     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
498     Assert.assertEquals(1, actualRequests.size());
499     DeleteTrainingPipelineRequest actualRequest =
500         ((DeleteTrainingPipelineRequest) actualRequests.get(0));
501 
502     Assert.assertEquals(name, actualRequest.getName());
503     Assert.assertTrue(
504         channelProvider.isHeaderSent(
505             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
506             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
507   }
508 
509   @Test
deleteTrainingPipelineExceptionTest2()510   public void deleteTrainingPipelineExceptionTest2() throws Exception {
511     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
512     mockPipelineService.addException(exception);
513 
514     try {
515       String name = "name3373707";
516       client.deleteTrainingPipelineAsync(name).get();
517       Assert.fail("No exception raised");
518     } catch (ExecutionException e) {
519       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
520       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
521       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
522     }
523   }
524 
525   @Test
cancelTrainingPipelineTest()526   public void cancelTrainingPipelineTest() throws Exception {
527     Empty expectedResponse = Empty.newBuilder().build();
528     mockPipelineService.addResponse(expectedResponse);
529 
530     TrainingPipelineName name =
531         TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
532 
533     client.cancelTrainingPipeline(name);
534 
535     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
536     Assert.assertEquals(1, actualRequests.size());
537     CancelTrainingPipelineRequest actualRequest =
538         ((CancelTrainingPipelineRequest) actualRequests.get(0));
539 
540     Assert.assertEquals(name.toString(), actualRequest.getName());
541     Assert.assertTrue(
542         channelProvider.isHeaderSent(
543             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
544             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
545   }
546 
547   @Test
cancelTrainingPipelineExceptionTest()548   public void cancelTrainingPipelineExceptionTest() throws Exception {
549     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
550     mockPipelineService.addException(exception);
551 
552     try {
553       TrainingPipelineName name =
554           TrainingPipelineName.of("[PROJECT]", "[LOCATION]", "[TRAINING_PIPELINE]");
555       client.cancelTrainingPipeline(name);
556       Assert.fail("No exception raised");
557     } catch (InvalidArgumentException e) {
558       // Expected exception.
559     }
560   }
561 
562   @Test
cancelTrainingPipelineTest2()563   public void cancelTrainingPipelineTest2() throws Exception {
564     Empty expectedResponse = Empty.newBuilder().build();
565     mockPipelineService.addResponse(expectedResponse);
566 
567     String name = "name3373707";
568 
569     client.cancelTrainingPipeline(name);
570 
571     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
572     Assert.assertEquals(1, actualRequests.size());
573     CancelTrainingPipelineRequest actualRequest =
574         ((CancelTrainingPipelineRequest) actualRequests.get(0));
575 
576     Assert.assertEquals(name, actualRequest.getName());
577     Assert.assertTrue(
578         channelProvider.isHeaderSent(
579             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
580             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
581   }
582 
583   @Test
cancelTrainingPipelineExceptionTest2()584   public void cancelTrainingPipelineExceptionTest2() throws Exception {
585     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
586     mockPipelineService.addException(exception);
587 
588     try {
589       String name = "name3373707";
590       client.cancelTrainingPipeline(name);
591       Assert.fail("No exception raised");
592     } catch (InvalidArgumentException e) {
593       // Expected exception.
594     }
595   }
596 
597   @Test
createPipelineJobTest()598   public void createPipelineJobTest() throws Exception {
599     PipelineJob expectedResponse =
600         PipelineJob.newBuilder()
601             .setName(PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]").toString())
602             .setDisplayName("displayName1714148973")
603             .setCreateTime(Timestamp.newBuilder().build())
604             .setStartTime(Timestamp.newBuilder().build())
605             .setEndTime(Timestamp.newBuilder().build())
606             .setUpdateTime(Timestamp.newBuilder().build())
607             .setPipelineSpec(Struct.newBuilder().build())
608             .setState(PipelineState.forNumber(0))
609             .setJobDetail(PipelineJobDetail.newBuilder().build())
610             .setError(Status.newBuilder().build())
611             .putAllLabels(new HashMap<String, String>())
612             .setRuntimeConfig(PipelineJob.RuntimeConfig.newBuilder().build())
613             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
614             .setServiceAccount("serviceAccount1079137720")
615             .setNetwork("network1843485230")
616             .setTemplateUri("templateUri1769633426")
617             .setTemplateMetadata(PipelineTemplateMetadata.newBuilder().build())
618             .build();
619     mockPipelineService.addResponse(expectedResponse);
620 
621     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
622     PipelineJob pipelineJob = PipelineJob.newBuilder().build();
623     String pipelineJobId = "pipelineJobId-1711315914";
624 
625     PipelineJob actualResponse = client.createPipelineJob(parent, pipelineJob, pipelineJobId);
626     Assert.assertEquals(expectedResponse, actualResponse);
627 
628     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
629     Assert.assertEquals(1, actualRequests.size());
630     CreatePipelineJobRequest actualRequest = ((CreatePipelineJobRequest) actualRequests.get(0));
631 
632     Assert.assertEquals(parent.toString(), actualRequest.getParent());
633     Assert.assertEquals(pipelineJob, actualRequest.getPipelineJob());
634     Assert.assertEquals(pipelineJobId, actualRequest.getPipelineJobId());
635     Assert.assertTrue(
636         channelProvider.isHeaderSent(
637             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
638             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
639   }
640 
641   @Test
createPipelineJobExceptionTest()642   public void createPipelineJobExceptionTest() throws Exception {
643     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
644     mockPipelineService.addException(exception);
645 
646     try {
647       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
648       PipelineJob pipelineJob = PipelineJob.newBuilder().build();
649       String pipelineJobId = "pipelineJobId-1711315914";
650       client.createPipelineJob(parent, pipelineJob, pipelineJobId);
651       Assert.fail("No exception raised");
652     } catch (InvalidArgumentException e) {
653       // Expected exception.
654     }
655   }
656 
657   @Test
createPipelineJobTest2()658   public void createPipelineJobTest2() throws Exception {
659     PipelineJob expectedResponse =
660         PipelineJob.newBuilder()
661             .setName(PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]").toString())
662             .setDisplayName("displayName1714148973")
663             .setCreateTime(Timestamp.newBuilder().build())
664             .setStartTime(Timestamp.newBuilder().build())
665             .setEndTime(Timestamp.newBuilder().build())
666             .setUpdateTime(Timestamp.newBuilder().build())
667             .setPipelineSpec(Struct.newBuilder().build())
668             .setState(PipelineState.forNumber(0))
669             .setJobDetail(PipelineJobDetail.newBuilder().build())
670             .setError(Status.newBuilder().build())
671             .putAllLabels(new HashMap<String, String>())
672             .setRuntimeConfig(PipelineJob.RuntimeConfig.newBuilder().build())
673             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
674             .setServiceAccount("serviceAccount1079137720")
675             .setNetwork("network1843485230")
676             .setTemplateUri("templateUri1769633426")
677             .setTemplateMetadata(PipelineTemplateMetadata.newBuilder().build())
678             .build();
679     mockPipelineService.addResponse(expectedResponse);
680 
681     String parent = "parent-995424086";
682     PipelineJob pipelineJob = PipelineJob.newBuilder().build();
683     String pipelineJobId = "pipelineJobId-1711315914";
684 
685     PipelineJob actualResponse = client.createPipelineJob(parent, pipelineJob, pipelineJobId);
686     Assert.assertEquals(expectedResponse, actualResponse);
687 
688     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
689     Assert.assertEquals(1, actualRequests.size());
690     CreatePipelineJobRequest actualRequest = ((CreatePipelineJobRequest) actualRequests.get(0));
691 
692     Assert.assertEquals(parent, actualRequest.getParent());
693     Assert.assertEquals(pipelineJob, actualRequest.getPipelineJob());
694     Assert.assertEquals(pipelineJobId, actualRequest.getPipelineJobId());
695     Assert.assertTrue(
696         channelProvider.isHeaderSent(
697             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
698             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
699   }
700 
701   @Test
createPipelineJobExceptionTest2()702   public void createPipelineJobExceptionTest2() throws Exception {
703     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
704     mockPipelineService.addException(exception);
705 
706     try {
707       String parent = "parent-995424086";
708       PipelineJob pipelineJob = PipelineJob.newBuilder().build();
709       String pipelineJobId = "pipelineJobId-1711315914";
710       client.createPipelineJob(parent, pipelineJob, pipelineJobId);
711       Assert.fail("No exception raised");
712     } catch (InvalidArgumentException e) {
713       // Expected exception.
714     }
715   }
716 
717   @Test
getPipelineJobTest()718   public void getPipelineJobTest() throws Exception {
719     PipelineJob expectedResponse =
720         PipelineJob.newBuilder()
721             .setName(PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]").toString())
722             .setDisplayName("displayName1714148973")
723             .setCreateTime(Timestamp.newBuilder().build())
724             .setStartTime(Timestamp.newBuilder().build())
725             .setEndTime(Timestamp.newBuilder().build())
726             .setUpdateTime(Timestamp.newBuilder().build())
727             .setPipelineSpec(Struct.newBuilder().build())
728             .setState(PipelineState.forNumber(0))
729             .setJobDetail(PipelineJobDetail.newBuilder().build())
730             .setError(Status.newBuilder().build())
731             .putAllLabels(new HashMap<String, String>())
732             .setRuntimeConfig(PipelineJob.RuntimeConfig.newBuilder().build())
733             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
734             .setServiceAccount("serviceAccount1079137720")
735             .setNetwork("network1843485230")
736             .setTemplateUri("templateUri1769633426")
737             .setTemplateMetadata(PipelineTemplateMetadata.newBuilder().build())
738             .build();
739     mockPipelineService.addResponse(expectedResponse);
740 
741     PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
742 
743     PipelineJob actualResponse = client.getPipelineJob(name);
744     Assert.assertEquals(expectedResponse, actualResponse);
745 
746     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
747     Assert.assertEquals(1, actualRequests.size());
748     GetPipelineJobRequest actualRequest = ((GetPipelineJobRequest) actualRequests.get(0));
749 
750     Assert.assertEquals(name.toString(), actualRequest.getName());
751     Assert.assertTrue(
752         channelProvider.isHeaderSent(
753             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
754             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
755   }
756 
757   @Test
getPipelineJobExceptionTest()758   public void getPipelineJobExceptionTest() throws Exception {
759     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
760     mockPipelineService.addException(exception);
761 
762     try {
763       PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
764       client.getPipelineJob(name);
765       Assert.fail("No exception raised");
766     } catch (InvalidArgumentException e) {
767       // Expected exception.
768     }
769   }
770 
771   @Test
getPipelineJobTest2()772   public void getPipelineJobTest2() throws Exception {
773     PipelineJob expectedResponse =
774         PipelineJob.newBuilder()
775             .setName(PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]").toString())
776             .setDisplayName("displayName1714148973")
777             .setCreateTime(Timestamp.newBuilder().build())
778             .setStartTime(Timestamp.newBuilder().build())
779             .setEndTime(Timestamp.newBuilder().build())
780             .setUpdateTime(Timestamp.newBuilder().build())
781             .setPipelineSpec(Struct.newBuilder().build())
782             .setState(PipelineState.forNumber(0))
783             .setJobDetail(PipelineJobDetail.newBuilder().build())
784             .setError(Status.newBuilder().build())
785             .putAllLabels(new HashMap<String, String>())
786             .setRuntimeConfig(PipelineJob.RuntimeConfig.newBuilder().build())
787             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
788             .setServiceAccount("serviceAccount1079137720")
789             .setNetwork("network1843485230")
790             .setTemplateUri("templateUri1769633426")
791             .setTemplateMetadata(PipelineTemplateMetadata.newBuilder().build())
792             .build();
793     mockPipelineService.addResponse(expectedResponse);
794 
795     String name = "name3373707";
796 
797     PipelineJob actualResponse = client.getPipelineJob(name);
798     Assert.assertEquals(expectedResponse, actualResponse);
799 
800     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
801     Assert.assertEquals(1, actualRequests.size());
802     GetPipelineJobRequest actualRequest = ((GetPipelineJobRequest) actualRequests.get(0));
803 
804     Assert.assertEquals(name, actualRequest.getName());
805     Assert.assertTrue(
806         channelProvider.isHeaderSent(
807             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
808             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
809   }
810 
811   @Test
getPipelineJobExceptionTest2()812   public void getPipelineJobExceptionTest2() throws Exception {
813     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
814     mockPipelineService.addException(exception);
815 
816     try {
817       String name = "name3373707";
818       client.getPipelineJob(name);
819       Assert.fail("No exception raised");
820     } catch (InvalidArgumentException e) {
821       // Expected exception.
822     }
823   }
824 
825   @Test
listPipelineJobsTest()826   public void listPipelineJobsTest() throws Exception {
827     PipelineJob responsesElement = PipelineJob.newBuilder().build();
828     ListPipelineJobsResponse expectedResponse =
829         ListPipelineJobsResponse.newBuilder()
830             .setNextPageToken("")
831             .addAllPipelineJobs(Arrays.asList(responsesElement))
832             .build();
833     mockPipelineService.addResponse(expectedResponse);
834 
835     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
836 
837     ListPipelineJobsPagedResponse pagedListResponse = client.listPipelineJobs(parent);
838 
839     List<PipelineJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
840 
841     Assert.assertEquals(1, resources.size());
842     Assert.assertEquals(expectedResponse.getPipelineJobsList().get(0), resources.get(0));
843 
844     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
845     Assert.assertEquals(1, actualRequests.size());
846     ListPipelineJobsRequest actualRequest = ((ListPipelineJobsRequest) actualRequests.get(0));
847 
848     Assert.assertEquals(parent.toString(), actualRequest.getParent());
849     Assert.assertTrue(
850         channelProvider.isHeaderSent(
851             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
852             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
853   }
854 
855   @Test
listPipelineJobsExceptionTest()856   public void listPipelineJobsExceptionTest() throws Exception {
857     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
858     mockPipelineService.addException(exception);
859 
860     try {
861       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
862       client.listPipelineJobs(parent);
863       Assert.fail("No exception raised");
864     } catch (InvalidArgumentException e) {
865       // Expected exception.
866     }
867   }
868 
869   @Test
listPipelineJobsTest2()870   public void listPipelineJobsTest2() throws Exception {
871     PipelineJob responsesElement = PipelineJob.newBuilder().build();
872     ListPipelineJobsResponse expectedResponse =
873         ListPipelineJobsResponse.newBuilder()
874             .setNextPageToken("")
875             .addAllPipelineJobs(Arrays.asList(responsesElement))
876             .build();
877     mockPipelineService.addResponse(expectedResponse);
878 
879     String parent = "parent-995424086";
880 
881     ListPipelineJobsPagedResponse pagedListResponse = client.listPipelineJobs(parent);
882 
883     List<PipelineJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
884 
885     Assert.assertEquals(1, resources.size());
886     Assert.assertEquals(expectedResponse.getPipelineJobsList().get(0), resources.get(0));
887 
888     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
889     Assert.assertEquals(1, actualRequests.size());
890     ListPipelineJobsRequest actualRequest = ((ListPipelineJobsRequest) actualRequests.get(0));
891 
892     Assert.assertEquals(parent, actualRequest.getParent());
893     Assert.assertTrue(
894         channelProvider.isHeaderSent(
895             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
896             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
897   }
898 
899   @Test
listPipelineJobsExceptionTest2()900   public void listPipelineJobsExceptionTest2() throws Exception {
901     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
902     mockPipelineService.addException(exception);
903 
904     try {
905       String parent = "parent-995424086";
906       client.listPipelineJobs(parent);
907       Assert.fail("No exception raised");
908     } catch (InvalidArgumentException e) {
909       // Expected exception.
910     }
911   }
912 
913   @Test
deletePipelineJobTest()914   public void deletePipelineJobTest() throws Exception {
915     Empty expectedResponse = Empty.newBuilder().build();
916     Operation resultOperation =
917         Operation.newBuilder()
918             .setName("deletePipelineJobTest")
919             .setDone(true)
920             .setResponse(Any.pack(expectedResponse))
921             .build();
922     mockPipelineService.addResponse(resultOperation);
923 
924     PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
925 
926     client.deletePipelineJobAsync(name).get();
927 
928     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
929     Assert.assertEquals(1, actualRequests.size());
930     DeletePipelineJobRequest actualRequest = ((DeletePipelineJobRequest) actualRequests.get(0));
931 
932     Assert.assertEquals(name.toString(), actualRequest.getName());
933     Assert.assertTrue(
934         channelProvider.isHeaderSent(
935             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
936             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
937   }
938 
939   @Test
deletePipelineJobExceptionTest()940   public void deletePipelineJobExceptionTest() throws Exception {
941     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
942     mockPipelineService.addException(exception);
943 
944     try {
945       PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
946       client.deletePipelineJobAsync(name).get();
947       Assert.fail("No exception raised");
948     } catch (ExecutionException e) {
949       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
950       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
951       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
952     }
953   }
954 
955   @Test
deletePipelineJobTest2()956   public void deletePipelineJobTest2() throws Exception {
957     Empty expectedResponse = Empty.newBuilder().build();
958     Operation resultOperation =
959         Operation.newBuilder()
960             .setName("deletePipelineJobTest")
961             .setDone(true)
962             .setResponse(Any.pack(expectedResponse))
963             .build();
964     mockPipelineService.addResponse(resultOperation);
965 
966     String name = "name3373707";
967 
968     client.deletePipelineJobAsync(name).get();
969 
970     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
971     Assert.assertEquals(1, actualRequests.size());
972     DeletePipelineJobRequest actualRequest = ((DeletePipelineJobRequest) actualRequests.get(0));
973 
974     Assert.assertEquals(name, actualRequest.getName());
975     Assert.assertTrue(
976         channelProvider.isHeaderSent(
977             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
978             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
979   }
980 
981   @Test
deletePipelineJobExceptionTest2()982   public void deletePipelineJobExceptionTest2() throws Exception {
983     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
984     mockPipelineService.addException(exception);
985 
986     try {
987       String name = "name3373707";
988       client.deletePipelineJobAsync(name).get();
989       Assert.fail("No exception raised");
990     } catch (ExecutionException e) {
991       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
992       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
993       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
994     }
995   }
996 
997   @Test
cancelPipelineJobTest()998   public void cancelPipelineJobTest() throws Exception {
999     Empty expectedResponse = Empty.newBuilder().build();
1000     mockPipelineService.addResponse(expectedResponse);
1001 
1002     PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
1003 
1004     client.cancelPipelineJob(name);
1005 
1006     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
1007     Assert.assertEquals(1, actualRequests.size());
1008     CancelPipelineJobRequest actualRequest = ((CancelPipelineJobRequest) actualRequests.get(0));
1009 
1010     Assert.assertEquals(name.toString(), actualRequest.getName());
1011     Assert.assertTrue(
1012         channelProvider.isHeaderSent(
1013             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1014             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1015   }
1016 
1017   @Test
cancelPipelineJobExceptionTest()1018   public void cancelPipelineJobExceptionTest() throws Exception {
1019     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1020     mockPipelineService.addException(exception);
1021 
1022     try {
1023       PipelineJobName name = PipelineJobName.of("[PROJECT]", "[LOCATION]", "[PIPELINE_JOB]");
1024       client.cancelPipelineJob(name);
1025       Assert.fail("No exception raised");
1026     } catch (InvalidArgumentException e) {
1027       // Expected exception.
1028     }
1029   }
1030 
1031   @Test
cancelPipelineJobTest2()1032   public void cancelPipelineJobTest2() throws Exception {
1033     Empty expectedResponse = Empty.newBuilder().build();
1034     mockPipelineService.addResponse(expectedResponse);
1035 
1036     String name = "name3373707";
1037 
1038     client.cancelPipelineJob(name);
1039 
1040     List<AbstractMessage> actualRequests = mockPipelineService.getRequests();
1041     Assert.assertEquals(1, actualRequests.size());
1042     CancelPipelineJobRequest actualRequest = ((CancelPipelineJobRequest) actualRequests.get(0));
1043 
1044     Assert.assertEquals(name, actualRequest.getName());
1045     Assert.assertTrue(
1046         channelProvider.isHeaderSent(
1047             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1048             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1049   }
1050 
1051   @Test
cancelPipelineJobExceptionTest2()1052   public void cancelPipelineJobExceptionTest2() throws Exception {
1053     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1054     mockPipelineService.addException(exception);
1055 
1056     try {
1057       String name = "name3373707";
1058       client.cancelPipelineJob(name);
1059       Assert.fail("No exception raised");
1060     } catch (InvalidArgumentException e) {
1061       // Expected exception.
1062     }
1063   }
1064 
1065   @Test
listLocationsTest()1066   public void listLocationsTest() throws Exception {
1067     Location responsesElement = Location.newBuilder().build();
1068     ListLocationsResponse expectedResponse =
1069         ListLocationsResponse.newBuilder()
1070             .setNextPageToken("")
1071             .addAllLocations(Arrays.asList(responsesElement))
1072             .build();
1073     mockLocations.addResponse(expectedResponse);
1074 
1075     ListLocationsRequest request =
1076         ListLocationsRequest.newBuilder()
1077             .setName("name3373707")
1078             .setFilter("filter-1274492040")
1079             .setPageSize(883849137)
1080             .setPageToken("pageToken873572522")
1081             .build();
1082 
1083     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1084 
1085     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1086 
1087     Assert.assertEquals(1, resources.size());
1088     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1089 
1090     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1091     Assert.assertEquals(1, actualRequests.size());
1092     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1093 
1094     Assert.assertEquals(request.getName(), actualRequest.getName());
1095     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1096     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1097     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1098     Assert.assertTrue(
1099         channelProvider.isHeaderSent(
1100             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1101             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1102   }
1103 
1104   @Test
listLocationsExceptionTest()1105   public void listLocationsExceptionTest() throws Exception {
1106     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1107     mockLocations.addException(exception);
1108 
1109     try {
1110       ListLocationsRequest request =
1111           ListLocationsRequest.newBuilder()
1112               .setName("name3373707")
1113               .setFilter("filter-1274492040")
1114               .setPageSize(883849137)
1115               .setPageToken("pageToken873572522")
1116               .build();
1117       client.listLocations(request);
1118       Assert.fail("No exception raised");
1119     } catch (InvalidArgumentException e) {
1120       // Expected exception.
1121     }
1122   }
1123 
1124   @Test
getLocationTest()1125   public void getLocationTest() throws Exception {
1126     Location expectedResponse =
1127         Location.newBuilder()
1128             .setName("name3373707")
1129             .setLocationId("locationId1541836720")
1130             .setDisplayName("displayName1714148973")
1131             .putAllLabels(new HashMap<String, String>())
1132             .setMetadata(Any.newBuilder().build())
1133             .build();
1134     mockLocations.addResponse(expectedResponse);
1135 
1136     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1137 
1138     Location actualResponse = client.getLocation(request);
1139     Assert.assertEquals(expectedResponse, actualResponse);
1140 
1141     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1142     Assert.assertEquals(1, actualRequests.size());
1143     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1144 
1145     Assert.assertEquals(request.getName(), actualRequest.getName());
1146     Assert.assertTrue(
1147         channelProvider.isHeaderSent(
1148             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1149             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1150   }
1151 
1152   @Test
getLocationExceptionTest()1153   public void getLocationExceptionTest() throws Exception {
1154     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1155     mockLocations.addException(exception);
1156 
1157     try {
1158       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1159       client.getLocation(request);
1160       Assert.fail("No exception raised");
1161     } catch (InvalidArgumentException e) {
1162       // Expected exception.
1163     }
1164   }
1165 
1166   @Test
setIamPolicyTest()1167   public void setIamPolicyTest() throws Exception {
1168     Policy expectedResponse =
1169         Policy.newBuilder()
1170             .setVersion(351608024)
1171             .addAllBindings(new ArrayList<Binding>())
1172             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1173             .setEtag(ByteString.EMPTY)
1174             .build();
1175     mockIAMPolicy.addResponse(expectedResponse);
1176 
1177     SetIamPolicyRequest request =
1178         SetIamPolicyRequest.newBuilder()
1179             .setResource(
1180                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1181                     .toString())
1182             .setPolicy(Policy.newBuilder().build())
1183             .setUpdateMask(FieldMask.newBuilder().build())
1184             .build();
1185 
1186     Policy actualResponse = client.setIamPolicy(request);
1187     Assert.assertEquals(expectedResponse, actualResponse);
1188 
1189     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1190     Assert.assertEquals(1, actualRequests.size());
1191     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1192 
1193     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1194     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1195     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1196     Assert.assertTrue(
1197         channelProvider.isHeaderSent(
1198             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1199             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1200   }
1201 
1202   @Test
setIamPolicyExceptionTest()1203   public void setIamPolicyExceptionTest() throws Exception {
1204     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1205     mockIAMPolicy.addException(exception);
1206 
1207     try {
1208       SetIamPolicyRequest request =
1209           SetIamPolicyRequest.newBuilder()
1210               .setResource(
1211                   EndpointName.ofProjectLocationEndpointName(
1212                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1213                       .toString())
1214               .setPolicy(Policy.newBuilder().build())
1215               .setUpdateMask(FieldMask.newBuilder().build())
1216               .build();
1217       client.setIamPolicy(request);
1218       Assert.fail("No exception raised");
1219     } catch (InvalidArgumentException e) {
1220       // Expected exception.
1221     }
1222   }
1223 
1224   @Test
getIamPolicyTest()1225   public void getIamPolicyTest() throws Exception {
1226     Policy expectedResponse =
1227         Policy.newBuilder()
1228             .setVersion(351608024)
1229             .addAllBindings(new ArrayList<Binding>())
1230             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1231             .setEtag(ByteString.EMPTY)
1232             .build();
1233     mockIAMPolicy.addResponse(expectedResponse);
1234 
1235     GetIamPolicyRequest request =
1236         GetIamPolicyRequest.newBuilder()
1237             .setResource(
1238                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1239                     .toString())
1240             .setOptions(GetPolicyOptions.newBuilder().build())
1241             .build();
1242 
1243     Policy actualResponse = client.getIamPolicy(request);
1244     Assert.assertEquals(expectedResponse, actualResponse);
1245 
1246     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1247     Assert.assertEquals(1, actualRequests.size());
1248     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1249 
1250     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1251     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
1252     Assert.assertTrue(
1253         channelProvider.isHeaderSent(
1254             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1255             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1256   }
1257 
1258   @Test
getIamPolicyExceptionTest()1259   public void getIamPolicyExceptionTest() throws Exception {
1260     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1261     mockIAMPolicy.addException(exception);
1262 
1263     try {
1264       GetIamPolicyRequest request =
1265           GetIamPolicyRequest.newBuilder()
1266               .setResource(
1267                   EndpointName.ofProjectLocationEndpointName(
1268                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1269                       .toString())
1270               .setOptions(GetPolicyOptions.newBuilder().build())
1271               .build();
1272       client.getIamPolicy(request);
1273       Assert.fail("No exception raised");
1274     } catch (InvalidArgumentException e) {
1275       // Expected exception.
1276     }
1277   }
1278 
1279   @Test
testIamPermissionsTest()1280   public void testIamPermissionsTest() throws Exception {
1281     TestIamPermissionsResponse expectedResponse =
1282         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1283     mockIAMPolicy.addResponse(expectedResponse);
1284 
1285     TestIamPermissionsRequest request =
1286         TestIamPermissionsRequest.newBuilder()
1287             .setResource(
1288                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1289                     .toString())
1290             .addAllPermissions(new ArrayList<String>())
1291             .build();
1292 
1293     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1294     Assert.assertEquals(expectedResponse, actualResponse);
1295 
1296     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1297     Assert.assertEquals(1, actualRequests.size());
1298     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1299 
1300     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1301     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
1302     Assert.assertTrue(
1303         channelProvider.isHeaderSent(
1304             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1305             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1306   }
1307 
1308   @Test
testIamPermissionsExceptionTest()1309   public void testIamPermissionsExceptionTest() throws Exception {
1310     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1311     mockIAMPolicy.addException(exception);
1312 
1313     try {
1314       TestIamPermissionsRequest request =
1315           TestIamPermissionsRequest.newBuilder()
1316               .setResource(
1317                   EndpointName.ofProjectLocationEndpointName(
1318                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1319                       .toString())
1320               .addAllPermissions(new ArrayList<String>())
1321               .build();
1322       client.testIamPermissions(request);
1323       Assert.fail("No exception raised");
1324     } catch (InvalidArgumentException e) {
1325       // Expected exception.
1326     }
1327   }
1328 }
1329