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