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