• 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.talent.v4beta1;
18 
19 import static com.google.cloud.talent.v4beta1.JobServiceClient.ListJobsPagedResponse;
20 import static com.google.cloud.talent.v4beta1.JobServiceClient.SearchJobsForAlertPagedResponse;
21 import static com.google.cloud.talent.v4beta1.JobServiceClient.SearchJobsPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
25 import com.google.api.gax.httpjson.testing.MockHttpService;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.ApiException;
28 import com.google.api.gax.rpc.ApiExceptionFactory;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.api.gax.rpc.testing.FakeStatusCode;
32 import com.google.cloud.talent.v4beta1.stub.HttpJsonJobServiceStub;
33 import com.google.common.collect.Lists;
34 import com.google.longrunning.Operation;
35 import com.google.protobuf.Any;
36 import com.google.protobuf.Empty;
37 import com.google.protobuf.Timestamp;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.List;
43 import java.util.concurrent.ExecutionException;
44 import javax.annotation.Generated;
45 import org.junit.After;
46 import org.junit.AfterClass;
47 import org.junit.Assert;
48 import org.junit.Before;
49 import org.junit.BeforeClass;
50 import org.junit.Test;
51 
52 @Generated("by gapic-generator-java")
53 public class JobServiceClientHttpJsonTest {
54   private static MockHttpService mockService;
55   private static JobServiceClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() throws IOException {
59     mockService =
60         new MockHttpService(
61             HttpJsonJobServiceStub.getMethodDescriptors(), JobServiceSettings.getDefaultEndpoint());
62     JobServiceSettings settings =
63         JobServiceSettings.newHttpJsonBuilder()
64             .setTransportChannelProvider(
65                 JobServiceSettings.defaultHttpJsonTransportProviderBuilder()
66                     .setHttpTransport(mockService)
67                     .build())
68             .setCredentialsProvider(NoCredentialsProvider.create())
69             .build();
70     client = JobServiceClient.create(settings);
71   }
72 
73   @AfterClass
stopServer()74   public static void stopServer() {
75     client.close();
76   }
77 
78   @Before
setUp()79   public void setUp() {}
80 
81   @After
tearDown()82   public void tearDown() throws Exception {
83     mockService.reset();
84   }
85 
86   @Test
createJobTest()87   public void createJobTest() throws Exception {
88     Job expectedResponse =
89         Job.newBuilder()
90             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
91             .setCompany(
92                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
93                     .toString())
94             .setRequisitionId("requisitionId-1769495849")
95             .setTitle("title110371416")
96             .setDescription("description-1724546052")
97             .addAllAddresses(new ArrayList<String>())
98             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
99             .addAllJobBenefits(new ArrayList<JobBenefit>())
100             .setCompensationInfo(CompensationInfo.newBuilder().build())
101             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
102             .addAllDegreeTypes(new ArrayList<DegreeType>())
103             .setDepartment("department848184146")
104             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
105             .setIncentives("incentives-1262874520")
106             .setLanguageCode("languageCode-2092349083")
107             .setJobLevel(JobLevel.forNumber(0))
108             .setPromotionValue(353413845)
109             .setQualifications("qualifications1903501412")
110             .setResponsibilities("responsibilities-926952660")
111             .setPostingRegion(PostingRegion.forNumber(0))
112             .setVisibility(Visibility.forNumber(0))
113             .setJobStartTime(Timestamp.newBuilder().build())
114             .setJobEndTime(Timestamp.newBuilder().build())
115             .setPostingPublishTime(Timestamp.newBuilder().build())
116             .setPostingExpireTime(Timestamp.newBuilder().build())
117             .setPostingCreateTime(Timestamp.newBuilder().build())
118             .setPostingUpdateTime(Timestamp.newBuilder().build())
119             .setCompanyDisplayName("companyDisplayName-686915152")
120             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
121             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
122             .build();
123     mockService.addResponse(expectedResponse);
124 
125     ProjectName parent = ProjectName.of("[PROJECT]");
126     Job job = Job.newBuilder().build();
127 
128     Job actualResponse = client.createJob(parent, job);
129     Assert.assertEquals(expectedResponse, actualResponse);
130 
131     List<String> actualRequests = mockService.getRequestPaths();
132     Assert.assertEquals(1, actualRequests.size());
133 
134     String apiClientHeaderKey =
135         mockService
136             .getRequestHeaders()
137             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
138             .iterator()
139             .next();
140     Assert.assertTrue(
141         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
142             .matcher(apiClientHeaderKey)
143             .matches());
144   }
145 
146   @Test
createJobExceptionTest()147   public void createJobExceptionTest() throws Exception {
148     ApiException exception =
149         ApiExceptionFactory.createException(
150             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
151     mockService.addException(exception);
152 
153     try {
154       ProjectName parent = ProjectName.of("[PROJECT]");
155       Job job = Job.newBuilder().build();
156       client.createJob(parent, job);
157       Assert.fail("No exception raised");
158     } catch (InvalidArgumentException e) {
159       // Expected exception.
160     }
161   }
162 
163   @Test
createJobTest2()164   public void createJobTest2() throws Exception {
165     Job expectedResponse =
166         Job.newBuilder()
167             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
168             .setCompany(
169                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
170                     .toString())
171             .setRequisitionId("requisitionId-1769495849")
172             .setTitle("title110371416")
173             .setDescription("description-1724546052")
174             .addAllAddresses(new ArrayList<String>())
175             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
176             .addAllJobBenefits(new ArrayList<JobBenefit>())
177             .setCompensationInfo(CompensationInfo.newBuilder().build())
178             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
179             .addAllDegreeTypes(new ArrayList<DegreeType>())
180             .setDepartment("department848184146")
181             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
182             .setIncentives("incentives-1262874520")
183             .setLanguageCode("languageCode-2092349083")
184             .setJobLevel(JobLevel.forNumber(0))
185             .setPromotionValue(353413845)
186             .setQualifications("qualifications1903501412")
187             .setResponsibilities("responsibilities-926952660")
188             .setPostingRegion(PostingRegion.forNumber(0))
189             .setVisibility(Visibility.forNumber(0))
190             .setJobStartTime(Timestamp.newBuilder().build())
191             .setJobEndTime(Timestamp.newBuilder().build())
192             .setPostingPublishTime(Timestamp.newBuilder().build())
193             .setPostingExpireTime(Timestamp.newBuilder().build())
194             .setPostingCreateTime(Timestamp.newBuilder().build())
195             .setPostingUpdateTime(Timestamp.newBuilder().build())
196             .setCompanyDisplayName("companyDisplayName-686915152")
197             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
198             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
199             .build();
200     mockService.addResponse(expectedResponse);
201 
202     TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
203     Job job = Job.newBuilder().build();
204 
205     Job actualResponse = client.createJob(parent, job);
206     Assert.assertEquals(expectedResponse, actualResponse);
207 
208     List<String> actualRequests = mockService.getRequestPaths();
209     Assert.assertEquals(1, actualRequests.size());
210 
211     String apiClientHeaderKey =
212         mockService
213             .getRequestHeaders()
214             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
215             .iterator()
216             .next();
217     Assert.assertTrue(
218         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
219             .matcher(apiClientHeaderKey)
220             .matches());
221   }
222 
223   @Test
createJobExceptionTest2()224   public void createJobExceptionTest2() throws Exception {
225     ApiException exception =
226         ApiExceptionFactory.createException(
227             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
228     mockService.addException(exception);
229 
230     try {
231       TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
232       Job job = Job.newBuilder().build();
233       client.createJob(parent, job);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
createJobTest3()241   public void createJobTest3() throws Exception {
242     Job expectedResponse =
243         Job.newBuilder()
244             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
245             .setCompany(
246                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
247                     .toString())
248             .setRequisitionId("requisitionId-1769495849")
249             .setTitle("title110371416")
250             .setDescription("description-1724546052")
251             .addAllAddresses(new ArrayList<String>())
252             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
253             .addAllJobBenefits(new ArrayList<JobBenefit>())
254             .setCompensationInfo(CompensationInfo.newBuilder().build())
255             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
256             .addAllDegreeTypes(new ArrayList<DegreeType>())
257             .setDepartment("department848184146")
258             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
259             .setIncentives("incentives-1262874520")
260             .setLanguageCode("languageCode-2092349083")
261             .setJobLevel(JobLevel.forNumber(0))
262             .setPromotionValue(353413845)
263             .setQualifications("qualifications1903501412")
264             .setResponsibilities("responsibilities-926952660")
265             .setPostingRegion(PostingRegion.forNumber(0))
266             .setVisibility(Visibility.forNumber(0))
267             .setJobStartTime(Timestamp.newBuilder().build())
268             .setJobEndTime(Timestamp.newBuilder().build())
269             .setPostingPublishTime(Timestamp.newBuilder().build())
270             .setPostingExpireTime(Timestamp.newBuilder().build())
271             .setPostingCreateTime(Timestamp.newBuilder().build())
272             .setPostingUpdateTime(Timestamp.newBuilder().build())
273             .setCompanyDisplayName("companyDisplayName-686915152")
274             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
275             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
276             .build();
277     mockService.addResponse(expectedResponse);
278 
279     String parent = "projects/project-8940/tenants/tenant-8940";
280     Job job = Job.newBuilder().build();
281 
282     Job actualResponse = client.createJob(parent, job);
283     Assert.assertEquals(expectedResponse, actualResponse);
284 
285     List<String> actualRequests = mockService.getRequestPaths();
286     Assert.assertEquals(1, actualRequests.size());
287 
288     String apiClientHeaderKey =
289         mockService
290             .getRequestHeaders()
291             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
292             .iterator()
293             .next();
294     Assert.assertTrue(
295         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
296             .matcher(apiClientHeaderKey)
297             .matches());
298   }
299 
300   @Test
createJobExceptionTest3()301   public void createJobExceptionTest3() throws Exception {
302     ApiException exception =
303         ApiExceptionFactory.createException(
304             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
305     mockService.addException(exception);
306 
307     try {
308       String parent = "projects/project-8940/tenants/tenant-8940";
309       Job job = Job.newBuilder().build();
310       client.createJob(parent, job);
311       Assert.fail("No exception raised");
312     } catch (InvalidArgumentException e) {
313       // Expected exception.
314     }
315   }
316 
317   @Test
batchCreateJobsTest()318   public void batchCreateJobsTest() throws Exception {
319     JobOperationResult expectedResponse =
320         JobOperationResult.newBuilder()
321             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
322             .build();
323     Operation resultOperation =
324         Operation.newBuilder()
325             .setName("batchCreateJobsTest")
326             .setDone(true)
327             .setResponse(Any.pack(expectedResponse))
328             .build();
329     mockService.addResponse(resultOperation);
330 
331     ProjectName parent = ProjectName.of("[PROJECT]");
332     List<Job> jobs = new ArrayList<>();
333 
334     JobOperationResult actualResponse = client.batchCreateJobsAsync(parent, jobs).get();
335     Assert.assertEquals(expectedResponse, actualResponse);
336 
337     List<String> actualRequests = mockService.getRequestPaths();
338     Assert.assertEquals(1, actualRequests.size());
339 
340     String apiClientHeaderKey =
341         mockService
342             .getRequestHeaders()
343             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
344             .iterator()
345             .next();
346     Assert.assertTrue(
347         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
348             .matcher(apiClientHeaderKey)
349             .matches());
350   }
351 
352   @Test
batchCreateJobsExceptionTest()353   public void batchCreateJobsExceptionTest() throws Exception {
354     ApiException exception =
355         ApiExceptionFactory.createException(
356             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
357     mockService.addException(exception);
358 
359     try {
360       ProjectName parent = ProjectName.of("[PROJECT]");
361       List<Job> jobs = new ArrayList<>();
362       client.batchCreateJobsAsync(parent, jobs).get();
363       Assert.fail("No exception raised");
364     } catch (ExecutionException e) {
365     }
366   }
367 
368   @Test
batchCreateJobsTest2()369   public void batchCreateJobsTest2() throws Exception {
370     JobOperationResult expectedResponse =
371         JobOperationResult.newBuilder()
372             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
373             .build();
374     Operation resultOperation =
375         Operation.newBuilder()
376             .setName("batchCreateJobsTest")
377             .setDone(true)
378             .setResponse(Any.pack(expectedResponse))
379             .build();
380     mockService.addResponse(resultOperation);
381 
382     TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
383     List<Job> jobs = new ArrayList<>();
384 
385     JobOperationResult actualResponse = client.batchCreateJobsAsync(parent, jobs).get();
386     Assert.assertEquals(expectedResponse, actualResponse);
387 
388     List<String> actualRequests = mockService.getRequestPaths();
389     Assert.assertEquals(1, actualRequests.size());
390 
391     String apiClientHeaderKey =
392         mockService
393             .getRequestHeaders()
394             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
395             .iterator()
396             .next();
397     Assert.assertTrue(
398         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
399             .matcher(apiClientHeaderKey)
400             .matches());
401   }
402 
403   @Test
batchCreateJobsExceptionTest2()404   public void batchCreateJobsExceptionTest2() throws Exception {
405     ApiException exception =
406         ApiExceptionFactory.createException(
407             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
408     mockService.addException(exception);
409 
410     try {
411       TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
412       List<Job> jobs = new ArrayList<>();
413       client.batchCreateJobsAsync(parent, jobs).get();
414       Assert.fail("No exception raised");
415     } catch (ExecutionException e) {
416     }
417   }
418 
419   @Test
batchCreateJobsTest3()420   public void batchCreateJobsTest3() throws Exception {
421     JobOperationResult expectedResponse =
422         JobOperationResult.newBuilder()
423             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
424             .build();
425     Operation resultOperation =
426         Operation.newBuilder()
427             .setName("batchCreateJobsTest")
428             .setDone(true)
429             .setResponse(Any.pack(expectedResponse))
430             .build();
431     mockService.addResponse(resultOperation);
432 
433     String parent = "projects/project-8940/tenants/tenant-8940";
434     List<Job> jobs = new ArrayList<>();
435 
436     JobOperationResult actualResponse = client.batchCreateJobsAsync(parent, jobs).get();
437     Assert.assertEquals(expectedResponse, actualResponse);
438 
439     List<String> actualRequests = mockService.getRequestPaths();
440     Assert.assertEquals(1, actualRequests.size());
441 
442     String apiClientHeaderKey =
443         mockService
444             .getRequestHeaders()
445             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
446             .iterator()
447             .next();
448     Assert.assertTrue(
449         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
450             .matcher(apiClientHeaderKey)
451             .matches());
452   }
453 
454   @Test
batchCreateJobsExceptionTest3()455   public void batchCreateJobsExceptionTest3() throws Exception {
456     ApiException exception =
457         ApiExceptionFactory.createException(
458             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
459     mockService.addException(exception);
460 
461     try {
462       String parent = "projects/project-8940/tenants/tenant-8940";
463       List<Job> jobs = new ArrayList<>();
464       client.batchCreateJobsAsync(parent, jobs).get();
465       Assert.fail("No exception raised");
466     } catch (ExecutionException e) {
467     }
468   }
469 
470   @Test
getJobTest()471   public void getJobTest() throws Exception {
472     Job expectedResponse =
473         Job.newBuilder()
474             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
475             .setCompany(
476                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
477                     .toString())
478             .setRequisitionId("requisitionId-1769495849")
479             .setTitle("title110371416")
480             .setDescription("description-1724546052")
481             .addAllAddresses(new ArrayList<String>())
482             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
483             .addAllJobBenefits(new ArrayList<JobBenefit>())
484             .setCompensationInfo(CompensationInfo.newBuilder().build())
485             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
486             .addAllDegreeTypes(new ArrayList<DegreeType>())
487             .setDepartment("department848184146")
488             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
489             .setIncentives("incentives-1262874520")
490             .setLanguageCode("languageCode-2092349083")
491             .setJobLevel(JobLevel.forNumber(0))
492             .setPromotionValue(353413845)
493             .setQualifications("qualifications1903501412")
494             .setResponsibilities("responsibilities-926952660")
495             .setPostingRegion(PostingRegion.forNumber(0))
496             .setVisibility(Visibility.forNumber(0))
497             .setJobStartTime(Timestamp.newBuilder().build())
498             .setJobEndTime(Timestamp.newBuilder().build())
499             .setPostingPublishTime(Timestamp.newBuilder().build())
500             .setPostingExpireTime(Timestamp.newBuilder().build())
501             .setPostingCreateTime(Timestamp.newBuilder().build())
502             .setPostingUpdateTime(Timestamp.newBuilder().build())
503             .setCompanyDisplayName("companyDisplayName-686915152")
504             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
505             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
506             .build();
507     mockService.addResponse(expectedResponse);
508 
509     JobName name = JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]");
510 
511     Job actualResponse = client.getJob(name);
512     Assert.assertEquals(expectedResponse, actualResponse);
513 
514     List<String> actualRequests = mockService.getRequestPaths();
515     Assert.assertEquals(1, actualRequests.size());
516 
517     String apiClientHeaderKey =
518         mockService
519             .getRequestHeaders()
520             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
521             .iterator()
522             .next();
523     Assert.assertTrue(
524         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
525             .matcher(apiClientHeaderKey)
526             .matches());
527   }
528 
529   @Test
getJobExceptionTest()530   public void getJobExceptionTest() throws Exception {
531     ApiException exception =
532         ApiExceptionFactory.createException(
533             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
534     mockService.addException(exception);
535 
536     try {
537       JobName name = JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]");
538       client.getJob(name);
539       Assert.fail("No exception raised");
540     } catch (InvalidArgumentException e) {
541       // Expected exception.
542     }
543   }
544 
545   @Test
getJobTest2()546   public void getJobTest2() throws Exception {
547     Job expectedResponse =
548         Job.newBuilder()
549             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
550             .setCompany(
551                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
552                     .toString())
553             .setRequisitionId("requisitionId-1769495849")
554             .setTitle("title110371416")
555             .setDescription("description-1724546052")
556             .addAllAddresses(new ArrayList<String>())
557             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
558             .addAllJobBenefits(new ArrayList<JobBenefit>())
559             .setCompensationInfo(CompensationInfo.newBuilder().build())
560             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
561             .addAllDegreeTypes(new ArrayList<DegreeType>())
562             .setDepartment("department848184146")
563             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
564             .setIncentives("incentives-1262874520")
565             .setLanguageCode("languageCode-2092349083")
566             .setJobLevel(JobLevel.forNumber(0))
567             .setPromotionValue(353413845)
568             .setQualifications("qualifications1903501412")
569             .setResponsibilities("responsibilities-926952660")
570             .setPostingRegion(PostingRegion.forNumber(0))
571             .setVisibility(Visibility.forNumber(0))
572             .setJobStartTime(Timestamp.newBuilder().build())
573             .setJobEndTime(Timestamp.newBuilder().build())
574             .setPostingPublishTime(Timestamp.newBuilder().build())
575             .setPostingExpireTime(Timestamp.newBuilder().build())
576             .setPostingCreateTime(Timestamp.newBuilder().build())
577             .setPostingUpdateTime(Timestamp.newBuilder().build())
578             .setCompanyDisplayName("companyDisplayName-686915152")
579             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
580             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
581             .build();
582     mockService.addResponse(expectedResponse);
583 
584     String name = "projects/project-4373/tenants/tenant-4373/jobs/job-4373";
585 
586     Job actualResponse = client.getJob(name);
587     Assert.assertEquals(expectedResponse, actualResponse);
588 
589     List<String> actualRequests = mockService.getRequestPaths();
590     Assert.assertEquals(1, actualRequests.size());
591 
592     String apiClientHeaderKey =
593         mockService
594             .getRequestHeaders()
595             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
596             .iterator()
597             .next();
598     Assert.assertTrue(
599         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
600             .matcher(apiClientHeaderKey)
601             .matches());
602   }
603 
604   @Test
getJobExceptionTest2()605   public void getJobExceptionTest2() throws Exception {
606     ApiException exception =
607         ApiExceptionFactory.createException(
608             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
609     mockService.addException(exception);
610 
611     try {
612       String name = "projects/project-4373/tenants/tenant-4373/jobs/job-4373";
613       client.getJob(name);
614       Assert.fail("No exception raised");
615     } catch (InvalidArgumentException e) {
616       // Expected exception.
617     }
618   }
619 
620   @Test
updateJobTest()621   public void updateJobTest() throws Exception {
622     Job expectedResponse =
623         Job.newBuilder()
624             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
625             .setCompany(
626                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
627                     .toString())
628             .setRequisitionId("requisitionId-1769495849")
629             .setTitle("title110371416")
630             .setDescription("description-1724546052")
631             .addAllAddresses(new ArrayList<String>())
632             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
633             .addAllJobBenefits(new ArrayList<JobBenefit>())
634             .setCompensationInfo(CompensationInfo.newBuilder().build())
635             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
636             .addAllDegreeTypes(new ArrayList<DegreeType>())
637             .setDepartment("department848184146")
638             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
639             .setIncentives("incentives-1262874520")
640             .setLanguageCode("languageCode-2092349083")
641             .setJobLevel(JobLevel.forNumber(0))
642             .setPromotionValue(353413845)
643             .setQualifications("qualifications1903501412")
644             .setResponsibilities("responsibilities-926952660")
645             .setPostingRegion(PostingRegion.forNumber(0))
646             .setVisibility(Visibility.forNumber(0))
647             .setJobStartTime(Timestamp.newBuilder().build())
648             .setJobEndTime(Timestamp.newBuilder().build())
649             .setPostingPublishTime(Timestamp.newBuilder().build())
650             .setPostingExpireTime(Timestamp.newBuilder().build())
651             .setPostingCreateTime(Timestamp.newBuilder().build())
652             .setPostingUpdateTime(Timestamp.newBuilder().build())
653             .setCompanyDisplayName("companyDisplayName-686915152")
654             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
655             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
656             .build();
657     mockService.addResponse(expectedResponse);
658 
659     Job job =
660         Job.newBuilder()
661             .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
662             .setCompany(
663                 CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
664                     .toString())
665             .setRequisitionId("requisitionId-1769495849")
666             .setTitle("title110371416")
667             .setDescription("description-1724546052")
668             .addAllAddresses(new ArrayList<String>())
669             .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
670             .addAllJobBenefits(new ArrayList<JobBenefit>())
671             .setCompensationInfo(CompensationInfo.newBuilder().build())
672             .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
673             .addAllDegreeTypes(new ArrayList<DegreeType>())
674             .setDepartment("department848184146")
675             .addAllEmploymentTypes(new ArrayList<EmploymentType>())
676             .setIncentives("incentives-1262874520")
677             .setLanguageCode("languageCode-2092349083")
678             .setJobLevel(JobLevel.forNumber(0))
679             .setPromotionValue(353413845)
680             .setQualifications("qualifications1903501412")
681             .setResponsibilities("responsibilities-926952660")
682             .setPostingRegion(PostingRegion.forNumber(0))
683             .setVisibility(Visibility.forNumber(0))
684             .setJobStartTime(Timestamp.newBuilder().build())
685             .setJobEndTime(Timestamp.newBuilder().build())
686             .setPostingPublishTime(Timestamp.newBuilder().build())
687             .setPostingExpireTime(Timestamp.newBuilder().build())
688             .setPostingCreateTime(Timestamp.newBuilder().build())
689             .setPostingUpdateTime(Timestamp.newBuilder().build())
690             .setCompanyDisplayName("companyDisplayName-686915152")
691             .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
692             .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
693             .build();
694 
695     Job actualResponse = client.updateJob(job);
696     Assert.assertEquals(expectedResponse, actualResponse);
697 
698     List<String> actualRequests = mockService.getRequestPaths();
699     Assert.assertEquals(1, actualRequests.size());
700 
701     String apiClientHeaderKey =
702         mockService
703             .getRequestHeaders()
704             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
705             .iterator()
706             .next();
707     Assert.assertTrue(
708         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
709             .matcher(apiClientHeaderKey)
710             .matches());
711   }
712 
713   @Test
updateJobExceptionTest()714   public void updateJobExceptionTest() throws Exception {
715     ApiException exception =
716         ApiExceptionFactory.createException(
717             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
718     mockService.addException(exception);
719 
720     try {
721       Job job =
722           Job.newBuilder()
723               .setName(JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]").toString())
724               .setCompany(
725                   CompanyName.ofProjectTenantCompanyName("[PROJECT]", "[TENANT]", "[COMPANY]")
726                       .toString())
727               .setRequisitionId("requisitionId-1769495849")
728               .setTitle("title110371416")
729               .setDescription("description-1724546052")
730               .addAllAddresses(new ArrayList<String>())
731               .setApplicationInfo(Job.ApplicationInfo.newBuilder().build())
732               .addAllJobBenefits(new ArrayList<JobBenefit>())
733               .setCompensationInfo(CompensationInfo.newBuilder().build())
734               .putAllCustomAttributes(new HashMap<String, CustomAttribute>())
735               .addAllDegreeTypes(new ArrayList<DegreeType>())
736               .setDepartment("department848184146")
737               .addAllEmploymentTypes(new ArrayList<EmploymentType>())
738               .setIncentives("incentives-1262874520")
739               .setLanguageCode("languageCode-2092349083")
740               .setJobLevel(JobLevel.forNumber(0))
741               .setPromotionValue(353413845)
742               .setQualifications("qualifications1903501412")
743               .setResponsibilities("responsibilities-926952660")
744               .setPostingRegion(PostingRegion.forNumber(0))
745               .setVisibility(Visibility.forNumber(0))
746               .setJobStartTime(Timestamp.newBuilder().build())
747               .setJobEndTime(Timestamp.newBuilder().build())
748               .setPostingPublishTime(Timestamp.newBuilder().build())
749               .setPostingExpireTime(Timestamp.newBuilder().build())
750               .setPostingCreateTime(Timestamp.newBuilder().build())
751               .setPostingUpdateTime(Timestamp.newBuilder().build())
752               .setCompanyDisplayName("companyDisplayName-686915152")
753               .setDerivedInfo(Job.DerivedInfo.newBuilder().build())
754               .setProcessingOptions(Job.ProcessingOptions.newBuilder().build())
755               .build();
756       client.updateJob(job);
757       Assert.fail("No exception raised");
758     } catch (InvalidArgumentException e) {
759       // Expected exception.
760     }
761   }
762 
763   @Test
batchUpdateJobsTest()764   public void batchUpdateJobsTest() throws Exception {
765     JobOperationResult expectedResponse =
766         JobOperationResult.newBuilder()
767             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
768             .build();
769     Operation resultOperation =
770         Operation.newBuilder()
771             .setName("batchUpdateJobsTest")
772             .setDone(true)
773             .setResponse(Any.pack(expectedResponse))
774             .build();
775     mockService.addResponse(resultOperation);
776 
777     ProjectName parent = ProjectName.of("[PROJECT]");
778     List<Job> jobs = new ArrayList<>();
779 
780     JobOperationResult actualResponse = client.batchUpdateJobsAsync(parent, jobs).get();
781     Assert.assertEquals(expectedResponse, actualResponse);
782 
783     List<String> actualRequests = mockService.getRequestPaths();
784     Assert.assertEquals(1, actualRequests.size());
785 
786     String apiClientHeaderKey =
787         mockService
788             .getRequestHeaders()
789             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
790             .iterator()
791             .next();
792     Assert.assertTrue(
793         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
794             .matcher(apiClientHeaderKey)
795             .matches());
796   }
797 
798   @Test
batchUpdateJobsExceptionTest()799   public void batchUpdateJobsExceptionTest() throws Exception {
800     ApiException exception =
801         ApiExceptionFactory.createException(
802             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
803     mockService.addException(exception);
804 
805     try {
806       ProjectName parent = ProjectName.of("[PROJECT]");
807       List<Job> jobs = new ArrayList<>();
808       client.batchUpdateJobsAsync(parent, jobs).get();
809       Assert.fail("No exception raised");
810     } catch (ExecutionException e) {
811     }
812   }
813 
814   @Test
batchUpdateJobsTest2()815   public void batchUpdateJobsTest2() throws Exception {
816     JobOperationResult expectedResponse =
817         JobOperationResult.newBuilder()
818             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
819             .build();
820     Operation resultOperation =
821         Operation.newBuilder()
822             .setName("batchUpdateJobsTest")
823             .setDone(true)
824             .setResponse(Any.pack(expectedResponse))
825             .build();
826     mockService.addResponse(resultOperation);
827 
828     TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
829     List<Job> jobs = new ArrayList<>();
830 
831     JobOperationResult actualResponse = client.batchUpdateJobsAsync(parent, jobs).get();
832     Assert.assertEquals(expectedResponse, actualResponse);
833 
834     List<String> actualRequests = mockService.getRequestPaths();
835     Assert.assertEquals(1, actualRequests.size());
836 
837     String apiClientHeaderKey =
838         mockService
839             .getRequestHeaders()
840             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
841             .iterator()
842             .next();
843     Assert.assertTrue(
844         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
845             .matcher(apiClientHeaderKey)
846             .matches());
847   }
848 
849   @Test
batchUpdateJobsExceptionTest2()850   public void batchUpdateJobsExceptionTest2() throws Exception {
851     ApiException exception =
852         ApiExceptionFactory.createException(
853             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
854     mockService.addException(exception);
855 
856     try {
857       TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
858       List<Job> jobs = new ArrayList<>();
859       client.batchUpdateJobsAsync(parent, jobs).get();
860       Assert.fail("No exception raised");
861     } catch (ExecutionException e) {
862     }
863   }
864 
865   @Test
batchUpdateJobsTest3()866   public void batchUpdateJobsTest3() throws Exception {
867     JobOperationResult expectedResponse =
868         JobOperationResult.newBuilder()
869             .addAllJobResults(new ArrayList<JobOperationResult.JobResult>())
870             .build();
871     Operation resultOperation =
872         Operation.newBuilder()
873             .setName("batchUpdateJobsTest")
874             .setDone(true)
875             .setResponse(Any.pack(expectedResponse))
876             .build();
877     mockService.addResponse(resultOperation);
878 
879     String parent = "projects/project-8940/tenants/tenant-8940";
880     List<Job> jobs = new ArrayList<>();
881 
882     JobOperationResult actualResponse = client.batchUpdateJobsAsync(parent, jobs).get();
883     Assert.assertEquals(expectedResponse, actualResponse);
884 
885     List<String> actualRequests = mockService.getRequestPaths();
886     Assert.assertEquals(1, actualRequests.size());
887 
888     String apiClientHeaderKey =
889         mockService
890             .getRequestHeaders()
891             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
892             .iterator()
893             .next();
894     Assert.assertTrue(
895         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
896             .matcher(apiClientHeaderKey)
897             .matches());
898   }
899 
900   @Test
batchUpdateJobsExceptionTest3()901   public void batchUpdateJobsExceptionTest3() throws Exception {
902     ApiException exception =
903         ApiExceptionFactory.createException(
904             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
905     mockService.addException(exception);
906 
907     try {
908       String parent = "projects/project-8940/tenants/tenant-8940";
909       List<Job> jobs = new ArrayList<>();
910       client.batchUpdateJobsAsync(parent, jobs).get();
911       Assert.fail("No exception raised");
912     } catch (ExecutionException e) {
913     }
914   }
915 
916   @Test
deleteJobTest()917   public void deleteJobTest() throws Exception {
918     Empty expectedResponse = Empty.newBuilder().build();
919     mockService.addResponse(expectedResponse);
920 
921     JobName name = JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]");
922 
923     client.deleteJob(name);
924 
925     List<String> actualRequests = mockService.getRequestPaths();
926     Assert.assertEquals(1, actualRequests.size());
927 
928     String apiClientHeaderKey =
929         mockService
930             .getRequestHeaders()
931             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
932             .iterator()
933             .next();
934     Assert.assertTrue(
935         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
936             .matcher(apiClientHeaderKey)
937             .matches());
938   }
939 
940   @Test
deleteJobExceptionTest()941   public void deleteJobExceptionTest() throws Exception {
942     ApiException exception =
943         ApiExceptionFactory.createException(
944             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
945     mockService.addException(exception);
946 
947     try {
948       JobName name = JobName.ofProjectTenantJobName("[PROJECT]", "[TENANT]", "[JOB]");
949       client.deleteJob(name);
950       Assert.fail("No exception raised");
951     } catch (InvalidArgumentException e) {
952       // Expected exception.
953     }
954   }
955 
956   @Test
deleteJobTest2()957   public void deleteJobTest2() throws Exception {
958     Empty expectedResponse = Empty.newBuilder().build();
959     mockService.addResponse(expectedResponse);
960 
961     String name = "projects/project-4373/tenants/tenant-4373/jobs/job-4373";
962 
963     client.deleteJob(name);
964 
965     List<String> actualRequests = mockService.getRequestPaths();
966     Assert.assertEquals(1, actualRequests.size());
967 
968     String apiClientHeaderKey =
969         mockService
970             .getRequestHeaders()
971             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
972             .iterator()
973             .next();
974     Assert.assertTrue(
975         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
976             .matcher(apiClientHeaderKey)
977             .matches());
978   }
979 
980   @Test
deleteJobExceptionTest2()981   public void deleteJobExceptionTest2() throws Exception {
982     ApiException exception =
983         ApiExceptionFactory.createException(
984             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
985     mockService.addException(exception);
986 
987     try {
988       String name = "projects/project-4373/tenants/tenant-4373/jobs/job-4373";
989       client.deleteJob(name);
990       Assert.fail("No exception raised");
991     } catch (InvalidArgumentException e) {
992       // Expected exception.
993     }
994   }
995 
996   @Test
batchDeleteJobsTest()997   public void batchDeleteJobsTest() throws Exception {
998     Empty expectedResponse = Empty.newBuilder().build();
999     mockService.addResponse(expectedResponse);
1000 
1001     ProjectName parent = ProjectName.of("[PROJECT]");
1002     String filter = "filter-1274492040";
1003 
1004     client.batchDeleteJobs(parent, filter);
1005 
1006     List<String> actualRequests = mockService.getRequestPaths();
1007     Assert.assertEquals(1, actualRequests.size());
1008 
1009     String apiClientHeaderKey =
1010         mockService
1011             .getRequestHeaders()
1012             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1013             .iterator()
1014             .next();
1015     Assert.assertTrue(
1016         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1017             .matcher(apiClientHeaderKey)
1018             .matches());
1019   }
1020 
1021   @Test
batchDeleteJobsExceptionTest()1022   public void batchDeleteJobsExceptionTest() throws Exception {
1023     ApiException exception =
1024         ApiExceptionFactory.createException(
1025             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1026     mockService.addException(exception);
1027 
1028     try {
1029       ProjectName parent = ProjectName.of("[PROJECT]");
1030       String filter = "filter-1274492040";
1031       client.batchDeleteJobs(parent, filter);
1032       Assert.fail("No exception raised");
1033     } catch (InvalidArgumentException e) {
1034       // Expected exception.
1035     }
1036   }
1037 
1038   @Test
batchDeleteJobsTest2()1039   public void batchDeleteJobsTest2() throws Exception {
1040     Empty expectedResponse = Empty.newBuilder().build();
1041     mockService.addResponse(expectedResponse);
1042 
1043     TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
1044     String filter = "filter-1274492040";
1045 
1046     client.batchDeleteJobs(parent, filter);
1047 
1048     List<String> actualRequests = mockService.getRequestPaths();
1049     Assert.assertEquals(1, actualRequests.size());
1050 
1051     String apiClientHeaderKey =
1052         mockService
1053             .getRequestHeaders()
1054             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1055             .iterator()
1056             .next();
1057     Assert.assertTrue(
1058         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1059             .matcher(apiClientHeaderKey)
1060             .matches());
1061   }
1062 
1063   @Test
batchDeleteJobsExceptionTest2()1064   public void batchDeleteJobsExceptionTest2() throws Exception {
1065     ApiException exception =
1066         ApiExceptionFactory.createException(
1067             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1068     mockService.addException(exception);
1069 
1070     try {
1071       TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
1072       String filter = "filter-1274492040";
1073       client.batchDeleteJobs(parent, filter);
1074       Assert.fail("No exception raised");
1075     } catch (InvalidArgumentException e) {
1076       // Expected exception.
1077     }
1078   }
1079 
1080   @Test
batchDeleteJobsTest3()1081   public void batchDeleteJobsTest3() throws Exception {
1082     Empty expectedResponse = Empty.newBuilder().build();
1083     mockService.addResponse(expectedResponse);
1084 
1085     String parent = "projects/project-8940/tenants/tenant-8940";
1086     String filter = "filter-1274492040";
1087 
1088     client.batchDeleteJobs(parent, filter);
1089 
1090     List<String> actualRequests = mockService.getRequestPaths();
1091     Assert.assertEquals(1, actualRequests.size());
1092 
1093     String apiClientHeaderKey =
1094         mockService
1095             .getRequestHeaders()
1096             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1097             .iterator()
1098             .next();
1099     Assert.assertTrue(
1100         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1101             .matcher(apiClientHeaderKey)
1102             .matches());
1103   }
1104 
1105   @Test
batchDeleteJobsExceptionTest3()1106   public void batchDeleteJobsExceptionTest3() throws Exception {
1107     ApiException exception =
1108         ApiExceptionFactory.createException(
1109             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1110     mockService.addException(exception);
1111 
1112     try {
1113       String parent = "projects/project-8940/tenants/tenant-8940";
1114       String filter = "filter-1274492040";
1115       client.batchDeleteJobs(parent, filter);
1116       Assert.fail("No exception raised");
1117     } catch (InvalidArgumentException e) {
1118       // Expected exception.
1119     }
1120   }
1121 
1122   @Test
listJobsTest()1123   public void listJobsTest() throws Exception {
1124     Job responsesElement = Job.newBuilder().build();
1125     ListJobsResponse expectedResponse =
1126         ListJobsResponse.newBuilder()
1127             .setNextPageToken("")
1128             .addAllJobs(Arrays.asList(responsesElement))
1129             .build();
1130     mockService.addResponse(expectedResponse);
1131 
1132     ProjectName parent = ProjectName.of("[PROJECT]");
1133     String filter = "filter-1274492040";
1134 
1135     ListJobsPagedResponse pagedListResponse = client.listJobs(parent, filter);
1136 
1137     List<Job> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1138 
1139     Assert.assertEquals(1, resources.size());
1140     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
1141 
1142     List<String> actualRequests = mockService.getRequestPaths();
1143     Assert.assertEquals(1, actualRequests.size());
1144 
1145     String apiClientHeaderKey =
1146         mockService
1147             .getRequestHeaders()
1148             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1149             .iterator()
1150             .next();
1151     Assert.assertTrue(
1152         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1153             .matcher(apiClientHeaderKey)
1154             .matches());
1155   }
1156 
1157   @Test
listJobsExceptionTest()1158   public void listJobsExceptionTest() throws Exception {
1159     ApiException exception =
1160         ApiExceptionFactory.createException(
1161             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1162     mockService.addException(exception);
1163 
1164     try {
1165       ProjectName parent = ProjectName.of("[PROJECT]");
1166       String filter = "filter-1274492040";
1167       client.listJobs(parent, filter);
1168       Assert.fail("No exception raised");
1169     } catch (InvalidArgumentException e) {
1170       // Expected exception.
1171     }
1172   }
1173 
1174   @Test
listJobsTest2()1175   public void listJobsTest2() throws Exception {
1176     Job responsesElement = Job.newBuilder().build();
1177     ListJobsResponse expectedResponse =
1178         ListJobsResponse.newBuilder()
1179             .setNextPageToken("")
1180             .addAllJobs(Arrays.asList(responsesElement))
1181             .build();
1182     mockService.addResponse(expectedResponse);
1183 
1184     TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
1185     String filter = "filter-1274492040";
1186 
1187     ListJobsPagedResponse pagedListResponse = client.listJobs(parent, filter);
1188 
1189     List<Job> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1190 
1191     Assert.assertEquals(1, resources.size());
1192     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
1193 
1194     List<String> actualRequests = mockService.getRequestPaths();
1195     Assert.assertEquals(1, actualRequests.size());
1196 
1197     String apiClientHeaderKey =
1198         mockService
1199             .getRequestHeaders()
1200             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1201             .iterator()
1202             .next();
1203     Assert.assertTrue(
1204         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1205             .matcher(apiClientHeaderKey)
1206             .matches());
1207   }
1208 
1209   @Test
listJobsExceptionTest2()1210   public void listJobsExceptionTest2() throws Exception {
1211     ApiException exception =
1212         ApiExceptionFactory.createException(
1213             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1214     mockService.addException(exception);
1215 
1216     try {
1217       TenantName parent = TenantName.of("[PROJECT]", "[TENANT]");
1218       String filter = "filter-1274492040";
1219       client.listJobs(parent, filter);
1220       Assert.fail("No exception raised");
1221     } catch (InvalidArgumentException e) {
1222       // Expected exception.
1223     }
1224   }
1225 
1226   @Test
listJobsTest3()1227   public void listJobsTest3() throws Exception {
1228     Job responsesElement = Job.newBuilder().build();
1229     ListJobsResponse expectedResponse =
1230         ListJobsResponse.newBuilder()
1231             .setNextPageToken("")
1232             .addAllJobs(Arrays.asList(responsesElement))
1233             .build();
1234     mockService.addResponse(expectedResponse);
1235 
1236     String parent = "projects/project-8940/tenants/tenant-8940";
1237     String filter = "filter-1274492040";
1238 
1239     ListJobsPagedResponse pagedListResponse = client.listJobs(parent, filter);
1240 
1241     List<Job> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1242 
1243     Assert.assertEquals(1, resources.size());
1244     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
1245 
1246     List<String> actualRequests = mockService.getRequestPaths();
1247     Assert.assertEquals(1, actualRequests.size());
1248 
1249     String apiClientHeaderKey =
1250         mockService
1251             .getRequestHeaders()
1252             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1253             .iterator()
1254             .next();
1255     Assert.assertTrue(
1256         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1257             .matcher(apiClientHeaderKey)
1258             .matches());
1259   }
1260 
1261   @Test
listJobsExceptionTest3()1262   public void listJobsExceptionTest3() throws Exception {
1263     ApiException exception =
1264         ApiExceptionFactory.createException(
1265             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1266     mockService.addException(exception);
1267 
1268     try {
1269       String parent = "projects/project-8940/tenants/tenant-8940";
1270       String filter = "filter-1274492040";
1271       client.listJobs(parent, filter);
1272       Assert.fail("No exception raised");
1273     } catch (InvalidArgumentException e) {
1274       // Expected exception.
1275     }
1276   }
1277 
1278   @Test
searchJobsTest()1279   public void searchJobsTest() throws Exception {
1280     SearchJobsResponse.MatchingJob responsesElement =
1281         SearchJobsResponse.MatchingJob.newBuilder().build();
1282     SearchJobsResponse expectedResponse =
1283         SearchJobsResponse.newBuilder()
1284             .setNextPageToken("")
1285             .addAllMatchingJobs(Arrays.asList(responsesElement))
1286             .build();
1287     mockService.addResponse(expectedResponse);
1288 
1289     SearchJobsRequest request =
1290         SearchJobsRequest.newBuilder()
1291             .setParent(TenantName.of("[PROJECT]", "[TENANT]").toString())
1292             .setRequestMetadata(RequestMetadata.newBuilder().build())
1293             .setJobQuery(JobQuery.newBuilder().build())
1294             .setEnableBroadening(true)
1295             .setRequirePreciseResultSize(true)
1296             .addAllHistogramQueries(new ArrayList<HistogramQuery>())
1297             .setJobView(JobView.forNumber(0))
1298             .setOffset(-1019779949)
1299             .setPageSize(883849137)
1300             .setPageToken("pageToken873572522")
1301             .setOrderBy("orderBy-1207110587")
1302             .setCustomRankingInfo(SearchJobsRequest.CustomRankingInfo.newBuilder().build())
1303             .setDisableKeywordMatch(true)
1304             .build();
1305 
1306     SearchJobsPagedResponse pagedListResponse = client.searchJobs(request);
1307 
1308     List<SearchJobsResponse.MatchingJob> resources =
1309         Lists.newArrayList(pagedListResponse.iterateAll());
1310 
1311     Assert.assertEquals(1, resources.size());
1312     Assert.assertEquals(expectedResponse.getMatchingJobsList().get(0), resources.get(0));
1313 
1314     List<String> actualRequests = mockService.getRequestPaths();
1315     Assert.assertEquals(1, actualRequests.size());
1316 
1317     String apiClientHeaderKey =
1318         mockService
1319             .getRequestHeaders()
1320             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1321             .iterator()
1322             .next();
1323     Assert.assertTrue(
1324         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1325             .matcher(apiClientHeaderKey)
1326             .matches());
1327   }
1328 
1329   @Test
searchJobsExceptionTest()1330   public void searchJobsExceptionTest() throws Exception {
1331     ApiException exception =
1332         ApiExceptionFactory.createException(
1333             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1334     mockService.addException(exception);
1335 
1336     try {
1337       SearchJobsRequest request =
1338           SearchJobsRequest.newBuilder()
1339               .setParent(TenantName.of("[PROJECT]", "[TENANT]").toString())
1340               .setRequestMetadata(RequestMetadata.newBuilder().build())
1341               .setJobQuery(JobQuery.newBuilder().build())
1342               .setEnableBroadening(true)
1343               .setRequirePreciseResultSize(true)
1344               .addAllHistogramQueries(new ArrayList<HistogramQuery>())
1345               .setJobView(JobView.forNumber(0))
1346               .setOffset(-1019779949)
1347               .setPageSize(883849137)
1348               .setPageToken("pageToken873572522")
1349               .setOrderBy("orderBy-1207110587")
1350               .setCustomRankingInfo(SearchJobsRequest.CustomRankingInfo.newBuilder().build())
1351               .setDisableKeywordMatch(true)
1352               .build();
1353       client.searchJobs(request);
1354       Assert.fail("No exception raised");
1355     } catch (InvalidArgumentException e) {
1356       // Expected exception.
1357     }
1358   }
1359 
1360   @Test
searchJobsForAlertTest()1361   public void searchJobsForAlertTest() throws Exception {
1362     SearchJobsResponse.MatchingJob responsesElement =
1363         SearchJobsResponse.MatchingJob.newBuilder().build();
1364     SearchJobsResponse expectedResponse =
1365         SearchJobsResponse.newBuilder()
1366             .setNextPageToken("")
1367             .addAllMatchingJobs(Arrays.asList(responsesElement))
1368             .build();
1369     mockService.addResponse(expectedResponse);
1370 
1371     SearchJobsRequest request =
1372         SearchJobsRequest.newBuilder()
1373             .setParent(TenantName.of("[PROJECT]", "[TENANT]").toString())
1374             .setRequestMetadata(RequestMetadata.newBuilder().build())
1375             .setJobQuery(JobQuery.newBuilder().build())
1376             .setEnableBroadening(true)
1377             .setRequirePreciseResultSize(true)
1378             .addAllHistogramQueries(new ArrayList<HistogramQuery>())
1379             .setJobView(JobView.forNumber(0))
1380             .setOffset(-1019779949)
1381             .setPageSize(883849137)
1382             .setPageToken("pageToken873572522")
1383             .setOrderBy("orderBy-1207110587")
1384             .setCustomRankingInfo(SearchJobsRequest.CustomRankingInfo.newBuilder().build())
1385             .setDisableKeywordMatch(true)
1386             .build();
1387 
1388     SearchJobsForAlertPagedResponse pagedListResponse = client.searchJobsForAlert(request);
1389 
1390     List<SearchJobsResponse.MatchingJob> resources =
1391         Lists.newArrayList(pagedListResponse.iterateAll());
1392 
1393     Assert.assertEquals(1, resources.size());
1394     Assert.assertEquals(expectedResponse.getMatchingJobsList().get(0), resources.get(0));
1395 
1396     List<String> actualRequests = mockService.getRequestPaths();
1397     Assert.assertEquals(1, actualRequests.size());
1398 
1399     String apiClientHeaderKey =
1400         mockService
1401             .getRequestHeaders()
1402             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1403             .iterator()
1404             .next();
1405     Assert.assertTrue(
1406         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1407             .matcher(apiClientHeaderKey)
1408             .matches());
1409   }
1410 
1411   @Test
searchJobsForAlertExceptionTest()1412   public void searchJobsForAlertExceptionTest() throws Exception {
1413     ApiException exception =
1414         ApiExceptionFactory.createException(
1415             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1416     mockService.addException(exception);
1417 
1418     try {
1419       SearchJobsRequest request =
1420           SearchJobsRequest.newBuilder()
1421               .setParent(TenantName.of("[PROJECT]", "[TENANT]").toString())
1422               .setRequestMetadata(RequestMetadata.newBuilder().build())
1423               .setJobQuery(JobQuery.newBuilder().build())
1424               .setEnableBroadening(true)
1425               .setRequirePreciseResultSize(true)
1426               .addAllHistogramQueries(new ArrayList<HistogramQuery>())
1427               .setJobView(JobView.forNumber(0))
1428               .setOffset(-1019779949)
1429               .setPageSize(883849137)
1430               .setPageToken("pageToken873572522")
1431               .setOrderBy("orderBy-1207110587")
1432               .setCustomRankingInfo(SearchJobsRequest.CustomRankingInfo.newBuilder().build())
1433               .setDisableKeywordMatch(true)
1434               .build();
1435       client.searchJobsForAlert(request);
1436       Assert.fail("No exception raised");
1437     } catch (InvalidArgumentException e) {
1438       // Expected exception.
1439     }
1440   }
1441 }
1442