• 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.video.transcoder.v1;
18 
19 import static com.google.cloud.video.transcoder.v1.TranscoderServiceClient.ListJobTemplatesPagedResponse;
20 import static com.google.cloud.video.transcoder.v1.TranscoderServiceClient.ListJobsPagedResponse;
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.cloud.video.transcoder.v1.stub.HttpJsonTranscoderServiceStub;
32 import com.google.common.collect.Lists;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.Timestamp;
35 import com.google.rpc.Status;
36 import java.io.IOException;
37 import java.util.Arrays;
38 import java.util.HashMap;
39 import java.util.List;
40 import javax.annotation.Generated;
41 import org.junit.After;
42 import org.junit.AfterClass;
43 import org.junit.Assert;
44 import org.junit.Before;
45 import org.junit.BeforeClass;
46 import org.junit.Test;
47 
48 @Generated("by gapic-generator-java")
49 public class TranscoderServiceClientHttpJsonTest {
50   private static MockHttpService mockService;
51   private static TranscoderServiceClient client;
52 
53   @BeforeClass
startStaticServer()54   public static void startStaticServer() throws IOException {
55     mockService =
56         new MockHttpService(
57             HttpJsonTranscoderServiceStub.getMethodDescriptors(),
58             TranscoderServiceSettings.getDefaultEndpoint());
59     TranscoderServiceSettings settings =
60         TranscoderServiceSettings.newHttpJsonBuilder()
61             .setTransportChannelProvider(
62                 TranscoderServiceSettings.defaultHttpJsonTransportProviderBuilder()
63                     .setHttpTransport(mockService)
64                     .build())
65             .setCredentialsProvider(NoCredentialsProvider.create())
66             .build();
67     client = TranscoderServiceClient.create(settings);
68   }
69 
70   @AfterClass
stopServer()71   public static void stopServer() {
72     client.close();
73   }
74 
75   @Before
setUp()76   public void setUp() {}
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     mockService.reset();
81   }
82 
83   @Test
createJobTest()84   public void createJobTest() throws Exception {
85     Job expectedResponse =
86         Job.newBuilder()
87             .setName(JobName.of("[PROJECT]", "[LOCATION]", "[JOB]").toString())
88             .setInputUri("inputUri470706498")
89             .setOutputUri("outputUri-2119300949")
90             .setCreateTime(Timestamp.newBuilder().build())
91             .setStartTime(Timestamp.newBuilder().build())
92             .setEndTime(Timestamp.newBuilder().build())
93             .setTtlAfterCompletionDays(107576420)
94             .putAllLabels(new HashMap<String, String>())
95             .setError(Status.newBuilder().build())
96             .build();
97     mockService.addResponse(expectedResponse);
98 
99     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
100     Job job = Job.newBuilder().build();
101 
102     Job actualResponse = client.createJob(parent, job);
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<String> actualRequests = mockService.getRequestPaths();
106     Assert.assertEquals(1, actualRequests.size());
107 
108     String apiClientHeaderKey =
109         mockService
110             .getRequestHeaders()
111             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
112             .iterator()
113             .next();
114     Assert.assertTrue(
115         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
116             .matcher(apiClientHeaderKey)
117             .matches());
118   }
119 
120   @Test
createJobExceptionTest()121   public void createJobExceptionTest() throws Exception {
122     ApiException exception =
123         ApiExceptionFactory.createException(
124             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
125     mockService.addException(exception);
126 
127     try {
128       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
129       Job job = Job.newBuilder().build();
130       client.createJob(parent, job);
131       Assert.fail("No exception raised");
132     } catch (InvalidArgumentException e) {
133       // Expected exception.
134     }
135   }
136 
137   @Test
createJobTest2()138   public void createJobTest2() throws Exception {
139     Job expectedResponse =
140         Job.newBuilder()
141             .setName(JobName.of("[PROJECT]", "[LOCATION]", "[JOB]").toString())
142             .setInputUri("inputUri470706498")
143             .setOutputUri("outputUri-2119300949")
144             .setCreateTime(Timestamp.newBuilder().build())
145             .setStartTime(Timestamp.newBuilder().build())
146             .setEndTime(Timestamp.newBuilder().build())
147             .setTtlAfterCompletionDays(107576420)
148             .putAllLabels(new HashMap<String, String>())
149             .setError(Status.newBuilder().build())
150             .build();
151     mockService.addResponse(expectedResponse);
152 
153     String parent = "projects/project-5833/locations/location-5833";
154     Job job = Job.newBuilder().build();
155 
156     Job actualResponse = client.createJob(parent, job);
157     Assert.assertEquals(expectedResponse, actualResponse);
158 
159     List<String> actualRequests = mockService.getRequestPaths();
160     Assert.assertEquals(1, actualRequests.size());
161 
162     String apiClientHeaderKey =
163         mockService
164             .getRequestHeaders()
165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
166             .iterator()
167             .next();
168     Assert.assertTrue(
169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
170             .matcher(apiClientHeaderKey)
171             .matches());
172   }
173 
174   @Test
createJobExceptionTest2()175   public void createJobExceptionTest2() throws Exception {
176     ApiException exception =
177         ApiExceptionFactory.createException(
178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
179     mockService.addException(exception);
180 
181     try {
182       String parent = "projects/project-5833/locations/location-5833";
183       Job job = Job.newBuilder().build();
184       client.createJob(parent, job);
185       Assert.fail("No exception raised");
186     } catch (InvalidArgumentException e) {
187       // Expected exception.
188     }
189   }
190 
191   @Test
listJobsTest()192   public void listJobsTest() throws Exception {
193     Job responsesElement = Job.newBuilder().build();
194     ListJobsResponse expectedResponse =
195         ListJobsResponse.newBuilder()
196             .setNextPageToken("")
197             .addAllJobs(Arrays.asList(responsesElement))
198             .build();
199     mockService.addResponse(expectedResponse);
200 
201     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
202 
203     ListJobsPagedResponse pagedListResponse = client.listJobs(parent);
204 
205     List<Job> resources = Lists.newArrayList(pagedListResponse.iterateAll());
206 
207     Assert.assertEquals(1, resources.size());
208     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
209 
210     List<String> actualRequests = mockService.getRequestPaths();
211     Assert.assertEquals(1, actualRequests.size());
212 
213     String apiClientHeaderKey =
214         mockService
215             .getRequestHeaders()
216             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
217             .iterator()
218             .next();
219     Assert.assertTrue(
220         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
221             .matcher(apiClientHeaderKey)
222             .matches());
223   }
224 
225   @Test
listJobsExceptionTest()226   public void listJobsExceptionTest() throws Exception {
227     ApiException exception =
228         ApiExceptionFactory.createException(
229             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
230     mockService.addException(exception);
231 
232     try {
233       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
234       client.listJobs(parent);
235       Assert.fail("No exception raised");
236     } catch (InvalidArgumentException e) {
237       // Expected exception.
238     }
239   }
240 
241   @Test
listJobsTest2()242   public void listJobsTest2() throws Exception {
243     Job responsesElement = Job.newBuilder().build();
244     ListJobsResponse expectedResponse =
245         ListJobsResponse.newBuilder()
246             .setNextPageToken("")
247             .addAllJobs(Arrays.asList(responsesElement))
248             .build();
249     mockService.addResponse(expectedResponse);
250 
251     String parent = "projects/project-5833/locations/location-5833";
252 
253     ListJobsPagedResponse pagedListResponse = client.listJobs(parent);
254 
255     List<Job> resources = Lists.newArrayList(pagedListResponse.iterateAll());
256 
257     Assert.assertEquals(1, resources.size());
258     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
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
listJobsExceptionTest2()276   public void listJobsExceptionTest2() 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 parent = "projects/project-5833/locations/location-5833";
284       client.listJobs(parent);
285       Assert.fail("No exception raised");
286     } catch (InvalidArgumentException e) {
287       // Expected exception.
288     }
289   }
290 
291   @Test
getJobTest()292   public void getJobTest() throws Exception {
293     Job expectedResponse =
294         Job.newBuilder()
295             .setName(JobName.of("[PROJECT]", "[LOCATION]", "[JOB]").toString())
296             .setInputUri("inputUri470706498")
297             .setOutputUri("outputUri-2119300949")
298             .setCreateTime(Timestamp.newBuilder().build())
299             .setStartTime(Timestamp.newBuilder().build())
300             .setEndTime(Timestamp.newBuilder().build())
301             .setTtlAfterCompletionDays(107576420)
302             .putAllLabels(new HashMap<String, String>())
303             .setError(Status.newBuilder().build())
304             .build();
305     mockService.addResponse(expectedResponse);
306 
307     JobName name = JobName.of("[PROJECT]", "[LOCATION]", "[JOB]");
308 
309     Job actualResponse = client.getJob(name);
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
getJobExceptionTest()328   public void getJobExceptionTest() 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       JobName name = JobName.of("[PROJECT]", "[LOCATION]", "[JOB]");
336       client.getJob(name);
337       Assert.fail("No exception raised");
338     } catch (InvalidArgumentException e) {
339       // Expected exception.
340     }
341   }
342 
343   @Test
getJobTest2()344   public void getJobTest2() throws Exception {
345     Job expectedResponse =
346         Job.newBuilder()
347             .setName(JobName.of("[PROJECT]", "[LOCATION]", "[JOB]").toString())
348             .setInputUri("inputUri470706498")
349             .setOutputUri("outputUri-2119300949")
350             .setCreateTime(Timestamp.newBuilder().build())
351             .setStartTime(Timestamp.newBuilder().build())
352             .setEndTime(Timestamp.newBuilder().build())
353             .setTtlAfterCompletionDays(107576420)
354             .putAllLabels(new HashMap<String, String>())
355             .setError(Status.newBuilder().build())
356             .build();
357     mockService.addResponse(expectedResponse);
358 
359     String name = "projects/project-3306/locations/location-3306/jobs/job-3306";
360 
361     Job actualResponse = client.getJob(name);
362     Assert.assertEquals(expectedResponse, actualResponse);
363 
364     List<String> actualRequests = mockService.getRequestPaths();
365     Assert.assertEquals(1, actualRequests.size());
366 
367     String apiClientHeaderKey =
368         mockService
369             .getRequestHeaders()
370             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
371             .iterator()
372             .next();
373     Assert.assertTrue(
374         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
375             .matcher(apiClientHeaderKey)
376             .matches());
377   }
378 
379   @Test
getJobExceptionTest2()380   public void getJobExceptionTest2() throws Exception {
381     ApiException exception =
382         ApiExceptionFactory.createException(
383             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
384     mockService.addException(exception);
385 
386     try {
387       String name = "projects/project-3306/locations/location-3306/jobs/job-3306";
388       client.getJob(name);
389       Assert.fail("No exception raised");
390     } catch (InvalidArgumentException e) {
391       // Expected exception.
392     }
393   }
394 
395   @Test
deleteJobTest()396   public void deleteJobTest() throws Exception {
397     Empty expectedResponse = Empty.newBuilder().build();
398     mockService.addResponse(expectedResponse);
399 
400     JobName name = JobName.of("[PROJECT]", "[LOCATION]", "[JOB]");
401 
402     client.deleteJob(name);
403 
404     List<String> actualRequests = mockService.getRequestPaths();
405     Assert.assertEquals(1, actualRequests.size());
406 
407     String apiClientHeaderKey =
408         mockService
409             .getRequestHeaders()
410             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
411             .iterator()
412             .next();
413     Assert.assertTrue(
414         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
415             .matcher(apiClientHeaderKey)
416             .matches());
417   }
418 
419   @Test
deleteJobExceptionTest()420   public void deleteJobExceptionTest() throws Exception {
421     ApiException exception =
422         ApiExceptionFactory.createException(
423             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
424     mockService.addException(exception);
425 
426     try {
427       JobName name = JobName.of("[PROJECT]", "[LOCATION]", "[JOB]");
428       client.deleteJob(name);
429       Assert.fail("No exception raised");
430     } catch (InvalidArgumentException e) {
431       // Expected exception.
432     }
433   }
434 
435   @Test
deleteJobTest2()436   public void deleteJobTest2() throws Exception {
437     Empty expectedResponse = Empty.newBuilder().build();
438     mockService.addResponse(expectedResponse);
439 
440     String name = "projects/project-3306/locations/location-3306/jobs/job-3306";
441 
442     client.deleteJob(name);
443 
444     List<String> actualRequests = mockService.getRequestPaths();
445     Assert.assertEquals(1, actualRequests.size());
446 
447     String apiClientHeaderKey =
448         mockService
449             .getRequestHeaders()
450             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
451             .iterator()
452             .next();
453     Assert.assertTrue(
454         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
455             .matcher(apiClientHeaderKey)
456             .matches());
457   }
458 
459   @Test
deleteJobExceptionTest2()460   public void deleteJobExceptionTest2() throws Exception {
461     ApiException exception =
462         ApiExceptionFactory.createException(
463             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
464     mockService.addException(exception);
465 
466     try {
467       String name = "projects/project-3306/locations/location-3306/jobs/job-3306";
468       client.deleteJob(name);
469       Assert.fail("No exception raised");
470     } catch (InvalidArgumentException e) {
471       // Expected exception.
472     }
473   }
474 
475   @Test
createJobTemplateTest()476   public void createJobTemplateTest() throws Exception {
477     JobTemplate expectedResponse =
478         JobTemplate.newBuilder()
479             .setName(JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]").toString())
480             .setConfig(JobConfig.newBuilder().build())
481             .putAllLabels(new HashMap<String, String>())
482             .build();
483     mockService.addResponse(expectedResponse);
484 
485     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
486     JobTemplate jobTemplate = JobTemplate.newBuilder().build();
487     String jobTemplateId = "jobTemplateId-597733678";
488 
489     JobTemplate actualResponse = client.createJobTemplate(parent, jobTemplate, jobTemplateId);
490     Assert.assertEquals(expectedResponse, actualResponse);
491 
492     List<String> actualRequests = mockService.getRequestPaths();
493     Assert.assertEquals(1, actualRequests.size());
494 
495     String apiClientHeaderKey =
496         mockService
497             .getRequestHeaders()
498             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
499             .iterator()
500             .next();
501     Assert.assertTrue(
502         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
503             .matcher(apiClientHeaderKey)
504             .matches());
505   }
506 
507   @Test
createJobTemplateExceptionTest()508   public void createJobTemplateExceptionTest() throws Exception {
509     ApiException exception =
510         ApiExceptionFactory.createException(
511             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
512     mockService.addException(exception);
513 
514     try {
515       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
516       JobTemplate jobTemplate = JobTemplate.newBuilder().build();
517       String jobTemplateId = "jobTemplateId-597733678";
518       client.createJobTemplate(parent, jobTemplate, jobTemplateId);
519       Assert.fail("No exception raised");
520     } catch (InvalidArgumentException e) {
521       // Expected exception.
522     }
523   }
524 
525   @Test
createJobTemplateTest2()526   public void createJobTemplateTest2() throws Exception {
527     JobTemplate expectedResponse =
528         JobTemplate.newBuilder()
529             .setName(JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]").toString())
530             .setConfig(JobConfig.newBuilder().build())
531             .putAllLabels(new HashMap<String, String>())
532             .build();
533     mockService.addResponse(expectedResponse);
534 
535     String parent = "projects/project-5833/locations/location-5833";
536     JobTemplate jobTemplate = JobTemplate.newBuilder().build();
537     String jobTemplateId = "jobTemplateId-597733678";
538 
539     JobTemplate actualResponse = client.createJobTemplate(parent, jobTemplate, jobTemplateId);
540     Assert.assertEquals(expectedResponse, actualResponse);
541 
542     List<String> actualRequests = mockService.getRequestPaths();
543     Assert.assertEquals(1, actualRequests.size());
544 
545     String apiClientHeaderKey =
546         mockService
547             .getRequestHeaders()
548             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
549             .iterator()
550             .next();
551     Assert.assertTrue(
552         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
553             .matcher(apiClientHeaderKey)
554             .matches());
555   }
556 
557   @Test
createJobTemplateExceptionTest2()558   public void createJobTemplateExceptionTest2() throws Exception {
559     ApiException exception =
560         ApiExceptionFactory.createException(
561             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
562     mockService.addException(exception);
563 
564     try {
565       String parent = "projects/project-5833/locations/location-5833";
566       JobTemplate jobTemplate = JobTemplate.newBuilder().build();
567       String jobTemplateId = "jobTemplateId-597733678";
568       client.createJobTemplate(parent, jobTemplate, jobTemplateId);
569       Assert.fail("No exception raised");
570     } catch (InvalidArgumentException e) {
571       // Expected exception.
572     }
573   }
574 
575   @Test
listJobTemplatesTest()576   public void listJobTemplatesTest() throws Exception {
577     JobTemplate responsesElement = JobTemplate.newBuilder().build();
578     ListJobTemplatesResponse expectedResponse =
579         ListJobTemplatesResponse.newBuilder()
580             .setNextPageToken("")
581             .addAllJobTemplates(Arrays.asList(responsesElement))
582             .build();
583     mockService.addResponse(expectedResponse);
584 
585     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
586 
587     ListJobTemplatesPagedResponse pagedListResponse = client.listJobTemplates(parent);
588 
589     List<JobTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
590 
591     Assert.assertEquals(1, resources.size());
592     Assert.assertEquals(expectedResponse.getJobTemplatesList().get(0), resources.get(0));
593 
594     List<String> actualRequests = mockService.getRequestPaths();
595     Assert.assertEquals(1, actualRequests.size());
596 
597     String apiClientHeaderKey =
598         mockService
599             .getRequestHeaders()
600             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
601             .iterator()
602             .next();
603     Assert.assertTrue(
604         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
605             .matcher(apiClientHeaderKey)
606             .matches());
607   }
608 
609   @Test
listJobTemplatesExceptionTest()610   public void listJobTemplatesExceptionTest() throws Exception {
611     ApiException exception =
612         ApiExceptionFactory.createException(
613             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
614     mockService.addException(exception);
615 
616     try {
617       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
618       client.listJobTemplates(parent);
619       Assert.fail("No exception raised");
620     } catch (InvalidArgumentException e) {
621       // Expected exception.
622     }
623   }
624 
625   @Test
listJobTemplatesTest2()626   public void listJobTemplatesTest2() throws Exception {
627     JobTemplate responsesElement = JobTemplate.newBuilder().build();
628     ListJobTemplatesResponse expectedResponse =
629         ListJobTemplatesResponse.newBuilder()
630             .setNextPageToken("")
631             .addAllJobTemplates(Arrays.asList(responsesElement))
632             .build();
633     mockService.addResponse(expectedResponse);
634 
635     String parent = "projects/project-5833/locations/location-5833";
636 
637     ListJobTemplatesPagedResponse pagedListResponse = client.listJobTemplates(parent);
638 
639     List<JobTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
640 
641     Assert.assertEquals(1, resources.size());
642     Assert.assertEquals(expectedResponse.getJobTemplatesList().get(0), resources.get(0));
643 
644     List<String> actualRequests = mockService.getRequestPaths();
645     Assert.assertEquals(1, actualRequests.size());
646 
647     String apiClientHeaderKey =
648         mockService
649             .getRequestHeaders()
650             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
651             .iterator()
652             .next();
653     Assert.assertTrue(
654         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
655             .matcher(apiClientHeaderKey)
656             .matches());
657   }
658 
659   @Test
listJobTemplatesExceptionTest2()660   public void listJobTemplatesExceptionTest2() throws Exception {
661     ApiException exception =
662         ApiExceptionFactory.createException(
663             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
664     mockService.addException(exception);
665 
666     try {
667       String parent = "projects/project-5833/locations/location-5833";
668       client.listJobTemplates(parent);
669       Assert.fail("No exception raised");
670     } catch (InvalidArgumentException e) {
671       // Expected exception.
672     }
673   }
674 
675   @Test
getJobTemplateTest()676   public void getJobTemplateTest() throws Exception {
677     JobTemplate expectedResponse =
678         JobTemplate.newBuilder()
679             .setName(JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]").toString())
680             .setConfig(JobConfig.newBuilder().build())
681             .putAllLabels(new HashMap<String, String>())
682             .build();
683     mockService.addResponse(expectedResponse);
684 
685     JobTemplateName name = JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]");
686 
687     JobTemplate actualResponse = client.getJobTemplate(name);
688     Assert.assertEquals(expectedResponse, actualResponse);
689 
690     List<String> actualRequests = mockService.getRequestPaths();
691     Assert.assertEquals(1, actualRequests.size());
692 
693     String apiClientHeaderKey =
694         mockService
695             .getRequestHeaders()
696             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
697             .iterator()
698             .next();
699     Assert.assertTrue(
700         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
701             .matcher(apiClientHeaderKey)
702             .matches());
703   }
704 
705   @Test
getJobTemplateExceptionTest()706   public void getJobTemplateExceptionTest() throws Exception {
707     ApiException exception =
708         ApiExceptionFactory.createException(
709             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
710     mockService.addException(exception);
711 
712     try {
713       JobTemplateName name = JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]");
714       client.getJobTemplate(name);
715       Assert.fail("No exception raised");
716     } catch (InvalidArgumentException e) {
717       // Expected exception.
718     }
719   }
720 
721   @Test
getJobTemplateTest2()722   public void getJobTemplateTest2() throws Exception {
723     JobTemplate expectedResponse =
724         JobTemplate.newBuilder()
725             .setName(JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]").toString())
726             .setConfig(JobConfig.newBuilder().build())
727             .putAllLabels(new HashMap<String, String>())
728             .build();
729     mockService.addResponse(expectedResponse);
730 
731     String name = "projects/project-3644/locations/location-3644/jobTemplates/jobTemplate-3644";
732 
733     JobTemplate actualResponse = client.getJobTemplate(name);
734     Assert.assertEquals(expectedResponse, actualResponse);
735 
736     List<String> actualRequests = mockService.getRequestPaths();
737     Assert.assertEquals(1, actualRequests.size());
738 
739     String apiClientHeaderKey =
740         mockService
741             .getRequestHeaders()
742             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
743             .iterator()
744             .next();
745     Assert.assertTrue(
746         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
747             .matcher(apiClientHeaderKey)
748             .matches());
749   }
750 
751   @Test
getJobTemplateExceptionTest2()752   public void getJobTemplateExceptionTest2() throws Exception {
753     ApiException exception =
754         ApiExceptionFactory.createException(
755             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
756     mockService.addException(exception);
757 
758     try {
759       String name = "projects/project-3644/locations/location-3644/jobTemplates/jobTemplate-3644";
760       client.getJobTemplate(name);
761       Assert.fail("No exception raised");
762     } catch (InvalidArgumentException e) {
763       // Expected exception.
764     }
765   }
766 
767   @Test
deleteJobTemplateTest()768   public void deleteJobTemplateTest() throws Exception {
769     Empty expectedResponse = Empty.newBuilder().build();
770     mockService.addResponse(expectedResponse);
771 
772     JobTemplateName name = JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]");
773 
774     client.deleteJobTemplate(name);
775 
776     List<String> actualRequests = mockService.getRequestPaths();
777     Assert.assertEquals(1, actualRequests.size());
778 
779     String apiClientHeaderKey =
780         mockService
781             .getRequestHeaders()
782             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
783             .iterator()
784             .next();
785     Assert.assertTrue(
786         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
787             .matcher(apiClientHeaderKey)
788             .matches());
789   }
790 
791   @Test
deleteJobTemplateExceptionTest()792   public void deleteJobTemplateExceptionTest() throws Exception {
793     ApiException exception =
794         ApiExceptionFactory.createException(
795             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
796     mockService.addException(exception);
797 
798     try {
799       JobTemplateName name = JobTemplateName.of("[PROJECT]", "[LOCATION]", "[JOB_TEMPLATE]");
800       client.deleteJobTemplate(name);
801       Assert.fail("No exception raised");
802     } catch (InvalidArgumentException e) {
803       // Expected exception.
804     }
805   }
806 
807   @Test
deleteJobTemplateTest2()808   public void deleteJobTemplateTest2() throws Exception {
809     Empty expectedResponse = Empty.newBuilder().build();
810     mockService.addResponse(expectedResponse);
811 
812     String name = "projects/project-3644/locations/location-3644/jobTemplates/jobTemplate-3644";
813 
814     client.deleteJobTemplate(name);
815 
816     List<String> actualRequests = mockService.getRequestPaths();
817     Assert.assertEquals(1, actualRequests.size());
818 
819     String apiClientHeaderKey =
820         mockService
821             .getRequestHeaders()
822             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
823             .iterator()
824             .next();
825     Assert.assertTrue(
826         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
827             .matcher(apiClientHeaderKey)
828             .matches());
829   }
830 
831   @Test
deleteJobTemplateExceptionTest2()832   public void deleteJobTemplateExceptionTest2() throws Exception {
833     ApiException exception =
834         ApiExceptionFactory.createException(
835             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
836     mockService.addException(exception);
837 
838     try {
839       String name = "projects/project-3644/locations/location-3644/jobTemplates/jobTemplate-3644";
840       client.deleteJobTemplate(name);
841       Assert.fail("No exception raised");
842     } catch (InvalidArgumentException e) {
843       // Expected exception.
844     }
845   }
846 }
847