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