• 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.documentai.v1;
18 
19 import static com.google.cloud.documentai.v1.DocumentProcessorServiceClient.ListEvaluationsPagedResponse;
20 import static com.google.cloud.documentai.v1.DocumentProcessorServiceClient.ListLocationsPagedResponse;
21 import static com.google.cloud.documentai.v1.DocumentProcessorServiceClient.ListProcessorTypesPagedResponse;
22 import static com.google.cloud.documentai.v1.DocumentProcessorServiceClient.ListProcessorVersionsPagedResponse;
23 import static com.google.cloud.documentai.v1.DocumentProcessorServiceClient.ListProcessorsPagedResponse;
24 
25 import com.google.api.LaunchStage;
26 import com.google.api.gax.core.NoCredentialsProvider;
27 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
28 import com.google.api.gax.httpjson.testing.MockHttpService;
29 import com.google.api.gax.rpc.ApiClientHeaderProvider;
30 import com.google.api.gax.rpc.ApiException;
31 import com.google.api.gax.rpc.ApiExceptionFactory;
32 import com.google.api.gax.rpc.InvalidArgumentException;
33 import com.google.api.gax.rpc.StatusCode;
34 import com.google.api.gax.rpc.testing.FakeStatusCode;
35 import com.google.api.resourcenames.ResourceName;
36 import com.google.cloud.documentai.v1.stub.HttpJsonDocumentProcessorServiceStub;
37 import com.google.cloud.location.GetLocationRequest;
38 import com.google.cloud.location.ListLocationsRequest;
39 import com.google.cloud.location.ListLocationsResponse;
40 import com.google.cloud.location.Location;
41 import com.google.common.collect.Lists;
42 import com.google.longrunning.Operation;
43 import com.google.protobuf.Any;
44 import com.google.protobuf.Empty;
45 import com.google.protobuf.Timestamp;
46 import java.io.IOException;
47 import java.util.ArrayList;
48 import java.util.Arrays;
49 import java.util.HashMap;
50 import java.util.List;
51 import java.util.concurrent.ExecutionException;
52 import javax.annotation.Generated;
53 import org.junit.After;
54 import org.junit.AfterClass;
55 import org.junit.Assert;
56 import org.junit.Before;
57 import org.junit.BeforeClass;
58 import org.junit.Test;
59 
60 @Generated("by gapic-generator-java")
61 public class DocumentProcessorServiceClientHttpJsonTest {
62   private static MockHttpService mockService;
63   private static DocumentProcessorServiceClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() throws IOException {
67     mockService =
68         new MockHttpService(
69             HttpJsonDocumentProcessorServiceStub.getMethodDescriptors(),
70             DocumentProcessorServiceSettings.getDefaultEndpoint());
71     DocumentProcessorServiceSettings settings =
72         DocumentProcessorServiceSettings.newHttpJsonBuilder()
73             .setTransportChannelProvider(
74                 DocumentProcessorServiceSettings.defaultHttpJsonTransportProviderBuilder()
75                     .setHttpTransport(mockService)
76                     .build())
77             .setCredentialsProvider(NoCredentialsProvider.create())
78             .build();
79     client = DocumentProcessorServiceClient.create(settings);
80   }
81 
82   @AfterClass
stopServer()83   public static void stopServer() {
84     client.close();
85   }
86 
87   @Before
setUp()88   public void setUp() {}
89 
90   @After
tearDown()91   public void tearDown() throws Exception {
92     mockService.reset();
93   }
94 
95   @Test
processDocumentTest()96   public void processDocumentTest() throws Exception {
97     ProcessResponse expectedResponse =
98         ProcessResponse.newBuilder()
99             .setDocument(Document.newBuilder().build())
100             .setHumanReviewStatus(HumanReviewStatus.newBuilder().build())
101             .build();
102     mockService.addResponse(expectedResponse);
103 
104     ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
105 
106     ProcessResponse actualResponse = client.processDocument(name);
107     Assert.assertEquals(expectedResponse, actualResponse);
108 
109     List<String> actualRequests = mockService.getRequestPaths();
110     Assert.assertEquals(1, actualRequests.size());
111 
112     String apiClientHeaderKey =
113         mockService
114             .getRequestHeaders()
115             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
116             .iterator()
117             .next();
118     Assert.assertTrue(
119         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
120             .matcher(apiClientHeaderKey)
121             .matches());
122   }
123 
124   @Test
processDocumentExceptionTest()125   public void processDocumentExceptionTest() throws Exception {
126     ApiException exception =
127         ApiExceptionFactory.createException(
128             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
129     mockService.addException(exception);
130 
131     try {
132       ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
133       client.processDocument(name);
134       Assert.fail("No exception raised");
135     } catch (InvalidArgumentException e) {
136       // Expected exception.
137     }
138   }
139 
140   @Test
processDocumentTest2()141   public void processDocumentTest2() throws Exception {
142     ProcessResponse expectedResponse =
143         ProcessResponse.newBuilder()
144             .setDocument(Document.newBuilder().build())
145             .setHumanReviewStatus(HumanReviewStatus.newBuilder().build())
146             .build();
147     mockService.addResponse(expectedResponse);
148 
149     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
150 
151     ProcessResponse actualResponse = client.processDocument(name);
152     Assert.assertEquals(expectedResponse, actualResponse);
153 
154     List<String> actualRequests = mockService.getRequestPaths();
155     Assert.assertEquals(1, actualRequests.size());
156 
157     String apiClientHeaderKey =
158         mockService
159             .getRequestHeaders()
160             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
161             .iterator()
162             .next();
163     Assert.assertTrue(
164         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
165             .matcher(apiClientHeaderKey)
166             .matches());
167   }
168 
169   @Test
processDocumentExceptionTest2()170   public void processDocumentExceptionTest2() throws Exception {
171     ApiException exception =
172         ApiExceptionFactory.createException(
173             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
174     mockService.addException(exception);
175 
176     try {
177       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
178       client.processDocument(name);
179       Assert.fail("No exception raised");
180     } catch (InvalidArgumentException e) {
181       // Expected exception.
182     }
183   }
184 
185   @Test
batchProcessDocumentsTest()186   public void batchProcessDocumentsTest() throws Exception {
187     BatchProcessResponse expectedResponse = BatchProcessResponse.newBuilder().build();
188     Operation resultOperation =
189         Operation.newBuilder()
190             .setName("batchProcessDocumentsTest")
191             .setDone(true)
192             .setResponse(Any.pack(expectedResponse))
193             .build();
194     mockService.addResponse(resultOperation);
195 
196     ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
197 
198     BatchProcessResponse actualResponse = client.batchProcessDocumentsAsync(name).get();
199     Assert.assertEquals(expectedResponse, actualResponse);
200 
201     List<String> actualRequests = mockService.getRequestPaths();
202     Assert.assertEquals(1, actualRequests.size());
203 
204     String apiClientHeaderKey =
205         mockService
206             .getRequestHeaders()
207             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
208             .iterator()
209             .next();
210     Assert.assertTrue(
211         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
212             .matcher(apiClientHeaderKey)
213             .matches());
214   }
215 
216   @Test
batchProcessDocumentsExceptionTest()217   public void batchProcessDocumentsExceptionTest() throws Exception {
218     ApiException exception =
219         ApiExceptionFactory.createException(
220             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
221     mockService.addException(exception);
222 
223     try {
224       ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
225       client.batchProcessDocumentsAsync(name).get();
226       Assert.fail("No exception raised");
227     } catch (ExecutionException e) {
228     }
229   }
230 
231   @Test
batchProcessDocumentsTest2()232   public void batchProcessDocumentsTest2() throws Exception {
233     BatchProcessResponse expectedResponse = BatchProcessResponse.newBuilder().build();
234     Operation resultOperation =
235         Operation.newBuilder()
236             .setName("batchProcessDocumentsTest")
237             .setDone(true)
238             .setResponse(Any.pack(expectedResponse))
239             .build();
240     mockService.addResponse(resultOperation);
241 
242     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
243 
244     BatchProcessResponse actualResponse = client.batchProcessDocumentsAsync(name).get();
245     Assert.assertEquals(expectedResponse, actualResponse);
246 
247     List<String> actualRequests = mockService.getRequestPaths();
248     Assert.assertEquals(1, actualRequests.size());
249 
250     String apiClientHeaderKey =
251         mockService
252             .getRequestHeaders()
253             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
254             .iterator()
255             .next();
256     Assert.assertTrue(
257         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
258             .matcher(apiClientHeaderKey)
259             .matches());
260   }
261 
262   @Test
batchProcessDocumentsExceptionTest2()263   public void batchProcessDocumentsExceptionTest2() throws Exception {
264     ApiException exception =
265         ApiExceptionFactory.createException(
266             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
267     mockService.addException(exception);
268 
269     try {
270       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
271       client.batchProcessDocumentsAsync(name).get();
272       Assert.fail("No exception raised");
273     } catch (ExecutionException e) {
274     }
275   }
276 
277   @Test
fetchProcessorTypesTest()278   public void fetchProcessorTypesTest() throws Exception {
279     FetchProcessorTypesResponse expectedResponse =
280         FetchProcessorTypesResponse.newBuilder()
281             .addAllProcessorTypes(new ArrayList<ProcessorType>())
282             .build();
283     mockService.addResponse(expectedResponse);
284 
285     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
286 
287     FetchProcessorTypesResponse actualResponse = client.fetchProcessorTypes(parent);
288     Assert.assertEquals(expectedResponse, actualResponse);
289 
290     List<String> actualRequests = mockService.getRequestPaths();
291     Assert.assertEquals(1, actualRequests.size());
292 
293     String apiClientHeaderKey =
294         mockService
295             .getRequestHeaders()
296             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
297             .iterator()
298             .next();
299     Assert.assertTrue(
300         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
301             .matcher(apiClientHeaderKey)
302             .matches());
303   }
304 
305   @Test
fetchProcessorTypesExceptionTest()306   public void fetchProcessorTypesExceptionTest() throws Exception {
307     ApiException exception =
308         ApiExceptionFactory.createException(
309             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
310     mockService.addException(exception);
311 
312     try {
313       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
314       client.fetchProcessorTypes(parent);
315       Assert.fail("No exception raised");
316     } catch (InvalidArgumentException e) {
317       // Expected exception.
318     }
319   }
320 
321   @Test
fetchProcessorTypesTest2()322   public void fetchProcessorTypesTest2() throws Exception {
323     FetchProcessorTypesResponse expectedResponse =
324         FetchProcessorTypesResponse.newBuilder()
325             .addAllProcessorTypes(new ArrayList<ProcessorType>())
326             .build();
327     mockService.addResponse(expectedResponse);
328 
329     String parent = "projects/project-5833/locations/location-5833";
330 
331     FetchProcessorTypesResponse actualResponse = client.fetchProcessorTypes(parent);
332     Assert.assertEquals(expectedResponse, actualResponse);
333 
334     List<String> actualRequests = mockService.getRequestPaths();
335     Assert.assertEquals(1, actualRequests.size());
336 
337     String apiClientHeaderKey =
338         mockService
339             .getRequestHeaders()
340             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
341             .iterator()
342             .next();
343     Assert.assertTrue(
344         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
345             .matcher(apiClientHeaderKey)
346             .matches());
347   }
348 
349   @Test
fetchProcessorTypesExceptionTest2()350   public void fetchProcessorTypesExceptionTest2() throws Exception {
351     ApiException exception =
352         ApiExceptionFactory.createException(
353             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
354     mockService.addException(exception);
355 
356     try {
357       String parent = "projects/project-5833/locations/location-5833";
358       client.fetchProcessorTypes(parent);
359       Assert.fail("No exception raised");
360     } catch (InvalidArgumentException e) {
361       // Expected exception.
362     }
363   }
364 
365   @Test
listProcessorTypesTest()366   public void listProcessorTypesTest() throws Exception {
367     ProcessorType responsesElement = ProcessorType.newBuilder().build();
368     ListProcessorTypesResponse expectedResponse =
369         ListProcessorTypesResponse.newBuilder()
370             .setNextPageToken("")
371             .addAllProcessorTypes(Arrays.asList(responsesElement))
372             .build();
373     mockService.addResponse(expectedResponse);
374 
375     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
376 
377     ListProcessorTypesPagedResponse pagedListResponse = client.listProcessorTypes(parent);
378 
379     List<ProcessorType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
380 
381     Assert.assertEquals(1, resources.size());
382     Assert.assertEquals(expectedResponse.getProcessorTypesList().get(0), resources.get(0));
383 
384     List<String> actualRequests = mockService.getRequestPaths();
385     Assert.assertEquals(1, actualRequests.size());
386 
387     String apiClientHeaderKey =
388         mockService
389             .getRequestHeaders()
390             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
391             .iterator()
392             .next();
393     Assert.assertTrue(
394         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
395             .matcher(apiClientHeaderKey)
396             .matches());
397   }
398 
399   @Test
listProcessorTypesExceptionTest()400   public void listProcessorTypesExceptionTest() throws Exception {
401     ApiException exception =
402         ApiExceptionFactory.createException(
403             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
404     mockService.addException(exception);
405 
406     try {
407       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
408       client.listProcessorTypes(parent);
409       Assert.fail("No exception raised");
410     } catch (InvalidArgumentException e) {
411       // Expected exception.
412     }
413   }
414 
415   @Test
listProcessorTypesTest2()416   public void listProcessorTypesTest2() throws Exception {
417     ProcessorType responsesElement = ProcessorType.newBuilder().build();
418     ListProcessorTypesResponse expectedResponse =
419         ListProcessorTypesResponse.newBuilder()
420             .setNextPageToken("")
421             .addAllProcessorTypes(Arrays.asList(responsesElement))
422             .build();
423     mockService.addResponse(expectedResponse);
424 
425     String parent = "projects/project-5833/locations/location-5833";
426 
427     ListProcessorTypesPagedResponse pagedListResponse = client.listProcessorTypes(parent);
428 
429     List<ProcessorType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
430 
431     Assert.assertEquals(1, resources.size());
432     Assert.assertEquals(expectedResponse.getProcessorTypesList().get(0), resources.get(0));
433 
434     List<String> actualRequests = mockService.getRequestPaths();
435     Assert.assertEquals(1, actualRequests.size());
436 
437     String apiClientHeaderKey =
438         mockService
439             .getRequestHeaders()
440             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
441             .iterator()
442             .next();
443     Assert.assertTrue(
444         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
445             .matcher(apiClientHeaderKey)
446             .matches());
447   }
448 
449   @Test
listProcessorTypesExceptionTest2()450   public void listProcessorTypesExceptionTest2() throws Exception {
451     ApiException exception =
452         ApiExceptionFactory.createException(
453             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
454     mockService.addException(exception);
455 
456     try {
457       String parent = "projects/project-5833/locations/location-5833";
458       client.listProcessorTypes(parent);
459       Assert.fail("No exception raised");
460     } catch (InvalidArgumentException e) {
461       // Expected exception.
462     }
463   }
464 
465   @Test
getProcessorTypeTest()466   public void getProcessorTypeTest() throws Exception {
467     ProcessorType expectedResponse =
468         ProcessorType.newBuilder()
469             .setName(ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]").toString())
470             .setType("type3575610")
471             .setCategory("category50511102")
472             .addAllAvailableLocations(new ArrayList<ProcessorType.LocationInfo>())
473             .setAllowCreation(true)
474             .setLaunchStage(LaunchStage.forNumber(0))
475             .addAllSampleDocumentUris(new ArrayList<String>())
476             .build();
477     mockService.addResponse(expectedResponse);
478 
479     ProcessorTypeName name = ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]");
480 
481     ProcessorType actualResponse = client.getProcessorType(name);
482     Assert.assertEquals(expectedResponse, actualResponse);
483 
484     List<String> actualRequests = mockService.getRequestPaths();
485     Assert.assertEquals(1, actualRequests.size());
486 
487     String apiClientHeaderKey =
488         mockService
489             .getRequestHeaders()
490             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
491             .iterator()
492             .next();
493     Assert.assertTrue(
494         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
495             .matcher(apiClientHeaderKey)
496             .matches());
497   }
498 
499   @Test
getProcessorTypeExceptionTest()500   public void getProcessorTypeExceptionTest() throws Exception {
501     ApiException exception =
502         ApiExceptionFactory.createException(
503             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
504     mockService.addException(exception);
505 
506     try {
507       ProcessorTypeName name = ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]");
508       client.getProcessorType(name);
509       Assert.fail("No exception raised");
510     } catch (InvalidArgumentException e) {
511       // Expected exception.
512     }
513   }
514 
515   @Test
getProcessorTypeTest2()516   public void getProcessorTypeTest2() throws Exception {
517     ProcessorType expectedResponse =
518         ProcessorType.newBuilder()
519             .setName(ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]").toString())
520             .setType("type3575610")
521             .setCategory("category50511102")
522             .addAllAvailableLocations(new ArrayList<ProcessorType.LocationInfo>())
523             .setAllowCreation(true)
524             .setLaunchStage(LaunchStage.forNumber(0))
525             .addAllSampleDocumentUris(new ArrayList<String>())
526             .build();
527     mockService.addResponse(expectedResponse);
528 
529     String name = "projects/project-6471/locations/location-6471/processorTypes/processorType-6471";
530 
531     ProcessorType actualResponse = client.getProcessorType(name);
532     Assert.assertEquals(expectedResponse, actualResponse);
533 
534     List<String> actualRequests = mockService.getRequestPaths();
535     Assert.assertEquals(1, actualRequests.size());
536 
537     String apiClientHeaderKey =
538         mockService
539             .getRequestHeaders()
540             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
541             .iterator()
542             .next();
543     Assert.assertTrue(
544         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
545             .matcher(apiClientHeaderKey)
546             .matches());
547   }
548 
549   @Test
getProcessorTypeExceptionTest2()550   public void getProcessorTypeExceptionTest2() throws Exception {
551     ApiException exception =
552         ApiExceptionFactory.createException(
553             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
554     mockService.addException(exception);
555 
556     try {
557       String name =
558           "projects/project-6471/locations/location-6471/processorTypes/processorType-6471";
559       client.getProcessorType(name);
560       Assert.fail("No exception raised");
561     } catch (InvalidArgumentException e) {
562       // Expected exception.
563     }
564   }
565 
566   @Test
listProcessorsTest()567   public void listProcessorsTest() throws Exception {
568     Processor responsesElement = Processor.newBuilder().build();
569     ListProcessorsResponse expectedResponse =
570         ListProcessorsResponse.newBuilder()
571             .setNextPageToken("")
572             .addAllProcessors(Arrays.asList(responsesElement))
573             .build();
574     mockService.addResponse(expectedResponse);
575 
576     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
577 
578     ListProcessorsPagedResponse pagedListResponse = client.listProcessors(parent);
579 
580     List<Processor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
581 
582     Assert.assertEquals(1, resources.size());
583     Assert.assertEquals(expectedResponse.getProcessorsList().get(0), resources.get(0));
584 
585     List<String> actualRequests = mockService.getRequestPaths();
586     Assert.assertEquals(1, actualRequests.size());
587 
588     String apiClientHeaderKey =
589         mockService
590             .getRequestHeaders()
591             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
592             .iterator()
593             .next();
594     Assert.assertTrue(
595         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
596             .matcher(apiClientHeaderKey)
597             .matches());
598   }
599 
600   @Test
listProcessorsExceptionTest()601   public void listProcessorsExceptionTest() throws Exception {
602     ApiException exception =
603         ApiExceptionFactory.createException(
604             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
605     mockService.addException(exception);
606 
607     try {
608       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
609       client.listProcessors(parent);
610       Assert.fail("No exception raised");
611     } catch (InvalidArgumentException e) {
612       // Expected exception.
613     }
614   }
615 
616   @Test
listProcessorsTest2()617   public void listProcessorsTest2() throws Exception {
618     Processor responsesElement = Processor.newBuilder().build();
619     ListProcessorsResponse expectedResponse =
620         ListProcessorsResponse.newBuilder()
621             .setNextPageToken("")
622             .addAllProcessors(Arrays.asList(responsesElement))
623             .build();
624     mockService.addResponse(expectedResponse);
625 
626     String parent = "projects/project-5833/locations/location-5833";
627 
628     ListProcessorsPagedResponse pagedListResponse = client.listProcessors(parent);
629 
630     List<Processor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
631 
632     Assert.assertEquals(1, resources.size());
633     Assert.assertEquals(expectedResponse.getProcessorsList().get(0), resources.get(0));
634 
635     List<String> actualRequests = mockService.getRequestPaths();
636     Assert.assertEquals(1, actualRequests.size());
637 
638     String apiClientHeaderKey =
639         mockService
640             .getRequestHeaders()
641             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
642             .iterator()
643             .next();
644     Assert.assertTrue(
645         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
646             .matcher(apiClientHeaderKey)
647             .matches());
648   }
649 
650   @Test
listProcessorsExceptionTest2()651   public void listProcessorsExceptionTest2() throws Exception {
652     ApiException exception =
653         ApiExceptionFactory.createException(
654             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
655     mockService.addException(exception);
656 
657     try {
658       String parent = "projects/project-5833/locations/location-5833";
659       client.listProcessors(parent);
660       Assert.fail("No exception raised");
661     } catch (InvalidArgumentException e) {
662       // Expected exception.
663     }
664   }
665 
666   @Test
getProcessorTest()667   public void getProcessorTest() throws Exception {
668     Processor expectedResponse =
669         Processor.newBuilder()
670             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
671             .setType("type3575610")
672             .setDisplayName("displayName1714148973")
673             .setDefaultProcessorVersion(
674                 ProcessorVersionName.of(
675                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
676                     .toString())
677             .setProcessEndpoint("processEndpoint-891502300")
678             .setCreateTime(Timestamp.newBuilder().build())
679             .setKmsKeyName("kmsKeyName412586233")
680             .build();
681     mockService.addResponse(expectedResponse);
682 
683     ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
684 
685     Processor actualResponse = client.getProcessor(name);
686     Assert.assertEquals(expectedResponse, actualResponse);
687 
688     List<String> actualRequests = mockService.getRequestPaths();
689     Assert.assertEquals(1, actualRequests.size());
690 
691     String apiClientHeaderKey =
692         mockService
693             .getRequestHeaders()
694             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
695             .iterator()
696             .next();
697     Assert.assertTrue(
698         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
699             .matcher(apiClientHeaderKey)
700             .matches());
701   }
702 
703   @Test
getProcessorExceptionTest()704   public void getProcessorExceptionTest() throws Exception {
705     ApiException exception =
706         ApiExceptionFactory.createException(
707             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
708     mockService.addException(exception);
709 
710     try {
711       ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
712       client.getProcessor(name);
713       Assert.fail("No exception raised");
714     } catch (InvalidArgumentException e) {
715       // Expected exception.
716     }
717   }
718 
719   @Test
getProcessorTest2()720   public void getProcessorTest2() throws Exception {
721     Processor expectedResponse =
722         Processor.newBuilder()
723             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
724             .setType("type3575610")
725             .setDisplayName("displayName1714148973")
726             .setDefaultProcessorVersion(
727                 ProcessorVersionName.of(
728                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
729                     .toString())
730             .setProcessEndpoint("processEndpoint-891502300")
731             .setCreateTime(Timestamp.newBuilder().build())
732             .setKmsKeyName("kmsKeyName412586233")
733             .build();
734     mockService.addResponse(expectedResponse);
735 
736     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
737 
738     Processor actualResponse = client.getProcessor(name);
739     Assert.assertEquals(expectedResponse, actualResponse);
740 
741     List<String> actualRequests = mockService.getRequestPaths();
742     Assert.assertEquals(1, actualRequests.size());
743 
744     String apiClientHeaderKey =
745         mockService
746             .getRequestHeaders()
747             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
748             .iterator()
749             .next();
750     Assert.assertTrue(
751         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
752             .matcher(apiClientHeaderKey)
753             .matches());
754   }
755 
756   @Test
getProcessorExceptionTest2()757   public void getProcessorExceptionTest2() throws Exception {
758     ApiException exception =
759         ApiExceptionFactory.createException(
760             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
761     mockService.addException(exception);
762 
763     try {
764       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
765       client.getProcessor(name);
766       Assert.fail("No exception raised");
767     } catch (InvalidArgumentException e) {
768       // Expected exception.
769     }
770   }
771 
772   @Test
trainProcessorVersionTest()773   public void trainProcessorVersionTest() throws Exception {
774     TrainProcessorVersionResponse expectedResponse =
775         TrainProcessorVersionResponse.newBuilder()
776             .setProcessorVersion("processorVersion-1941143578")
777             .build();
778     Operation resultOperation =
779         Operation.newBuilder()
780             .setName("trainProcessorVersionTest")
781             .setDone(true)
782             .setResponse(Any.pack(expectedResponse))
783             .build();
784     mockService.addResponse(resultOperation);
785 
786     ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
787     ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
788 
789     TrainProcessorVersionResponse actualResponse =
790         client.trainProcessorVersionAsync(parent, processorVersion).get();
791     Assert.assertEquals(expectedResponse, actualResponse);
792 
793     List<String> actualRequests = mockService.getRequestPaths();
794     Assert.assertEquals(1, actualRequests.size());
795 
796     String apiClientHeaderKey =
797         mockService
798             .getRequestHeaders()
799             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
800             .iterator()
801             .next();
802     Assert.assertTrue(
803         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
804             .matcher(apiClientHeaderKey)
805             .matches());
806   }
807 
808   @Test
trainProcessorVersionExceptionTest()809   public void trainProcessorVersionExceptionTest() throws Exception {
810     ApiException exception =
811         ApiExceptionFactory.createException(
812             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
813     mockService.addException(exception);
814 
815     try {
816       ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
817       ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
818       client.trainProcessorVersionAsync(parent, processorVersion).get();
819       Assert.fail("No exception raised");
820     } catch (ExecutionException e) {
821     }
822   }
823 
824   @Test
trainProcessorVersionTest2()825   public void trainProcessorVersionTest2() throws Exception {
826     TrainProcessorVersionResponse expectedResponse =
827         TrainProcessorVersionResponse.newBuilder()
828             .setProcessorVersion("processorVersion-1941143578")
829             .build();
830     Operation resultOperation =
831         Operation.newBuilder()
832             .setName("trainProcessorVersionTest")
833             .setDone(true)
834             .setResponse(Any.pack(expectedResponse))
835             .build();
836     mockService.addResponse(resultOperation);
837 
838     String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
839     ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
840 
841     TrainProcessorVersionResponse actualResponse =
842         client.trainProcessorVersionAsync(parent, processorVersion).get();
843     Assert.assertEquals(expectedResponse, actualResponse);
844 
845     List<String> actualRequests = mockService.getRequestPaths();
846     Assert.assertEquals(1, actualRequests.size());
847 
848     String apiClientHeaderKey =
849         mockService
850             .getRequestHeaders()
851             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
852             .iterator()
853             .next();
854     Assert.assertTrue(
855         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
856             .matcher(apiClientHeaderKey)
857             .matches());
858   }
859 
860   @Test
trainProcessorVersionExceptionTest2()861   public void trainProcessorVersionExceptionTest2() throws Exception {
862     ApiException exception =
863         ApiExceptionFactory.createException(
864             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
865     mockService.addException(exception);
866 
867     try {
868       String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
869       ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
870       client.trainProcessorVersionAsync(parent, processorVersion).get();
871       Assert.fail("No exception raised");
872     } catch (ExecutionException e) {
873     }
874   }
875 
876   @Test
getProcessorVersionTest()877   public void getProcessorVersionTest() throws Exception {
878     ProcessorVersion expectedResponse =
879         ProcessorVersion.newBuilder()
880             .setName(
881                 ProcessorVersionName.of(
882                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
883                     .toString())
884             .setDisplayName("displayName1714148973")
885             .setDocumentSchema(DocumentSchema.newBuilder().build())
886             .setCreateTime(Timestamp.newBuilder().build())
887             .setLatestEvaluation(EvaluationReference.newBuilder().build())
888             .setKmsKeyName("kmsKeyName412586233")
889             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
890             .setGoogleManaged(true)
891             .setDeprecationInfo(ProcessorVersion.DeprecationInfo.newBuilder().build())
892             .build();
893     mockService.addResponse(expectedResponse);
894 
895     ProcessorVersionName name =
896         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
897 
898     ProcessorVersion actualResponse = client.getProcessorVersion(name);
899     Assert.assertEquals(expectedResponse, actualResponse);
900 
901     List<String> actualRequests = mockService.getRequestPaths();
902     Assert.assertEquals(1, actualRequests.size());
903 
904     String apiClientHeaderKey =
905         mockService
906             .getRequestHeaders()
907             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
908             .iterator()
909             .next();
910     Assert.assertTrue(
911         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
912             .matcher(apiClientHeaderKey)
913             .matches());
914   }
915 
916   @Test
getProcessorVersionExceptionTest()917   public void getProcessorVersionExceptionTest() throws Exception {
918     ApiException exception =
919         ApiExceptionFactory.createException(
920             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
921     mockService.addException(exception);
922 
923     try {
924       ProcessorVersionName name =
925           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
926       client.getProcessorVersion(name);
927       Assert.fail("No exception raised");
928     } catch (InvalidArgumentException e) {
929       // Expected exception.
930     }
931   }
932 
933   @Test
getProcessorVersionTest2()934   public void getProcessorVersionTest2() throws Exception {
935     ProcessorVersion expectedResponse =
936         ProcessorVersion.newBuilder()
937             .setName(
938                 ProcessorVersionName.of(
939                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
940                     .toString())
941             .setDisplayName("displayName1714148973")
942             .setDocumentSchema(DocumentSchema.newBuilder().build())
943             .setCreateTime(Timestamp.newBuilder().build())
944             .setLatestEvaluation(EvaluationReference.newBuilder().build())
945             .setKmsKeyName("kmsKeyName412586233")
946             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
947             .setGoogleManaged(true)
948             .setDeprecationInfo(ProcessorVersion.DeprecationInfo.newBuilder().build())
949             .build();
950     mockService.addResponse(expectedResponse);
951 
952     String name =
953         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
954 
955     ProcessorVersion actualResponse = client.getProcessorVersion(name);
956     Assert.assertEquals(expectedResponse, actualResponse);
957 
958     List<String> actualRequests = mockService.getRequestPaths();
959     Assert.assertEquals(1, actualRequests.size());
960 
961     String apiClientHeaderKey =
962         mockService
963             .getRequestHeaders()
964             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
965             .iterator()
966             .next();
967     Assert.assertTrue(
968         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
969             .matcher(apiClientHeaderKey)
970             .matches());
971   }
972 
973   @Test
getProcessorVersionExceptionTest2()974   public void getProcessorVersionExceptionTest2() throws Exception {
975     ApiException exception =
976         ApiExceptionFactory.createException(
977             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
978     mockService.addException(exception);
979 
980     try {
981       String name =
982           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
983       client.getProcessorVersion(name);
984       Assert.fail("No exception raised");
985     } catch (InvalidArgumentException e) {
986       // Expected exception.
987     }
988   }
989 
990   @Test
listProcessorVersionsTest()991   public void listProcessorVersionsTest() throws Exception {
992     ProcessorVersion responsesElement = ProcessorVersion.newBuilder().build();
993     ListProcessorVersionsResponse expectedResponse =
994         ListProcessorVersionsResponse.newBuilder()
995             .setNextPageToken("")
996             .addAllProcessorVersions(Arrays.asList(responsesElement))
997             .build();
998     mockService.addResponse(expectedResponse);
999 
1000     ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1001 
1002     ListProcessorVersionsPagedResponse pagedListResponse = client.listProcessorVersions(parent);
1003 
1004     List<ProcessorVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1005 
1006     Assert.assertEquals(1, resources.size());
1007     Assert.assertEquals(expectedResponse.getProcessorVersionsList().get(0), resources.get(0));
1008 
1009     List<String> actualRequests = mockService.getRequestPaths();
1010     Assert.assertEquals(1, actualRequests.size());
1011 
1012     String apiClientHeaderKey =
1013         mockService
1014             .getRequestHeaders()
1015             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1016             .iterator()
1017             .next();
1018     Assert.assertTrue(
1019         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1020             .matcher(apiClientHeaderKey)
1021             .matches());
1022   }
1023 
1024   @Test
listProcessorVersionsExceptionTest()1025   public void listProcessorVersionsExceptionTest() throws Exception {
1026     ApiException exception =
1027         ApiExceptionFactory.createException(
1028             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1029     mockService.addException(exception);
1030 
1031     try {
1032       ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1033       client.listProcessorVersions(parent);
1034       Assert.fail("No exception raised");
1035     } catch (InvalidArgumentException e) {
1036       // Expected exception.
1037     }
1038   }
1039 
1040   @Test
listProcessorVersionsTest2()1041   public void listProcessorVersionsTest2() throws Exception {
1042     ProcessorVersion responsesElement = ProcessorVersion.newBuilder().build();
1043     ListProcessorVersionsResponse expectedResponse =
1044         ListProcessorVersionsResponse.newBuilder()
1045             .setNextPageToken("")
1046             .addAllProcessorVersions(Arrays.asList(responsesElement))
1047             .build();
1048     mockService.addResponse(expectedResponse);
1049 
1050     String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
1051 
1052     ListProcessorVersionsPagedResponse pagedListResponse = client.listProcessorVersions(parent);
1053 
1054     List<ProcessorVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1055 
1056     Assert.assertEquals(1, resources.size());
1057     Assert.assertEquals(expectedResponse.getProcessorVersionsList().get(0), resources.get(0));
1058 
1059     List<String> actualRequests = mockService.getRequestPaths();
1060     Assert.assertEquals(1, actualRequests.size());
1061 
1062     String apiClientHeaderKey =
1063         mockService
1064             .getRequestHeaders()
1065             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1066             .iterator()
1067             .next();
1068     Assert.assertTrue(
1069         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1070             .matcher(apiClientHeaderKey)
1071             .matches());
1072   }
1073 
1074   @Test
listProcessorVersionsExceptionTest2()1075   public void listProcessorVersionsExceptionTest2() throws Exception {
1076     ApiException exception =
1077         ApiExceptionFactory.createException(
1078             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1079     mockService.addException(exception);
1080 
1081     try {
1082       String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
1083       client.listProcessorVersions(parent);
1084       Assert.fail("No exception raised");
1085     } catch (InvalidArgumentException e) {
1086       // Expected exception.
1087     }
1088   }
1089 
1090   @Test
deleteProcessorVersionTest()1091   public void deleteProcessorVersionTest() throws Exception {
1092     Empty expectedResponse = Empty.newBuilder().build();
1093     Operation resultOperation =
1094         Operation.newBuilder()
1095             .setName("deleteProcessorVersionTest")
1096             .setDone(true)
1097             .setResponse(Any.pack(expectedResponse))
1098             .build();
1099     mockService.addResponse(resultOperation);
1100 
1101     ProcessorVersionName name =
1102         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1103 
1104     client.deleteProcessorVersionAsync(name).get();
1105 
1106     List<String> actualRequests = mockService.getRequestPaths();
1107     Assert.assertEquals(1, actualRequests.size());
1108 
1109     String apiClientHeaderKey =
1110         mockService
1111             .getRequestHeaders()
1112             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1113             .iterator()
1114             .next();
1115     Assert.assertTrue(
1116         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1117             .matcher(apiClientHeaderKey)
1118             .matches());
1119   }
1120 
1121   @Test
deleteProcessorVersionExceptionTest()1122   public void deleteProcessorVersionExceptionTest() throws Exception {
1123     ApiException exception =
1124         ApiExceptionFactory.createException(
1125             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1126     mockService.addException(exception);
1127 
1128     try {
1129       ProcessorVersionName name =
1130           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1131       client.deleteProcessorVersionAsync(name).get();
1132       Assert.fail("No exception raised");
1133     } catch (ExecutionException e) {
1134     }
1135   }
1136 
1137   @Test
deleteProcessorVersionTest2()1138   public void deleteProcessorVersionTest2() throws Exception {
1139     Empty expectedResponse = Empty.newBuilder().build();
1140     Operation resultOperation =
1141         Operation.newBuilder()
1142             .setName("deleteProcessorVersionTest")
1143             .setDone(true)
1144             .setResponse(Any.pack(expectedResponse))
1145             .build();
1146     mockService.addResponse(resultOperation);
1147 
1148     String name =
1149         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1150 
1151     client.deleteProcessorVersionAsync(name).get();
1152 
1153     List<String> actualRequests = mockService.getRequestPaths();
1154     Assert.assertEquals(1, actualRequests.size());
1155 
1156     String apiClientHeaderKey =
1157         mockService
1158             .getRequestHeaders()
1159             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1160             .iterator()
1161             .next();
1162     Assert.assertTrue(
1163         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1164             .matcher(apiClientHeaderKey)
1165             .matches());
1166   }
1167 
1168   @Test
deleteProcessorVersionExceptionTest2()1169   public void deleteProcessorVersionExceptionTest2() throws Exception {
1170     ApiException exception =
1171         ApiExceptionFactory.createException(
1172             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1173     mockService.addException(exception);
1174 
1175     try {
1176       String name =
1177           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1178       client.deleteProcessorVersionAsync(name).get();
1179       Assert.fail("No exception raised");
1180     } catch (ExecutionException e) {
1181     }
1182   }
1183 
1184   @Test
deployProcessorVersionTest()1185   public void deployProcessorVersionTest() throws Exception {
1186     DeployProcessorVersionResponse expectedResponse =
1187         DeployProcessorVersionResponse.newBuilder().build();
1188     Operation resultOperation =
1189         Operation.newBuilder()
1190             .setName("deployProcessorVersionTest")
1191             .setDone(true)
1192             .setResponse(Any.pack(expectedResponse))
1193             .build();
1194     mockService.addResponse(resultOperation);
1195 
1196     ProcessorVersionName name =
1197         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1198 
1199     DeployProcessorVersionResponse actualResponse = client.deployProcessorVersionAsync(name).get();
1200     Assert.assertEquals(expectedResponse, actualResponse);
1201 
1202     List<String> actualRequests = mockService.getRequestPaths();
1203     Assert.assertEquals(1, actualRequests.size());
1204 
1205     String apiClientHeaderKey =
1206         mockService
1207             .getRequestHeaders()
1208             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1209             .iterator()
1210             .next();
1211     Assert.assertTrue(
1212         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1213             .matcher(apiClientHeaderKey)
1214             .matches());
1215   }
1216 
1217   @Test
deployProcessorVersionExceptionTest()1218   public void deployProcessorVersionExceptionTest() throws Exception {
1219     ApiException exception =
1220         ApiExceptionFactory.createException(
1221             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1222     mockService.addException(exception);
1223 
1224     try {
1225       ProcessorVersionName name =
1226           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1227       client.deployProcessorVersionAsync(name).get();
1228       Assert.fail("No exception raised");
1229     } catch (ExecutionException e) {
1230     }
1231   }
1232 
1233   @Test
deployProcessorVersionTest2()1234   public void deployProcessorVersionTest2() throws Exception {
1235     DeployProcessorVersionResponse expectedResponse =
1236         DeployProcessorVersionResponse.newBuilder().build();
1237     Operation resultOperation =
1238         Operation.newBuilder()
1239             .setName("deployProcessorVersionTest")
1240             .setDone(true)
1241             .setResponse(Any.pack(expectedResponse))
1242             .build();
1243     mockService.addResponse(resultOperation);
1244 
1245     String name =
1246         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1247 
1248     DeployProcessorVersionResponse actualResponse = client.deployProcessorVersionAsync(name).get();
1249     Assert.assertEquals(expectedResponse, actualResponse);
1250 
1251     List<String> actualRequests = mockService.getRequestPaths();
1252     Assert.assertEquals(1, actualRequests.size());
1253 
1254     String apiClientHeaderKey =
1255         mockService
1256             .getRequestHeaders()
1257             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1258             .iterator()
1259             .next();
1260     Assert.assertTrue(
1261         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1262             .matcher(apiClientHeaderKey)
1263             .matches());
1264   }
1265 
1266   @Test
deployProcessorVersionExceptionTest2()1267   public void deployProcessorVersionExceptionTest2() throws Exception {
1268     ApiException exception =
1269         ApiExceptionFactory.createException(
1270             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1271     mockService.addException(exception);
1272 
1273     try {
1274       String name =
1275           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1276       client.deployProcessorVersionAsync(name).get();
1277       Assert.fail("No exception raised");
1278     } catch (ExecutionException e) {
1279     }
1280   }
1281 
1282   @Test
undeployProcessorVersionTest()1283   public void undeployProcessorVersionTest() throws Exception {
1284     UndeployProcessorVersionResponse expectedResponse =
1285         UndeployProcessorVersionResponse.newBuilder().build();
1286     Operation resultOperation =
1287         Operation.newBuilder()
1288             .setName("undeployProcessorVersionTest")
1289             .setDone(true)
1290             .setResponse(Any.pack(expectedResponse))
1291             .build();
1292     mockService.addResponse(resultOperation);
1293 
1294     ProcessorVersionName name =
1295         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1296 
1297     UndeployProcessorVersionResponse actualResponse =
1298         client.undeployProcessorVersionAsync(name).get();
1299     Assert.assertEquals(expectedResponse, actualResponse);
1300 
1301     List<String> actualRequests = mockService.getRequestPaths();
1302     Assert.assertEquals(1, actualRequests.size());
1303 
1304     String apiClientHeaderKey =
1305         mockService
1306             .getRequestHeaders()
1307             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1308             .iterator()
1309             .next();
1310     Assert.assertTrue(
1311         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1312             .matcher(apiClientHeaderKey)
1313             .matches());
1314   }
1315 
1316   @Test
undeployProcessorVersionExceptionTest()1317   public void undeployProcessorVersionExceptionTest() throws Exception {
1318     ApiException exception =
1319         ApiExceptionFactory.createException(
1320             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1321     mockService.addException(exception);
1322 
1323     try {
1324       ProcessorVersionName name =
1325           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1326       client.undeployProcessorVersionAsync(name).get();
1327       Assert.fail("No exception raised");
1328     } catch (ExecutionException e) {
1329     }
1330   }
1331 
1332   @Test
undeployProcessorVersionTest2()1333   public void undeployProcessorVersionTest2() throws Exception {
1334     UndeployProcessorVersionResponse expectedResponse =
1335         UndeployProcessorVersionResponse.newBuilder().build();
1336     Operation resultOperation =
1337         Operation.newBuilder()
1338             .setName("undeployProcessorVersionTest")
1339             .setDone(true)
1340             .setResponse(Any.pack(expectedResponse))
1341             .build();
1342     mockService.addResponse(resultOperation);
1343 
1344     String name =
1345         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1346 
1347     UndeployProcessorVersionResponse actualResponse =
1348         client.undeployProcessorVersionAsync(name).get();
1349     Assert.assertEquals(expectedResponse, actualResponse);
1350 
1351     List<String> actualRequests = mockService.getRequestPaths();
1352     Assert.assertEquals(1, actualRequests.size());
1353 
1354     String apiClientHeaderKey =
1355         mockService
1356             .getRequestHeaders()
1357             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1358             .iterator()
1359             .next();
1360     Assert.assertTrue(
1361         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1362             .matcher(apiClientHeaderKey)
1363             .matches());
1364   }
1365 
1366   @Test
undeployProcessorVersionExceptionTest2()1367   public void undeployProcessorVersionExceptionTest2() throws Exception {
1368     ApiException exception =
1369         ApiExceptionFactory.createException(
1370             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1371     mockService.addException(exception);
1372 
1373     try {
1374       String name =
1375           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1376       client.undeployProcessorVersionAsync(name).get();
1377       Assert.fail("No exception raised");
1378     } catch (ExecutionException e) {
1379     }
1380   }
1381 
1382   @Test
createProcessorTest()1383   public void createProcessorTest() throws Exception {
1384     Processor expectedResponse =
1385         Processor.newBuilder()
1386             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1387             .setType("type3575610")
1388             .setDisplayName("displayName1714148973")
1389             .setDefaultProcessorVersion(
1390                 ProcessorVersionName.of(
1391                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1392                     .toString())
1393             .setProcessEndpoint("processEndpoint-891502300")
1394             .setCreateTime(Timestamp.newBuilder().build())
1395             .setKmsKeyName("kmsKeyName412586233")
1396             .build();
1397     mockService.addResponse(expectedResponse);
1398 
1399     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1400     Processor processor = Processor.newBuilder().build();
1401 
1402     Processor actualResponse = client.createProcessor(parent, processor);
1403     Assert.assertEquals(expectedResponse, actualResponse);
1404 
1405     List<String> actualRequests = mockService.getRequestPaths();
1406     Assert.assertEquals(1, actualRequests.size());
1407 
1408     String apiClientHeaderKey =
1409         mockService
1410             .getRequestHeaders()
1411             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1412             .iterator()
1413             .next();
1414     Assert.assertTrue(
1415         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1416             .matcher(apiClientHeaderKey)
1417             .matches());
1418   }
1419 
1420   @Test
createProcessorExceptionTest()1421   public void createProcessorExceptionTest() throws Exception {
1422     ApiException exception =
1423         ApiExceptionFactory.createException(
1424             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1425     mockService.addException(exception);
1426 
1427     try {
1428       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1429       Processor processor = Processor.newBuilder().build();
1430       client.createProcessor(parent, processor);
1431       Assert.fail("No exception raised");
1432     } catch (InvalidArgumentException e) {
1433       // Expected exception.
1434     }
1435   }
1436 
1437   @Test
createProcessorTest2()1438   public void createProcessorTest2() throws Exception {
1439     Processor expectedResponse =
1440         Processor.newBuilder()
1441             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1442             .setType("type3575610")
1443             .setDisplayName("displayName1714148973")
1444             .setDefaultProcessorVersion(
1445                 ProcessorVersionName.of(
1446                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1447                     .toString())
1448             .setProcessEndpoint("processEndpoint-891502300")
1449             .setCreateTime(Timestamp.newBuilder().build())
1450             .setKmsKeyName("kmsKeyName412586233")
1451             .build();
1452     mockService.addResponse(expectedResponse);
1453 
1454     String parent = "projects/project-5833/locations/location-5833";
1455     Processor processor = Processor.newBuilder().build();
1456 
1457     Processor actualResponse = client.createProcessor(parent, processor);
1458     Assert.assertEquals(expectedResponse, actualResponse);
1459 
1460     List<String> actualRequests = mockService.getRequestPaths();
1461     Assert.assertEquals(1, actualRequests.size());
1462 
1463     String apiClientHeaderKey =
1464         mockService
1465             .getRequestHeaders()
1466             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1467             .iterator()
1468             .next();
1469     Assert.assertTrue(
1470         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1471             .matcher(apiClientHeaderKey)
1472             .matches());
1473   }
1474 
1475   @Test
createProcessorExceptionTest2()1476   public void createProcessorExceptionTest2() throws Exception {
1477     ApiException exception =
1478         ApiExceptionFactory.createException(
1479             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1480     mockService.addException(exception);
1481 
1482     try {
1483       String parent = "projects/project-5833/locations/location-5833";
1484       Processor processor = Processor.newBuilder().build();
1485       client.createProcessor(parent, processor);
1486       Assert.fail("No exception raised");
1487     } catch (InvalidArgumentException e) {
1488       // Expected exception.
1489     }
1490   }
1491 
1492   @Test
deleteProcessorTest()1493   public void deleteProcessorTest() throws Exception {
1494     Empty expectedResponse = Empty.newBuilder().build();
1495     Operation resultOperation =
1496         Operation.newBuilder()
1497             .setName("deleteProcessorTest")
1498             .setDone(true)
1499             .setResponse(Any.pack(expectedResponse))
1500             .build();
1501     mockService.addResponse(resultOperation);
1502 
1503     ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1504 
1505     client.deleteProcessorAsync(name).get();
1506 
1507     List<String> actualRequests = mockService.getRequestPaths();
1508     Assert.assertEquals(1, actualRequests.size());
1509 
1510     String apiClientHeaderKey =
1511         mockService
1512             .getRequestHeaders()
1513             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1514             .iterator()
1515             .next();
1516     Assert.assertTrue(
1517         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1518             .matcher(apiClientHeaderKey)
1519             .matches());
1520   }
1521 
1522   @Test
deleteProcessorExceptionTest()1523   public void deleteProcessorExceptionTest() throws Exception {
1524     ApiException exception =
1525         ApiExceptionFactory.createException(
1526             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1527     mockService.addException(exception);
1528 
1529     try {
1530       ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1531       client.deleteProcessorAsync(name).get();
1532       Assert.fail("No exception raised");
1533     } catch (ExecutionException e) {
1534     }
1535   }
1536 
1537   @Test
deleteProcessorTest2()1538   public void deleteProcessorTest2() throws Exception {
1539     Empty expectedResponse = Empty.newBuilder().build();
1540     Operation resultOperation =
1541         Operation.newBuilder()
1542             .setName("deleteProcessorTest")
1543             .setDone(true)
1544             .setResponse(Any.pack(expectedResponse))
1545             .build();
1546     mockService.addResponse(resultOperation);
1547 
1548     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
1549 
1550     client.deleteProcessorAsync(name).get();
1551 
1552     List<String> actualRequests = mockService.getRequestPaths();
1553     Assert.assertEquals(1, actualRequests.size());
1554 
1555     String apiClientHeaderKey =
1556         mockService
1557             .getRequestHeaders()
1558             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1559             .iterator()
1560             .next();
1561     Assert.assertTrue(
1562         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1563             .matcher(apiClientHeaderKey)
1564             .matches());
1565   }
1566 
1567   @Test
deleteProcessorExceptionTest2()1568   public void deleteProcessorExceptionTest2() throws Exception {
1569     ApiException exception =
1570         ApiExceptionFactory.createException(
1571             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1572     mockService.addException(exception);
1573 
1574     try {
1575       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
1576       client.deleteProcessorAsync(name).get();
1577       Assert.fail("No exception raised");
1578     } catch (ExecutionException e) {
1579     }
1580   }
1581 
1582   @Test
enableProcessorTest()1583   public void enableProcessorTest() throws Exception {
1584     EnableProcessorResponse expectedResponse = EnableProcessorResponse.newBuilder().build();
1585     Operation resultOperation =
1586         Operation.newBuilder()
1587             .setName("enableProcessorTest")
1588             .setDone(true)
1589             .setResponse(Any.pack(expectedResponse))
1590             .build();
1591     mockService.addResponse(resultOperation);
1592 
1593     EnableProcessorRequest request =
1594         EnableProcessorRequest.newBuilder()
1595             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1596             .build();
1597 
1598     EnableProcessorResponse actualResponse = client.enableProcessorAsync(request).get();
1599     Assert.assertEquals(expectedResponse, actualResponse);
1600 
1601     List<String> actualRequests = mockService.getRequestPaths();
1602     Assert.assertEquals(1, actualRequests.size());
1603 
1604     String apiClientHeaderKey =
1605         mockService
1606             .getRequestHeaders()
1607             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1608             .iterator()
1609             .next();
1610     Assert.assertTrue(
1611         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1612             .matcher(apiClientHeaderKey)
1613             .matches());
1614   }
1615 
1616   @Test
enableProcessorExceptionTest()1617   public void enableProcessorExceptionTest() throws Exception {
1618     ApiException exception =
1619         ApiExceptionFactory.createException(
1620             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1621     mockService.addException(exception);
1622 
1623     try {
1624       EnableProcessorRequest request =
1625           EnableProcessorRequest.newBuilder()
1626               .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1627               .build();
1628       client.enableProcessorAsync(request).get();
1629       Assert.fail("No exception raised");
1630     } catch (ExecutionException e) {
1631     }
1632   }
1633 
1634   @Test
disableProcessorTest()1635   public void disableProcessorTest() throws Exception {
1636     DisableProcessorResponse expectedResponse = DisableProcessorResponse.newBuilder().build();
1637     Operation resultOperation =
1638         Operation.newBuilder()
1639             .setName("disableProcessorTest")
1640             .setDone(true)
1641             .setResponse(Any.pack(expectedResponse))
1642             .build();
1643     mockService.addResponse(resultOperation);
1644 
1645     DisableProcessorRequest request =
1646         DisableProcessorRequest.newBuilder()
1647             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1648             .build();
1649 
1650     DisableProcessorResponse actualResponse = client.disableProcessorAsync(request).get();
1651     Assert.assertEquals(expectedResponse, actualResponse);
1652 
1653     List<String> actualRequests = mockService.getRequestPaths();
1654     Assert.assertEquals(1, actualRequests.size());
1655 
1656     String apiClientHeaderKey =
1657         mockService
1658             .getRequestHeaders()
1659             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1660             .iterator()
1661             .next();
1662     Assert.assertTrue(
1663         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1664             .matcher(apiClientHeaderKey)
1665             .matches());
1666   }
1667 
1668   @Test
disableProcessorExceptionTest()1669   public void disableProcessorExceptionTest() throws Exception {
1670     ApiException exception =
1671         ApiExceptionFactory.createException(
1672             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1673     mockService.addException(exception);
1674 
1675     try {
1676       DisableProcessorRequest request =
1677           DisableProcessorRequest.newBuilder()
1678               .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1679               .build();
1680       client.disableProcessorAsync(request).get();
1681       Assert.fail("No exception raised");
1682     } catch (ExecutionException e) {
1683     }
1684   }
1685 
1686   @Test
setDefaultProcessorVersionTest()1687   public void setDefaultProcessorVersionTest() throws Exception {
1688     SetDefaultProcessorVersionResponse expectedResponse =
1689         SetDefaultProcessorVersionResponse.newBuilder().build();
1690     Operation resultOperation =
1691         Operation.newBuilder()
1692             .setName("setDefaultProcessorVersionTest")
1693             .setDone(true)
1694             .setResponse(Any.pack(expectedResponse))
1695             .build();
1696     mockService.addResponse(resultOperation);
1697 
1698     SetDefaultProcessorVersionRequest request =
1699         SetDefaultProcessorVersionRequest.newBuilder()
1700             .setProcessor(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1701             .setDefaultProcessorVersion(
1702                 ProcessorVersionName.of(
1703                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1704                     .toString())
1705             .build();
1706 
1707     SetDefaultProcessorVersionResponse actualResponse =
1708         client.setDefaultProcessorVersionAsync(request).get();
1709     Assert.assertEquals(expectedResponse, actualResponse);
1710 
1711     List<String> actualRequests = mockService.getRequestPaths();
1712     Assert.assertEquals(1, actualRequests.size());
1713 
1714     String apiClientHeaderKey =
1715         mockService
1716             .getRequestHeaders()
1717             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1718             .iterator()
1719             .next();
1720     Assert.assertTrue(
1721         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1722             .matcher(apiClientHeaderKey)
1723             .matches());
1724   }
1725 
1726   @Test
setDefaultProcessorVersionExceptionTest()1727   public void setDefaultProcessorVersionExceptionTest() throws Exception {
1728     ApiException exception =
1729         ApiExceptionFactory.createException(
1730             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1731     mockService.addException(exception);
1732 
1733     try {
1734       SetDefaultProcessorVersionRequest request =
1735           SetDefaultProcessorVersionRequest.newBuilder()
1736               .setProcessor(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1737               .setDefaultProcessorVersion(
1738                   ProcessorVersionName.of(
1739                           "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1740                       .toString())
1741               .build();
1742       client.setDefaultProcessorVersionAsync(request).get();
1743       Assert.fail("No exception raised");
1744     } catch (ExecutionException e) {
1745     }
1746   }
1747 
1748   @Test
reviewDocumentTest()1749   public void reviewDocumentTest() throws Exception {
1750     ReviewDocumentResponse expectedResponse =
1751         ReviewDocumentResponse.newBuilder()
1752             .setGcsDestination("gcsDestination-1612392329")
1753             .setRejectionReason("rejectionReason1485905837")
1754             .build();
1755     Operation resultOperation =
1756         Operation.newBuilder()
1757             .setName("reviewDocumentTest")
1758             .setDone(true)
1759             .setResponse(Any.pack(expectedResponse))
1760             .build();
1761     mockService.addResponse(resultOperation);
1762 
1763     HumanReviewConfigName humanReviewConfig =
1764         HumanReviewConfigName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1765 
1766     ReviewDocumentResponse actualResponse = client.reviewDocumentAsync(humanReviewConfig).get();
1767     Assert.assertEquals(expectedResponse, actualResponse);
1768 
1769     List<String> actualRequests = mockService.getRequestPaths();
1770     Assert.assertEquals(1, actualRequests.size());
1771 
1772     String apiClientHeaderKey =
1773         mockService
1774             .getRequestHeaders()
1775             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1776             .iterator()
1777             .next();
1778     Assert.assertTrue(
1779         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1780             .matcher(apiClientHeaderKey)
1781             .matches());
1782   }
1783 
1784   @Test
reviewDocumentExceptionTest()1785   public void reviewDocumentExceptionTest() throws Exception {
1786     ApiException exception =
1787         ApiExceptionFactory.createException(
1788             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1789     mockService.addException(exception);
1790 
1791     try {
1792       HumanReviewConfigName humanReviewConfig =
1793           HumanReviewConfigName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1794       client.reviewDocumentAsync(humanReviewConfig).get();
1795       Assert.fail("No exception raised");
1796     } catch (ExecutionException e) {
1797     }
1798   }
1799 
1800   @Test
reviewDocumentTest2()1801   public void reviewDocumentTest2() throws Exception {
1802     ReviewDocumentResponse expectedResponse =
1803         ReviewDocumentResponse.newBuilder()
1804             .setGcsDestination("gcsDestination-1612392329")
1805             .setRejectionReason("rejectionReason1485905837")
1806             .build();
1807     Operation resultOperation =
1808         Operation.newBuilder()
1809             .setName("reviewDocumentTest")
1810             .setDone(true)
1811             .setResponse(Any.pack(expectedResponse))
1812             .build();
1813     mockService.addResponse(resultOperation);
1814 
1815     String humanReviewConfig =
1816         "projects/project-1917/locations/location-1917/processors/processor-1917/humanReviewConfig";
1817 
1818     ReviewDocumentResponse actualResponse = client.reviewDocumentAsync(humanReviewConfig).get();
1819     Assert.assertEquals(expectedResponse, actualResponse);
1820 
1821     List<String> actualRequests = mockService.getRequestPaths();
1822     Assert.assertEquals(1, actualRequests.size());
1823 
1824     String apiClientHeaderKey =
1825         mockService
1826             .getRequestHeaders()
1827             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1828             .iterator()
1829             .next();
1830     Assert.assertTrue(
1831         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1832             .matcher(apiClientHeaderKey)
1833             .matches());
1834   }
1835 
1836   @Test
reviewDocumentExceptionTest2()1837   public void reviewDocumentExceptionTest2() throws Exception {
1838     ApiException exception =
1839         ApiExceptionFactory.createException(
1840             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1841     mockService.addException(exception);
1842 
1843     try {
1844       String humanReviewConfig =
1845           "projects/project-1917/locations/location-1917/processors/processor-1917/humanReviewConfig";
1846       client.reviewDocumentAsync(humanReviewConfig).get();
1847       Assert.fail("No exception raised");
1848     } catch (ExecutionException e) {
1849     }
1850   }
1851 
1852   @Test
evaluateProcessorVersionTest()1853   public void evaluateProcessorVersionTest() throws Exception {
1854     EvaluateProcessorVersionResponse expectedResponse =
1855         EvaluateProcessorVersionResponse.newBuilder().setEvaluation("evaluation858523452").build();
1856     Operation resultOperation =
1857         Operation.newBuilder()
1858             .setName("evaluateProcessorVersionTest")
1859             .setDone(true)
1860             .setResponse(Any.pack(expectedResponse))
1861             .build();
1862     mockService.addResponse(resultOperation);
1863 
1864     ProcessorVersionName processorVersion =
1865         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1866 
1867     EvaluateProcessorVersionResponse actualResponse =
1868         client.evaluateProcessorVersionAsync(processorVersion).get();
1869     Assert.assertEquals(expectedResponse, actualResponse);
1870 
1871     List<String> actualRequests = mockService.getRequestPaths();
1872     Assert.assertEquals(1, actualRequests.size());
1873 
1874     String apiClientHeaderKey =
1875         mockService
1876             .getRequestHeaders()
1877             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1878             .iterator()
1879             .next();
1880     Assert.assertTrue(
1881         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1882             .matcher(apiClientHeaderKey)
1883             .matches());
1884   }
1885 
1886   @Test
evaluateProcessorVersionExceptionTest()1887   public void evaluateProcessorVersionExceptionTest() throws Exception {
1888     ApiException exception =
1889         ApiExceptionFactory.createException(
1890             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1891     mockService.addException(exception);
1892 
1893     try {
1894       ProcessorVersionName processorVersion =
1895           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1896       client.evaluateProcessorVersionAsync(processorVersion).get();
1897       Assert.fail("No exception raised");
1898     } catch (ExecutionException e) {
1899     }
1900   }
1901 
1902   @Test
evaluateProcessorVersionTest2()1903   public void evaluateProcessorVersionTest2() throws Exception {
1904     EvaluateProcessorVersionResponse expectedResponse =
1905         EvaluateProcessorVersionResponse.newBuilder().setEvaluation("evaluation858523452").build();
1906     Operation resultOperation =
1907         Operation.newBuilder()
1908             .setName("evaluateProcessorVersionTest")
1909             .setDone(true)
1910             .setResponse(Any.pack(expectedResponse))
1911             .build();
1912     mockService.addResponse(resultOperation);
1913 
1914     String processorVersion =
1915         "projects/project-7729/locations/location-7729/processors/processor-7729/processorVersions/processorVersion-7729";
1916 
1917     EvaluateProcessorVersionResponse actualResponse =
1918         client.evaluateProcessorVersionAsync(processorVersion).get();
1919     Assert.assertEquals(expectedResponse, actualResponse);
1920 
1921     List<String> actualRequests = mockService.getRequestPaths();
1922     Assert.assertEquals(1, actualRequests.size());
1923 
1924     String apiClientHeaderKey =
1925         mockService
1926             .getRequestHeaders()
1927             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1928             .iterator()
1929             .next();
1930     Assert.assertTrue(
1931         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1932             .matcher(apiClientHeaderKey)
1933             .matches());
1934   }
1935 
1936   @Test
evaluateProcessorVersionExceptionTest2()1937   public void evaluateProcessorVersionExceptionTest2() throws Exception {
1938     ApiException exception =
1939         ApiExceptionFactory.createException(
1940             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1941     mockService.addException(exception);
1942 
1943     try {
1944       String processorVersion =
1945           "projects/project-7729/locations/location-7729/processors/processor-7729/processorVersions/processorVersion-7729";
1946       client.evaluateProcessorVersionAsync(processorVersion).get();
1947       Assert.fail("No exception raised");
1948     } catch (ExecutionException e) {
1949     }
1950   }
1951 
1952   @Test
getEvaluationTest()1953   public void getEvaluationTest() throws Exception {
1954     Evaluation expectedResponse =
1955         Evaluation.newBuilder()
1956             .setName(
1957                 EvaluationName.of(
1958                         "[PROJECT]",
1959                         "[LOCATION]",
1960                         "[PROCESSOR]",
1961                         "[PROCESSOR_VERSION]",
1962                         "[EVALUATION]")
1963                     .toString())
1964             .setCreateTime(Timestamp.newBuilder().build())
1965             .setDocumentCounters(Evaluation.Counters.newBuilder().build())
1966             .setAllEntitiesMetrics(Evaluation.MultiConfidenceMetrics.newBuilder().build())
1967             .putAllEntityMetrics(new HashMap<String, Evaluation.MultiConfidenceMetrics>())
1968             .setKmsKeyName("kmsKeyName412586233")
1969             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1970             .build();
1971     mockService.addResponse(expectedResponse);
1972 
1973     EvaluationName name =
1974         EvaluationName.of(
1975             "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]", "[EVALUATION]");
1976 
1977     Evaluation actualResponse = client.getEvaluation(name);
1978     Assert.assertEquals(expectedResponse, actualResponse);
1979 
1980     List<String> actualRequests = mockService.getRequestPaths();
1981     Assert.assertEquals(1, actualRequests.size());
1982 
1983     String apiClientHeaderKey =
1984         mockService
1985             .getRequestHeaders()
1986             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1987             .iterator()
1988             .next();
1989     Assert.assertTrue(
1990         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1991             .matcher(apiClientHeaderKey)
1992             .matches());
1993   }
1994 
1995   @Test
getEvaluationExceptionTest()1996   public void getEvaluationExceptionTest() throws Exception {
1997     ApiException exception =
1998         ApiExceptionFactory.createException(
1999             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2000     mockService.addException(exception);
2001 
2002     try {
2003       EvaluationName name =
2004           EvaluationName.of(
2005               "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]", "[EVALUATION]");
2006       client.getEvaluation(name);
2007       Assert.fail("No exception raised");
2008     } catch (InvalidArgumentException e) {
2009       // Expected exception.
2010     }
2011   }
2012 
2013   @Test
getEvaluationTest2()2014   public void getEvaluationTest2() throws Exception {
2015     Evaluation expectedResponse =
2016         Evaluation.newBuilder()
2017             .setName(
2018                 EvaluationName.of(
2019                         "[PROJECT]",
2020                         "[LOCATION]",
2021                         "[PROCESSOR]",
2022                         "[PROCESSOR_VERSION]",
2023                         "[EVALUATION]")
2024                     .toString())
2025             .setCreateTime(Timestamp.newBuilder().build())
2026             .setDocumentCounters(Evaluation.Counters.newBuilder().build())
2027             .setAllEntitiesMetrics(Evaluation.MultiConfidenceMetrics.newBuilder().build())
2028             .putAllEntityMetrics(new HashMap<String, Evaluation.MultiConfidenceMetrics>())
2029             .setKmsKeyName("kmsKeyName412586233")
2030             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2031             .build();
2032     mockService.addResponse(expectedResponse);
2033 
2034     String name =
2035         "projects/project-6701/locations/location-6701/processors/processor-6701/processorVersions/processorVersion-6701/evaluations/evaluation-6701";
2036 
2037     Evaluation actualResponse = client.getEvaluation(name);
2038     Assert.assertEquals(expectedResponse, actualResponse);
2039 
2040     List<String> actualRequests = mockService.getRequestPaths();
2041     Assert.assertEquals(1, actualRequests.size());
2042 
2043     String apiClientHeaderKey =
2044         mockService
2045             .getRequestHeaders()
2046             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2047             .iterator()
2048             .next();
2049     Assert.assertTrue(
2050         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2051             .matcher(apiClientHeaderKey)
2052             .matches());
2053   }
2054 
2055   @Test
getEvaluationExceptionTest2()2056   public void getEvaluationExceptionTest2() throws Exception {
2057     ApiException exception =
2058         ApiExceptionFactory.createException(
2059             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2060     mockService.addException(exception);
2061 
2062     try {
2063       String name =
2064           "projects/project-6701/locations/location-6701/processors/processor-6701/processorVersions/processorVersion-6701/evaluations/evaluation-6701";
2065       client.getEvaluation(name);
2066       Assert.fail("No exception raised");
2067     } catch (InvalidArgumentException e) {
2068       // Expected exception.
2069     }
2070   }
2071 
2072   @Test
listEvaluationsTest()2073   public void listEvaluationsTest() throws Exception {
2074     Evaluation responsesElement = Evaluation.newBuilder().build();
2075     ListEvaluationsResponse expectedResponse =
2076         ListEvaluationsResponse.newBuilder()
2077             .setNextPageToken("")
2078             .addAllEvaluations(Arrays.asList(responsesElement))
2079             .build();
2080     mockService.addResponse(expectedResponse);
2081 
2082     ProcessorVersionName parent =
2083         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
2084 
2085     ListEvaluationsPagedResponse pagedListResponse = client.listEvaluations(parent);
2086 
2087     List<Evaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2088 
2089     Assert.assertEquals(1, resources.size());
2090     Assert.assertEquals(expectedResponse.getEvaluationsList().get(0), resources.get(0));
2091 
2092     List<String> actualRequests = mockService.getRequestPaths();
2093     Assert.assertEquals(1, actualRequests.size());
2094 
2095     String apiClientHeaderKey =
2096         mockService
2097             .getRequestHeaders()
2098             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2099             .iterator()
2100             .next();
2101     Assert.assertTrue(
2102         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2103             .matcher(apiClientHeaderKey)
2104             .matches());
2105   }
2106 
2107   @Test
listEvaluationsExceptionTest()2108   public void listEvaluationsExceptionTest() throws Exception {
2109     ApiException exception =
2110         ApiExceptionFactory.createException(
2111             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2112     mockService.addException(exception);
2113 
2114     try {
2115       ProcessorVersionName parent =
2116           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
2117       client.listEvaluations(parent);
2118       Assert.fail("No exception raised");
2119     } catch (InvalidArgumentException e) {
2120       // Expected exception.
2121     }
2122   }
2123 
2124   @Test
listEvaluationsTest2()2125   public void listEvaluationsTest2() throws Exception {
2126     Evaluation responsesElement = Evaluation.newBuilder().build();
2127     ListEvaluationsResponse expectedResponse =
2128         ListEvaluationsResponse.newBuilder()
2129             .setNextPageToken("")
2130             .addAllEvaluations(Arrays.asList(responsesElement))
2131             .build();
2132     mockService.addResponse(expectedResponse);
2133 
2134     String parent =
2135         "projects/project-1781/locations/location-1781/processors/processor-1781/processorVersions/processorVersion-1781";
2136 
2137     ListEvaluationsPagedResponse pagedListResponse = client.listEvaluations(parent);
2138 
2139     List<Evaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2140 
2141     Assert.assertEquals(1, resources.size());
2142     Assert.assertEquals(expectedResponse.getEvaluationsList().get(0), resources.get(0));
2143 
2144     List<String> actualRequests = mockService.getRequestPaths();
2145     Assert.assertEquals(1, actualRequests.size());
2146 
2147     String apiClientHeaderKey =
2148         mockService
2149             .getRequestHeaders()
2150             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2151             .iterator()
2152             .next();
2153     Assert.assertTrue(
2154         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2155             .matcher(apiClientHeaderKey)
2156             .matches());
2157   }
2158 
2159   @Test
listEvaluationsExceptionTest2()2160   public void listEvaluationsExceptionTest2() throws Exception {
2161     ApiException exception =
2162         ApiExceptionFactory.createException(
2163             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2164     mockService.addException(exception);
2165 
2166     try {
2167       String parent =
2168           "projects/project-1781/locations/location-1781/processors/processor-1781/processorVersions/processorVersion-1781";
2169       client.listEvaluations(parent);
2170       Assert.fail("No exception raised");
2171     } catch (InvalidArgumentException e) {
2172       // Expected exception.
2173     }
2174   }
2175 
2176   @Test
listLocationsTest()2177   public void listLocationsTest() throws Exception {
2178     Location responsesElement = Location.newBuilder().build();
2179     ListLocationsResponse expectedResponse =
2180         ListLocationsResponse.newBuilder()
2181             .setNextPageToken("")
2182             .addAllLocations(Arrays.asList(responsesElement))
2183             .build();
2184     mockService.addResponse(expectedResponse);
2185 
2186     ListLocationsRequest request =
2187         ListLocationsRequest.newBuilder()
2188             .setName("projects/project-3664")
2189             .setFilter("filter-1274492040")
2190             .setPageSize(883849137)
2191             .setPageToken("pageToken873572522")
2192             .build();
2193 
2194     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2195 
2196     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2197 
2198     Assert.assertEquals(1, resources.size());
2199     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2200 
2201     List<String> actualRequests = mockService.getRequestPaths();
2202     Assert.assertEquals(1, actualRequests.size());
2203 
2204     String apiClientHeaderKey =
2205         mockService
2206             .getRequestHeaders()
2207             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2208             .iterator()
2209             .next();
2210     Assert.assertTrue(
2211         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2212             .matcher(apiClientHeaderKey)
2213             .matches());
2214   }
2215 
2216   @Test
listLocationsExceptionTest()2217   public void listLocationsExceptionTest() throws Exception {
2218     ApiException exception =
2219         ApiExceptionFactory.createException(
2220             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2221     mockService.addException(exception);
2222 
2223     try {
2224       ListLocationsRequest request =
2225           ListLocationsRequest.newBuilder()
2226               .setName("projects/project-3664")
2227               .setFilter("filter-1274492040")
2228               .setPageSize(883849137)
2229               .setPageToken("pageToken873572522")
2230               .build();
2231       client.listLocations(request);
2232       Assert.fail("No exception raised");
2233     } catch (InvalidArgumentException e) {
2234       // Expected exception.
2235     }
2236   }
2237 
2238   @Test
getLocationTest()2239   public void getLocationTest() throws Exception {
2240     Location expectedResponse =
2241         Location.newBuilder()
2242             .setName("name3373707")
2243             .setLocationId("locationId1541836720")
2244             .setDisplayName("displayName1714148973")
2245             .putAllLabels(new HashMap<String, String>())
2246             .setMetadata(Any.newBuilder().build())
2247             .build();
2248     mockService.addResponse(expectedResponse);
2249 
2250     GetLocationRequest request =
2251         GetLocationRequest.newBuilder()
2252             .setName("projects/project-9062/locations/location-9062")
2253             .build();
2254 
2255     Location actualResponse = client.getLocation(request);
2256     Assert.assertEquals(expectedResponse, actualResponse);
2257 
2258     List<String> actualRequests = mockService.getRequestPaths();
2259     Assert.assertEquals(1, actualRequests.size());
2260 
2261     String apiClientHeaderKey =
2262         mockService
2263             .getRequestHeaders()
2264             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2265             .iterator()
2266             .next();
2267     Assert.assertTrue(
2268         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2269             .matcher(apiClientHeaderKey)
2270             .matches());
2271   }
2272 
2273   @Test
getLocationExceptionTest()2274   public void getLocationExceptionTest() throws Exception {
2275     ApiException exception =
2276         ApiExceptionFactory.createException(
2277             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2278     mockService.addException(exception);
2279 
2280     try {
2281       GetLocationRequest request =
2282           GetLocationRequest.newBuilder()
2283               .setName("projects/project-9062/locations/location-9062")
2284               .build();
2285       client.getLocation(request);
2286       Assert.fail("No exception raised");
2287     } catch (InvalidArgumentException e) {
2288       // Expected exception.
2289     }
2290   }
2291 }
2292