• 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.tasks.v2;
18 
19 import static com.google.cloud.tasks.v2.CloudTasksClient.ListQueuesPagedResponse;
20 import static com.google.cloud.tasks.v2.CloudTasksClient.ListTasksPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.resourcenames.ResourceName;
30 import com.google.common.collect.Lists;
31 import com.google.iam.v1.AuditConfig;
32 import com.google.iam.v1.Binding;
33 import com.google.iam.v1.GetIamPolicyRequest;
34 import com.google.iam.v1.Policy;
35 import com.google.iam.v1.SetIamPolicyRequest;
36 import com.google.iam.v1.TestIamPermissionsRequest;
37 import com.google.iam.v1.TestIamPermissionsResponse;
38 import com.google.protobuf.AbstractMessage;
39 import com.google.protobuf.ByteString;
40 import com.google.protobuf.Duration;
41 import com.google.protobuf.Empty;
42 import com.google.protobuf.FieldMask;
43 import com.google.protobuf.Timestamp;
44 import io.grpc.StatusRuntimeException;
45 import java.io.IOException;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.List;
49 import java.util.UUID;
50 import javax.annotation.Generated;
51 import org.junit.After;
52 import org.junit.AfterClass;
53 import org.junit.Assert;
54 import org.junit.Before;
55 import org.junit.BeforeClass;
56 import org.junit.Test;
57 
58 @Generated("by gapic-generator-java")
59 public class CloudTasksClientTest {
60   private static MockCloudTasks mockCloudTasks;
61   private static MockServiceHelper mockServiceHelper;
62   private LocalChannelProvider channelProvider;
63   private CloudTasksClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() {
67     mockCloudTasks = new MockCloudTasks();
68     mockServiceHelper =
69         new MockServiceHelper(
70             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockCloudTasks));
71     mockServiceHelper.start();
72   }
73 
74   @AfterClass
stopServer()75   public static void stopServer() {
76     mockServiceHelper.stop();
77   }
78 
79   @Before
setUp()80   public void setUp() throws IOException {
81     mockServiceHelper.reset();
82     channelProvider = mockServiceHelper.createChannelProvider();
83     CloudTasksSettings settings =
84         CloudTasksSettings.newBuilder()
85             .setTransportChannelProvider(channelProvider)
86             .setCredentialsProvider(NoCredentialsProvider.create())
87             .build();
88     client = CloudTasksClient.create(settings);
89   }
90 
91   @After
tearDown()92   public void tearDown() throws Exception {
93     client.close();
94   }
95 
96   @Test
listQueuesTest()97   public void listQueuesTest() throws Exception {
98     Queue responsesElement = Queue.newBuilder().build();
99     ListQueuesResponse expectedResponse =
100         ListQueuesResponse.newBuilder()
101             .setNextPageToken("")
102             .addAllQueues(Arrays.asList(responsesElement))
103             .build();
104     mockCloudTasks.addResponse(expectedResponse);
105 
106     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
107 
108     ListQueuesPagedResponse pagedListResponse = client.listQueues(parent);
109 
110     List<Queue> resources = Lists.newArrayList(pagedListResponse.iterateAll());
111 
112     Assert.assertEquals(1, resources.size());
113     Assert.assertEquals(expectedResponse.getQueuesList().get(0), resources.get(0));
114 
115     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
116     Assert.assertEquals(1, actualRequests.size());
117     ListQueuesRequest actualRequest = ((ListQueuesRequest) actualRequests.get(0));
118 
119     Assert.assertEquals(parent.toString(), actualRequest.getParent());
120     Assert.assertTrue(
121         channelProvider.isHeaderSent(
122             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
123             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
124   }
125 
126   @Test
listQueuesExceptionTest()127   public void listQueuesExceptionTest() throws Exception {
128     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
129     mockCloudTasks.addException(exception);
130 
131     try {
132       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
133       client.listQueues(parent);
134       Assert.fail("No exception raised");
135     } catch (InvalidArgumentException e) {
136       // Expected exception.
137     }
138   }
139 
140   @Test
listQueuesTest2()141   public void listQueuesTest2() throws Exception {
142     Queue responsesElement = Queue.newBuilder().build();
143     ListQueuesResponse expectedResponse =
144         ListQueuesResponse.newBuilder()
145             .setNextPageToken("")
146             .addAllQueues(Arrays.asList(responsesElement))
147             .build();
148     mockCloudTasks.addResponse(expectedResponse);
149 
150     String parent = "parent-995424086";
151 
152     ListQueuesPagedResponse pagedListResponse = client.listQueues(parent);
153 
154     List<Queue> resources = Lists.newArrayList(pagedListResponse.iterateAll());
155 
156     Assert.assertEquals(1, resources.size());
157     Assert.assertEquals(expectedResponse.getQueuesList().get(0), resources.get(0));
158 
159     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
160     Assert.assertEquals(1, actualRequests.size());
161     ListQueuesRequest actualRequest = ((ListQueuesRequest) actualRequests.get(0));
162 
163     Assert.assertEquals(parent, actualRequest.getParent());
164     Assert.assertTrue(
165         channelProvider.isHeaderSent(
166             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
167             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
168   }
169 
170   @Test
listQueuesExceptionTest2()171   public void listQueuesExceptionTest2() throws Exception {
172     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
173     mockCloudTasks.addException(exception);
174 
175     try {
176       String parent = "parent-995424086";
177       client.listQueues(parent);
178       Assert.fail("No exception raised");
179     } catch (InvalidArgumentException e) {
180       // Expected exception.
181     }
182   }
183 
184   @Test
getQueueTest()185   public void getQueueTest() throws Exception {
186     Queue expectedResponse =
187         Queue.newBuilder()
188             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
189             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
190             .setRateLimits(RateLimits.newBuilder().build())
191             .setRetryConfig(RetryConfig.newBuilder().build())
192             .setPurgeTime(Timestamp.newBuilder().build())
193             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
194             .build();
195     mockCloudTasks.addResponse(expectedResponse);
196 
197     QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
198 
199     Queue actualResponse = client.getQueue(name);
200     Assert.assertEquals(expectedResponse, actualResponse);
201 
202     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
203     Assert.assertEquals(1, actualRequests.size());
204     GetQueueRequest actualRequest = ((GetQueueRequest) actualRequests.get(0));
205 
206     Assert.assertEquals(name.toString(), actualRequest.getName());
207     Assert.assertTrue(
208         channelProvider.isHeaderSent(
209             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
210             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
211   }
212 
213   @Test
getQueueExceptionTest()214   public void getQueueExceptionTest() throws Exception {
215     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
216     mockCloudTasks.addException(exception);
217 
218     try {
219       QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
220       client.getQueue(name);
221       Assert.fail("No exception raised");
222     } catch (InvalidArgumentException e) {
223       // Expected exception.
224     }
225   }
226 
227   @Test
getQueueTest2()228   public void getQueueTest2() throws Exception {
229     Queue expectedResponse =
230         Queue.newBuilder()
231             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
232             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
233             .setRateLimits(RateLimits.newBuilder().build())
234             .setRetryConfig(RetryConfig.newBuilder().build())
235             .setPurgeTime(Timestamp.newBuilder().build())
236             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
237             .build();
238     mockCloudTasks.addResponse(expectedResponse);
239 
240     String name = "name3373707";
241 
242     Queue actualResponse = client.getQueue(name);
243     Assert.assertEquals(expectedResponse, actualResponse);
244 
245     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
246     Assert.assertEquals(1, actualRequests.size());
247     GetQueueRequest actualRequest = ((GetQueueRequest) actualRequests.get(0));
248 
249     Assert.assertEquals(name, actualRequest.getName());
250     Assert.assertTrue(
251         channelProvider.isHeaderSent(
252             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
253             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
254   }
255 
256   @Test
getQueueExceptionTest2()257   public void getQueueExceptionTest2() throws Exception {
258     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
259     mockCloudTasks.addException(exception);
260 
261     try {
262       String name = "name3373707";
263       client.getQueue(name);
264       Assert.fail("No exception raised");
265     } catch (InvalidArgumentException e) {
266       // Expected exception.
267     }
268   }
269 
270   @Test
createQueueTest()271   public void createQueueTest() throws Exception {
272     Queue expectedResponse =
273         Queue.newBuilder()
274             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
275             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
276             .setRateLimits(RateLimits.newBuilder().build())
277             .setRetryConfig(RetryConfig.newBuilder().build())
278             .setPurgeTime(Timestamp.newBuilder().build())
279             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
280             .build();
281     mockCloudTasks.addResponse(expectedResponse);
282 
283     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
284     Queue queue = Queue.newBuilder().build();
285 
286     Queue actualResponse = client.createQueue(parent, queue);
287     Assert.assertEquals(expectedResponse, actualResponse);
288 
289     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
290     Assert.assertEquals(1, actualRequests.size());
291     CreateQueueRequest actualRequest = ((CreateQueueRequest) actualRequests.get(0));
292 
293     Assert.assertEquals(parent.toString(), actualRequest.getParent());
294     Assert.assertEquals(queue, actualRequest.getQueue());
295     Assert.assertTrue(
296         channelProvider.isHeaderSent(
297             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
298             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
299   }
300 
301   @Test
createQueueExceptionTest()302   public void createQueueExceptionTest() throws Exception {
303     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
304     mockCloudTasks.addException(exception);
305 
306     try {
307       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
308       Queue queue = Queue.newBuilder().build();
309       client.createQueue(parent, queue);
310       Assert.fail("No exception raised");
311     } catch (InvalidArgumentException e) {
312       // Expected exception.
313     }
314   }
315 
316   @Test
createQueueTest2()317   public void createQueueTest2() throws Exception {
318     Queue expectedResponse =
319         Queue.newBuilder()
320             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
321             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
322             .setRateLimits(RateLimits.newBuilder().build())
323             .setRetryConfig(RetryConfig.newBuilder().build())
324             .setPurgeTime(Timestamp.newBuilder().build())
325             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
326             .build();
327     mockCloudTasks.addResponse(expectedResponse);
328 
329     String parent = "parent-995424086";
330     Queue queue = Queue.newBuilder().build();
331 
332     Queue actualResponse = client.createQueue(parent, queue);
333     Assert.assertEquals(expectedResponse, actualResponse);
334 
335     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
336     Assert.assertEquals(1, actualRequests.size());
337     CreateQueueRequest actualRequest = ((CreateQueueRequest) actualRequests.get(0));
338 
339     Assert.assertEquals(parent, actualRequest.getParent());
340     Assert.assertEquals(queue, actualRequest.getQueue());
341     Assert.assertTrue(
342         channelProvider.isHeaderSent(
343             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
344             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
345   }
346 
347   @Test
createQueueExceptionTest2()348   public void createQueueExceptionTest2() throws Exception {
349     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
350     mockCloudTasks.addException(exception);
351 
352     try {
353       String parent = "parent-995424086";
354       Queue queue = Queue.newBuilder().build();
355       client.createQueue(parent, queue);
356       Assert.fail("No exception raised");
357     } catch (InvalidArgumentException e) {
358       // Expected exception.
359     }
360   }
361 
362   @Test
updateQueueTest()363   public void updateQueueTest() throws Exception {
364     Queue expectedResponse =
365         Queue.newBuilder()
366             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
367             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
368             .setRateLimits(RateLimits.newBuilder().build())
369             .setRetryConfig(RetryConfig.newBuilder().build())
370             .setPurgeTime(Timestamp.newBuilder().build())
371             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
372             .build();
373     mockCloudTasks.addResponse(expectedResponse);
374 
375     Queue queue = Queue.newBuilder().build();
376     FieldMask updateMask = FieldMask.newBuilder().build();
377 
378     Queue actualResponse = client.updateQueue(queue, updateMask);
379     Assert.assertEquals(expectedResponse, actualResponse);
380 
381     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
382     Assert.assertEquals(1, actualRequests.size());
383     UpdateQueueRequest actualRequest = ((UpdateQueueRequest) actualRequests.get(0));
384 
385     Assert.assertEquals(queue, actualRequest.getQueue());
386     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
387     Assert.assertTrue(
388         channelProvider.isHeaderSent(
389             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
390             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
391   }
392 
393   @Test
updateQueueExceptionTest()394   public void updateQueueExceptionTest() throws Exception {
395     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
396     mockCloudTasks.addException(exception);
397 
398     try {
399       Queue queue = Queue.newBuilder().build();
400       FieldMask updateMask = FieldMask.newBuilder().build();
401       client.updateQueue(queue, updateMask);
402       Assert.fail("No exception raised");
403     } catch (InvalidArgumentException e) {
404       // Expected exception.
405     }
406   }
407 
408   @Test
deleteQueueTest()409   public void deleteQueueTest() throws Exception {
410     Empty expectedResponse = Empty.newBuilder().build();
411     mockCloudTasks.addResponse(expectedResponse);
412 
413     QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
414 
415     client.deleteQueue(name);
416 
417     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
418     Assert.assertEquals(1, actualRequests.size());
419     DeleteQueueRequest actualRequest = ((DeleteQueueRequest) actualRequests.get(0));
420 
421     Assert.assertEquals(name.toString(), actualRequest.getName());
422     Assert.assertTrue(
423         channelProvider.isHeaderSent(
424             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
425             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
426   }
427 
428   @Test
deleteQueueExceptionTest()429   public void deleteQueueExceptionTest() throws Exception {
430     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
431     mockCloudTasks.addException(exception);
432 
433     try {
434       QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
435       client.deleteQueue(name);
436       Assert.fail("No exception raised");
437     } catch (InvalidArgumentException e) {
438       // Expected exception.
439     }
440   }
441 
442   @Test
deleteQueueTest2()443   public void deleteQueueTest2() throws Exception {
444     Empty expectedResponse = Empty.newBuilder().build();
445     mockCloudTasks.addResponse(expectedResponse);
446 
447     String name = "name3373707";
448 
449     client.deleteQueue(name);
450 
451     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
452     Assert.assertEquals(1, actualRequests.size());
453     DeleteQueueRequest actualRequest = ((DeleteQueueRequest) actualRequests.get(0));
454 
455     Assert.assertEquals(name, actualRequest.getName());
456     Assert.assertTrue(
457         channelProvider.isHeaderSent(
458             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
459             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
460   }
461 
462   @Test
deleteQueueExceptionTest2()463   public void deleteQueueExceptionTest2() throws Exception {
464     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
465     mockCloudTasks.addException(exception);
466 
467     try {
468       String name = "name3373707";
469       client.deleteQueue(name);
470       Assert.fail("No exception raised");
471     } catch (InvalidArgumentException e) {
472       // Expected exception.
473     }
474   }
475 
476   @Test
purgeQueueTest()477   public void purgeQueueTest() throws Exception {
478     Queue expectedResponse =
479         Queue.newBuilder()
480             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
481             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
482             .setRateLimits(RateLimits.newBuilder().build())
483             .setRetryConfig(RetryConfig.newBuilder().build())
484             .setPurgeTime(Timestamp.newBuilder().build())
485             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
486             .build();
487     mockCloudTasks.addResponse(expectedResponse);
488 
489     QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
490 
491     Queue actualResponse = client.purgeQueue(name);
492     Assert.assertEquals(expectedResponse, actualResponse);
493 
494     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
495     Assert.assertEquals(1, actualRequests.size());
496     PurgeQueueRequest actualRequest = ((PurgeQueueRequest) actualRequests.get(0));
497 
498     Assert.assertEquals(name.toString(), actualRequest.getName());
499     Assert.assertTrue(
500         channelProvider.isHeaderSent(
501             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
502             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
503   }
504 
505   @Test
purgeQueueExceptionTest()506   public void purgeQueueExceptionTest() throws Exception {
507     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
508     mockCloudTasks.addException(exception);
509 
510     try {
511       QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
512       client.purgeQueue(name);
513       Assert.fail("No exception raised");
514     } catch (InvalidArgumentException e) {
515       // Expected exception.
516     }
517   }
518 
519   @Test
purgeQueueTest2()520   public void purgeQueueTest2() throws Exception {
521     Queue expectedResponse =
522         Queue.newBuilder()
523             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
524             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
525             .setRateLimits(RateLimits.newBuilder().build())
526             .setRetryConfig(RetryConfig.newBuilder().build())
527             .setPurgeTime(Timestamp.newBuilder().build())
528             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
529             .build();
530     mockCloudTasks.addResponse(expectedResponse);
531 
532     String name = "name3373707";
533 
534     Queue actualResponse = client.purgeQueue(name);
535     Assert.assertEquals(expectedResponse, actualResponse);
536 
537     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
538     Assert.assertEquals(1, actualRequests.size());
539     PurgeQueueRequest actualRequest = ((PurgeQueueRequest) actualRequests.get(0));
540 
541     Assert.assertEquals(name, actualRequest.getName());
542     Assert.assertTrue(
543         channelProvider.isHeaderSent(
544             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
545             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
546   }
547 
548   @Test
purgeQueueExceptionTest2()549   public void purgeQueueExceptionTest2() throws Exception {
550     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
551     mockCloudTasks.addException(exception);
552 
553     try {
554       String name = "name3373707";
555       client.purgeQueue(name);
556       Assert.fail("No exception raised");
557     } catch (InvalidArgumentException e) {
558       // Expected exception.
559     }
560   }
561 
562   @Test
pauseQueueTest()563   public void pauseQueueTest() throws Exception {
564     Queue expectedResponse =
565         Queue.newBuilder()
566             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
567             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
568             .setRateLimits(RateLimits.newBuilder().build())
569             .setRetryConfig(RetryConfig.newBuilder().build())
570             .setPurgeTime(Timestamp.newBuilder().build())
571             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
572             .build();
573     mockCloudTasks.addResponse(expectedResponse);
574 
575     QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
576 
577     Queue actualResponse = client.pauseQueue(name);
578     Assert.assertEquals(expectedResponse, actualResponse);
579 
580     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
581     Assert.assertEquals(1, actualRequests.size());
582     PauseQueueRequest actualRequest = ((PauseQueueRequest) actualRequests.get(0));
583 
584     Assert.assertEquals(name.toString(), actualRequest.getName());
585     Assert.assertTrue(
586         channelProvider.isHeaderSent(
587             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
588             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
589   }
590 
591   @Test
pauseQueueExceptionTest()592   public void pauseQueueExceptionTest() throws Exception {
593     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
594     mockCloudTasks.addException(exception);
595 
596     try {
597       QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
598       client.pauseQueue(name);
599       Assert.fail("No exception raised");
600     } catch (InvalidArgumentException e) {
601       // Expected exception.
602     }
603   }
604 
605   @Test
pauseQueueTest2()606   public void pauseQueueTest2() throws Exception {
607     Queue expectedResponse =
608         Queue.newBuilder()
609             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
610             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
611             .setRateLimits(RateLimits.newBuilder().build())
612             .setRetryConfig(RetryConfig.newBuilder().build())
613             .setPurgeTime(Timestamp.newBuilder().build())
614             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
615             .build();
616     mockCloudTasks.addResponse(expectedResponse);
617 
618     String name = "name3373707";
619 
620     Queue actualResponse = client.pauseQueue(name);
621     Assert.assertEquals(expectedResponse, actualResponse);
622 
623     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
624     Assert.assertEquals(1, actualRequests.size());
625     PauseQueueRequest actualRequest = ((PauseQueueRequest) actualRequests.get(0));
626 
627     Assert.assertEquals(name, actualRequest.getName());
628     Assert.assertTrue(
629         channelProvider.isHeaderSent(
630             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
631             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
632   }
633 
634   @Test
pauseQueueExceptionTest2()635   public void pauseQueueExceptionTest2() throws Exception {
636     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
637     mockCloudTasks.addException(exception);
638 
639     try {
640       String name = "name3373707";
641       client.pauseQueue(name);
642       Assert.fail("No exception raised");
643     } catch (InvalidArgumentException e) {
644       // Expected exception.
645     }
646   }
647 
648   @Test
resumeQueueTest()649   public void resumeQueueTest() throws Exception {
650     Queue expectedResponse =
651         Queue.newBuilder()
652             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
653             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
654             .setRateLimits(RateLimits.newBuilder().build())
655             .setRetryConfig(RetryConfig.newBuilder().build())
656             .setPurgeTime(Timestamp.newBuilder().build())
657             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
658             .build();
659     mockCloudTasks.addResponse(expectedResponse);
660 
661     QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
662 
663     Queue actualResponse = client.resumeQueue(name);
664     Assert.assertEquals(expectedResponse, actualResponse);
665 
666     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
667     Assert.assertEquals(1, actualRequests.size());
668     ResumeQueueRequest actualRequest = ((ResumeQueueRequest) actualRequests.get(0));
669 
670     Assert.assertEquals(name.toString(), actualRequest.getName());
671     Assert.assertTrue(
672         channelProvider.isHeaderSent(
673             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
674             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
675   }
676 
677   @Test
resumeQueueExceptionTest()678   public void resumeQueueExceptionTest() throws Exception {
679     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
680     mockCloudTasks.addException(exception);
681 
682     try {
683       QueueName name = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
684       client.resumeQueue(name);
685       Assert.fail("No exception raised");
686     } catch (InvalidArgumentException e) {
687       // Expected exception.
688     }
689   }
690 
691   @Test
resumeQueueTest2()692   public void resumeQueueTest2() throws Exception {
693     Queue expectedResponse =
694         Queue.newBuilder()
695             .setName(QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]").toString())
696             .setAppEngineRoutingOverride(AppEngineRouting.newBuilder().build())
697             .setRateLimits(RateLimits.newBuilder().build())
698             .setRetryConfig(RetryConfig.newBuilder().build())
699             .setPurgeTime(Timestamp.newBuilder().build())
700             .setStackdriverLoggingConfig(StackdriverLoggingConfig.newBuilder().build())
701             .build();
702     mockCloudTasks.addResponse(expectedResponse);
703 
704     String name = "name3373707";
705 
706     Queue actualResponse = client.resumeQueue(name);
707     Assert.assertEquals(expectedResponse, actualResponse);
708 
709     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
710     Assert.assertEquals(1, actualRequests.size());
711     ResumeQueueRequest actualRequest = ((ResumeQueueRequest) actualRequests.get(0));
712 
713     Assert.assertEquals(name, actualRequest.getName());
714     Assert.assertTrue(
715         channelProvider.isHeaderSent(
716             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
717             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
718   }
719 
720   @Test
resumeQueueExceptionTest2()721   public void resumeQueueExceptionTest2() throws Exception {
722     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
723     mockCloudTasks.addException(exception);
724 
725     try {
726       String name = "name3373707";
727       client.resumeQueue(name);
728       Assert.fail("No exception raised");
729     } catch (InvalidArgumentException e) {
730       // Expected exception.
731     }
732   }
733 
734   @Test
getIamPolicyTest()735   public void getIamPolicyTest() throws Exception {
736     Policy expectedResponse =
737         Policy.newBuilder()
738             .setVersion(351608024)
739             .addAllBindings(new ArrayList<Binding>())
740             .addAllAuditConfigs(new ArrayList<AuditConfig>())
741             .setEtag(ByteString.EMPTY)
742             .build();
743     mockCloudTasks.addResponse(expectedResponse);
744 
745     ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
746 
747     Policy actualResponse = client.getIamPolicy(resource);
748     Assert.assertEquals(expectedResponse, actualResponse);
749 
750     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
751     Assert.assertEquals(1, actualRequests.size());
752     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
753 
754     Assert.assertEquals(resource.toString(), actualRequest.getResource());
755     Assert.assertTrue(
756         channelProvider.isHeaderSent(
757             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
758             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
759   }
760 
761   @Test
getIamPolicyExceptionTest()762   public void getIamPolicyExceptionTest() throws Exception {
763     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
764     mockCloudTasks.addException(exception);
765 
766     try {
767       ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
768       client.getIamPolicy(resource);
769       Assert.fail("No exception raised");
770     } catch (InvalidArgumentException e) {
771       // Expected exception.
772     }
773   }
774 
775   @Test
getIamPolicyTest2()776   public void getIamPolicyTest2() throws Exception {
777     Policy expectedResponse =
778         Policy.newBuilder()
779             .setVersion(351608024)
780             .addAllBindings(new ArrayList<Binding>())
781             .addAllAuditConfigs(new ArrayList<AuditConfig>())
782             .setEtag(ByteString.EMPTY)
783             .build();
784     mockCloudTasks.addResponse(expectedResponse);
785 
786     String resource = "resource-341064690";
787 
788     Policy actualResponse = client.getIamPolicy(resource);
789     Assert.assertEquals(expectedResponse, actualResponse);
790 
791     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
792     Assert.assertEquals(1, actualRequests.size());
793     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
794 
795     Assert.assertEquals(resource, actualRequest.getResource());
796     Assert.assertTrue(
797         channelProvider.isHeaderSent(
798             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
799             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
800   }
801 
802   @Test
getIamPolicyExceptionTest2()803   public void getIamPolicyExceptionTest2() throws Exception {
804     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
805     mockCloudTasks.addException(exception);
806 
807     try {
808       String resource = "resource-341064690";
809       client.getIamPolicy(resource);
810       Assert.fail("No exception raised");
811     } catch (InvalidArgumentException e) {
812       // Expected exception.
813     }
814   }
815 
816   @Test
setIamPolicyTest()817   public void setIamPolicyTest() throws Exception {
818     Policy expectedResponse =
819         Policy.newBuilder()
820             .setVersion(351608024)
821             .addAllBindings(new ArrayList<Binding>())
822             .addAllAuditConfigs(new ArrayList<AuditConfig>())
823             .setEtag(ByteString.EMPTY)
824             .build();
825     mockCloudTasks.addResponse(expectedResponse);
826 
827     ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
828     Policy policy = Policy.newBuilder().build();
829 
830     Policy actualResponse = client.setIamPolicy(resource, policy);
831     Assert.assertEquals(expectedResponse, actualResponse);
832 
833     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
834     Assert.assertEquals(1, actualRequests.size());
835     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
836 
837     Assert.assertEquals(resource.toString(), actualRequest.getResource());
838     Assert.assertEquals(policy, actualRequest.getPolicy());
839     Assert.assertTrue(
840         channelProvider.isHeaderSent(
841             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
842             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
843   }
844 
845   @Test
setIamPolicyExceptionTest()846   public void setIamPolicyExceptionTest() throws Exception {
847     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
848     mockCloudTasks.addException(exception);
849 
850     try {
851       ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
852       Policy policy = Policy.newBuilder().build();
853       client.setIamPolicy(resource, policy);
854       Assert.fail("No exception raised");
855     } catch (InvalidArgumentException e) {
856       // Expected exception.
857     }
858   }
859 
860   @Test
setIamPolicyTest2()861   public void setIamPolicyTest2() throws Exception {
862     Policy expectedResponse =
863         Policy.newBuilder()
864             .setVersion(351608024)
865             .addAllBindings(new ArrayList<Binding>())
866             .addAllAuditConfigs(new ArrayList<AuditConfig>())
867             .setEtag(ByteString.EMPTY)
868             .build();
869     mockCloudTasks.addResponse(expectedResponse);
870 
871     String resource = "resource-341064690";
872     Policy policy = Policy.newBuilder().build();
873 
874     Policy actualResponse = client.setIamPolicy(resource, policy);
875     Assert.assertEquals(expectedResponse, actualResponse);
876 
877     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
878     Assert.assertEquals(1, actualRequests.size());
879     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
880 
881     Assert.assertEquals(resource, actualRequest.getResource());
882     Assert.assertEquals(policy, actualRequest.getPolicy());
883     Assert.assertTrue(
884         channelProvider.isHeaderSent(
885             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
886             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
887   }
888 
889   @Test
setIamPolicyExceptionTest2()890   public void setIamPolicyExceptionTest2() throws Exception {
891     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
892     mockCloudTasks.addException(exception);
893 
894     try {
895       String resource = "resource-341064690";
896       Policy policy = Policy.newBuilder().build();
897       client.setIamPolicy(resource, policy);
898       Assert.fail("No exception raised");
899     } catch (InvalidArgumentException e) {
900       // Expected exception.
901     }
902   }
903 
904   @Test
testIamPermissionsTest()905   public void testIamPermissionsTest() throws Exception {
906     TestIamPermissionsResponse expectedResponse =
907         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
908     mockCloudTasks.addResponse(expectedResponse);
909 
910     ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
911     List<String> permissions = new ArrayList<>();
912 
913     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
914     Assert.assertEquals(expectedResponse, actualResponse);
915 
916     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
917     Assert.assertEquals(1, actualRequests.size());
918     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
919 
920     Assert.assertEquals(resource.toString(), actualRequest.getResource());
921     Assert.assertEquals(permissions, actualRequest.getPermissionsList());
922     Assert.assertTrue(
923         channelProvider.isHeaderSent(
924             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
925             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
926   }
927 
928   @Test
testIamPermissionsExceptionTest()929   public void testIamPermissionsExceptionTest() throws Exception {
930     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
931     mockCloudTasks.addException(exception);
932 
933     try {
934       ResourceName resource = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
935       List<String> permissions = new ArrayList<>();
936       client.testIamPermissions(resource, permissions);
937       Assert.fail("No exception raised");
938     } catch (InvalidArgumentException e) {
939       // Expected exception.
940     }
941   }
942 
943   @Test
testIamPermissionsTest2()944   public void testIamPermissionsTest2() throws Exception {
945     TestIamPermissionsResponse expectedResponse =
946         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
947     mockCloudTasks.addResponse(expectedResponse);
948 
949     String resource = "resource-341064690";
950     List<String> permissions = new ArrayList<>();
951 
952     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
953     Assert.assertEquals(expectedResponse, actualResponse);
954 
955     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
956     Assert.assertEquals(1, actualRequests.size());
957     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
958 
959     Assert.assertEquals(resource, actualRequest.getResource());
960     Assert.assertEquals(permissions, actualRequest.getPermissionsList());
961     Assert.assertTrue(
962         channelProvider.isHeaderSent(
963             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
964             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
965   }
966 
967   @Test
testIamPermissionsExceptionTest2()968   public void testIamPermissionsExceptionTest2() throws Exception {
969     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
970     mockCloudTasks.addException(exception);
971 
972     try {
973       String resource = "resource-341064690";
974       List<String> permissions = new ArrayList<>();
975       client.testIamPermissions(resource, permissions);
976       Assert.fail("No exception raised");
977     } catch (InvalidArgumentException e) {
978       // Expected exception.
979     }
980   }
981 
982   @Test
listTasksTest()983   public void listTasksTest() throws Exception {
984     Task responsesElement = Task.newBuilder().build();
985     ListTasksResponse expectedResponse =
986         ListTasksResponse.newBuilder()
987             .setNextPageToken("")
988             .addAllTasks(Arrays.asList(responsesElement))
989             .build();
990     mockCloudTasks.addResponse(expectedResponse);
991 
992     QueueName parent = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
993 
994     ListTasksPagedResponse pagedListResponse = client.listTasks(parent);
995 
996     List<Task> resources = Lists.newArrayList(pagedListResponse.iterateAll());
997 
998     Assert.assertEquals(1, resources.size());
999     Assert.assertEquals(expectedResponse.getTasksList().get(0), resources.get(0));
1000 
1001     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1002     Assert.assertEquals(1, actualRequests.size());
1003     ListTasksRequest actualRequest = ((ListTasksRequest) actualRequests.get(0));
1004 
1005     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1006     Assert.assertTrue(
1007         channelProvider.isHeaderSent(
1008             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1009             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1010   }
1011 
1012   @Test
listTasksExceptionTest()1013   public void listTasksExceptionTest() throws Exception {
1014     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1015     mockCloudTasks.addException(exception);
1016 
1017     try {
1018       QueueName parent = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
1019       client.listTasks(parent);
1020       Assert.fail("No exception raised");
1021     } catch (InvalidArgumentException e) {
1022       // Expected exception.
1023     }
1024   }
1025 
1026   @Test
listTasksTest2()1027   public void listTasksTest2() throws Exception {
1028     Task responsesElement = Task.newBuilder().build();
1029     ListTasksResponse expectedResponse =
1030         ListTasksResponse.newBuilder()
1031             .setNextPageToken("")
1032             .addAllTasks(Arrays.asList(responsesElement))
1033             .build();
1034     mockCloudTasks.addResponse(expectedResponse);
1035 
1036     String parent = "parent-995424086";
1037 
1038     ListTasksPagedResponse pagedListResponse = client.listTasks(parent);
1039 
1040     List<Task> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1041 
1042     Assert.assertEquals(1, resources.size());
1043     Assert.assertEquals(expectedResponse.getTasksList().get(0), resources.get(0));
1044 
1045     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1046     Assert.assertEquals(1, actualRequests.size());
1047     ListTasksRequest actualRequest = ((ListTasksRequest) actualRequests.get(0));
1048 
1049     Assert.assertEquals(parent, actualRequest.getParent());
1050     Assert.assertTrue(
1051         channelProvider.isHeaderSent(
1052             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1053             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1054   }
1055 
1056   @Test
listTasksExceptionTest2()1057   public void listTasksExceptionTest2() throws Exception {
1058     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1059     mockCloudTasks.addException(exception);
1060 
1061     try {
1062       String parent = "parent-995424086";
1063       client.listTasks(parent);
1064       Assert.fail("No exception raised");
1065     } catch (InvalidArgumentException e) {
1066       // Expected exception.
1067     }
1068   }
1069 
1070   @Test
getTaskTest()1071   public void getTaskTest() throws Exception {
1072     Task expectedResponse =
1073         Task.newBuilder()
1074             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1075             .setScheduleTime(Timestamp.newBuilder().build())
1076             .setCreateTime(Timestamp.newBuilder().build())
1077             .setDispatchDeadline(Duration.newBuilder().build())
1078             .setDispatchCount(-1217252086)
1079             .setResponseCount(424727441)
1080             .setFirstAttempt(Attempt.newBuilder().build())
1081             .setLastAttempt(Attempt.newBuilder().build())
1082             .build();
1083     mockCloudTasks.addResponse(expectedResponse);
1084 
1085     TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1086 
1087     Task actualResponse = client.getTask(name);
1088     Assert.assertEquals(expectedResponse, actualResponse);
1089 
1090     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1091     Assert.assertEquals(1, actualRequests.size());
1092     GetTaskRequest actualRequest = ((GetTaskRequest) actualRequests.get(0));
1093 
1094     Assert.assertEquals(name.toString(), actualRequest.getName());
1095     Assert.assertTrue(
1096         channelProvider.isHeaderSent(
1097             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1098             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1099   }
1100 
1101   @Test
getTaskExceptionTest()1102   public void getTaskExceptionTest() throws Exception {
1103     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1104     mockCloudTasks.addException(exception);
1105 
1106     try {
1107       TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1108       client.getTask(name);
1109       Assert.fail("No exception raised");
1110     } catch (InvalidArgumentException e) {
1111       // Expected exception.
1112     }
1113   }
1114 
1115   @Test
getTaskTest2()1116   public void getTaskTest2() throws Exception {
1117     Task expectedResponse =
1118         Task.newBuilder()
1119             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1120             .setScheduleTime(Timestamp.newBuilder().build())
1121             .setCreateTime(Timestamp.newBuilder().build())
1122             .setDispatchDeadline(Duration.newBuilder().build())
1123             .setDispatchCount(-1217252086)
1124             .setResponseCount(424727441)
1125             .setFirstAttempt(Attempt.newBuilder().build())
1126             .setLastAttempt(Attempt.newBuilder().build())
1127             .build();
1128     mockCloudTasks.addResponse(expectedResponse);
1129 
1130     String name = "name3373707";
1131 
1132     Task actualResponse = client.getTask(name);
1133     Assert.assertEquals(expectedResponse, actualResponse);
1134 
1135     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1136     Assert.assertEquals(1, actualRequests.size());
1137     GetTaskRequest actualRequest = ((GetTaskRequest) actualRequests.get(0));
1138 
1139     Assert.assertEquals(name, actualRequest.getName());
1140     Assert.assertTrue(
1141         channelProvider.isHeaderSent(
1142             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1143             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1144   }
1145 
1146   @Test
getTaskExceptionTest2()1147   public void getTaskExceptionTest2() throws Exception {
1148     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1149     mockCloudTasks.addException(exception);
1150 
1151     try {
1152       String name = "name3373707";
1153       client.getTask(name);
1154       Assert.fail("No exception raised");
1155     } catch (InvalidArgumentException e) {
1156       // Expected exception.
1157     }
1158   }
1159 
1160   @Test
createTaskTest()1161   public void createTaskTest() throws Exception {
1162     Task expectedResponse =
1163         Task.newBuilder()
1164             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1165             .setScheduleTime(Timestamp.newBuilder().build())
1166             .setCreateTime(Timestamp.newBuilder().build())
1167             .setDispatchDeadline(Duration.newBuilder().build())
1168             .setDispatchCount(-1217252086)
1169             .setResponseCount(424727441)
1170             .setFirstAttempt(Attempt.newBuilder().build())
1171             .setLastAttempt(Attempt.newBuilder().build())
1172             .build();
1173     mockCloudTasks.addResponse(expectedResponse);
1174 
1175     QueueName parent = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
1176     Task task = Task.newBuilder().build();
1177 
1178     Task actualResponse = client.createTask(parent, task);
1179     Assert.assertEquals(expectedResponse, actualResponse);
1180 
1181     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1182     Assert.assertEquals(1, actualRequests.size());
1183     CreateTaskRequest actualRequest = ((CreateTaskRequest) actualRequests.get(0));
1184 
1185     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1186     Assert.assertEquals(task, actualRequest.getTask());
1187     Assert.assertTrue(
1188         channelProvider.isHeaderSent(
1189             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1190             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1191   }
1192 
1193   @Test
createTaskExceptionTest()1194   public void createTaskExceptionTest() throws Exception {
1195     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1196     mockCloudTasks.addException(exception);
1197 
1198     try {
1199       QueueName parent = QueueName.of("[PROJECT]", "[LOCATION]", "[QUEUE]");
1200       Task task = Task.newBuilder().build();
1201       client.createTask(parent, task);
1202       Assert.fail("No exception raised");
1203     } catch (InvalidArgumentException e) {
1204       // Expected exception.
1205     }
1206   }
1207 
1208   @Test
createTaskTest2()1209   public void createTaskTest2() throws Exception {
1210     Task expectedResponse =
1211         Task.newBuilder()
1212             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1213             .setScheduleTime(Timestamp.newBuilder().build())
1214             .setCreateTime(Timestamp.newBuilder().build())
1215             .setDispatchDeadline(Duration.newBuilder().build())
1216             .setDispatchCount(-1217252086)
1217             .setResponseCount(424727441)
1218             .setFirstAttempt(Attempt.newBuilder().build())
1219             .setLastAttempt(Attempt.newBuilder().build())
1220             .build();
1221     mockCloudTasks.addResponse(expectedResponse);
1222 
1223     String parent = "parent-995424086";
1224     Task task = Task.newBuilder().build();
1225 
1226     Task actualResponse = client.createTask(parent, task);
1227     Assert.assertEquals(expectedResponse, actualResponse);
1228 
1229     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1230     Assert.assertEquals(1, actualRequests.size());
1231     CreateTaskRequest actualRequest = ((CreateTaskRequest) actualRequests.get(0));
1232 
1233     Assert.assertEquals(parent, actualRequest.getParent());
1234     Assert.assertEquals(task, actualRequest.getTask());
1235     Assert.assertTrue(
1236         channelProvider.isHeaderSent(
1237             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1238             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1239   }
1240 
1241   @Test
createTaskExceptionTest2()1242   public void createTaskExceptionTest2() throws Exception {
1243     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1244     mockCloudTasks.addException(exception);
1245 
1246     try {
1247       String parent = "parent-995424086";
1248       Task task = Task.newBuilder().build();
1249       client.createTask(parent, task);
1250       Assert.fail("No exception raised");
1251     } catch (InvalidArgumentException e) {
1252       // Expected exception.
1253     }
1254   }
1255 
1256   @Test
deleteTaskTest()1257   public void deleteTaskTest() throws Exception {
1258     Empty expectedResponse = Empty.newBuilder().build();
1259     mockCloudTasks.addResponse(expectedResponse);
1260 
1261     TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1262 
1263     client.deleteTask(name);
1264 
1265     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1266     Assert.assertEquals(1, actualRequests.size());
1267     DeleteTaskRequest actualRequest = ((DeleteTaskRequest) actualRequests.get(0));
1268 
1269     Assert.assertEquals(name.toString(), actualRequest.getName());
1270     Assert.assertTrue(
1271         channelProvider.isHeaderSent(
1272             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1273             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1274   }
1275 
1276   @Test
deleteTaskExceptionTest()1277   public void deleteTaskExceptionTest() throws Exception {
1278     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1279     mockCloudTasks.addException(exception);
1280 
1281     try {
1282       TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1283       client.deleteTask(name);
1284       Assert.fail("No exception raised");
1285     } catch (InvalidArgumentException e) {
1286       // Expected exception.
1287     }
1288   }
1289 
1290   @Test
deleteTaskTest2()1291   public void deleteTaskTest2() throws Exception {
1292     Empty expectedResponse = Empty.newBuilder().build();
1293     mockCloudTasks.addResponse(expectedResponse);
1294 
1295     String name = "name3373707";
1296 
1297     client.deleteTask(name);
1298 
1299     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1300     Assert.assertEquals(1, actualRequests.size());
1301     DeleteTaskRequest actualRequest = ((DeleteTaskRequest) actualRequests.get(0));
1302 
1303     Assert.assertEquals(name, actualRequest.getName());
1304     Assert.assertTrue(
1305         channelProvider.isHeaderSent(
1306             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1307             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1308   }
1309 
1310   @Test
deleteTaskExceptionTest2()1311   public void deleteTaskExceptionTest2() throws Exception {
1312     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1313     mockCloudTasks.addException(exception);
1314 
1315     try {
1316       String name = "name3373707";
1317       client.deleteTask(name);
1318       Assert.fail("No exception raised");
1319     } catch (InvalidArgumentException e) {
1320       // Expected exception.
1321     }
1322   }
1323 
1324   @Test
runTaskTest()1325   public void runTaskTest() throws Exception {
1326     Task expectedResponse =
1327         Task.newBuilder()
1328             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1329             .setScheduleTime(Timestamp.newBuilder().build())
1330             .setCreateTime(Timestamp.newBuilder().build())
1331             .setDispatchDeadline(Duration.newBuilder().build())
1332             .setDispatchCount(-1217252086)
1333             .setResponseCount(424727441)
1334             .setFirstAttempt(Attempt.newBuilder().build())
1335             .setLastAttempt(Attempt.newBuilder().build())
1336             .build();
1337     mockCloudTasks.addResponse(expectedResponse);
1338 
1339     TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1340 
1341     Task actualResponse = client.runTask(name);
1342     Assert.assertEquals(expectedResponse, actualResponse);
1343 
1344     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1345     Assert.assertEquals(1, actualRequests.size());
1346     RunTaskRequest actualRequest = ((RunTaskRequest) actualRequests.get(0));
1347 
1348     Assert.assertEquals(name.toString(), actualRequest.getName());
1349     Assert.assertTrue(
1350         channelProvider.isHeaderSent(
1351             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1352             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1353   }
1354 
1355   @Test
runTaskExceptionTest()1356   public void runTaskExceptionTest() throws Exception {
1357     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1358     mockCloudTasks.addException(exception);
1359 
1360     try {
1361       TaskName name = TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]");
1362       client.runTask(name);
1363       Assert.fail("No exception raised");
1364     } catch (InvalidArgumentException e) {
1365       // Expected exception.
1366     }
1367   }
1368 
1369   @Test
runTaskTest2()1370   public void runTaskTest2() throws Exception {
1371     Task expectedResponse =
1372         Task.newBuilder()
1373             .setName(TaskName.of("[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]").toString())
1374             .setScheduleTime(Timestamp.newBuilder().build())
1375             .setCreateTime(Timestamp.newBuilder().build())
1376             .setDispatchDeadline(Duration.newBuilder().build())
1377             .setDispatchCount(-1217252086)
1378             .setResponseCount(424727441)
1379             .setFirstAttempt(Attempt.newBuilder().build())
1380             .setLastAttempt(Attempt.newBuilder().build())
1381             .build();
1382     mockCloudTasks.addResponse(expectedResponse);
1383 
1384     String name = "name3373707";
1385 
1386     Task actualResponse = client.runTask(name);
1387     Assert.assertEquals(expectedResponse, actualResponse);
1388 
1389     List<AbstractMessage> actualRequests = mockCloudTasks.getRequests();
1390     Assert.assertEquals(1, actualRequests.size());
1391     RunTaskRequest actualRequest = ((RunTaskRequest) actualRequests.get(0));
1392 
1393     Assert.assertEquals(name, actualRequest.getName());
1394     Assert.assertTrue(
1395         channelProvider.isHeaderSent(
1396             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1397             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1398   }
1399 
1400   @Test
runTaskExceptionTest2()1401   public void runTaskExceptionTest2() throws Exception {
1402     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1403     mockCloudTasks.addException(exception);
1404 
1405     try {
1406       String name = "name3373707";
1407       client.runTask(name);
1408       Assert.fail("No exception raised");
1409     } catch (InvalidArgumentException e) {
1410       // Expected exception.
1411     }
1412   }
1413 }
1414