• 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.v1beta2;
18 
19 import com.google.api.gax.core.NoCredentialsProvider;
20 import com.google.api.gax.grpc.GaxGrpcProperties;
21 import com.google.api.gax.grpc.testing.LocalChannelProvider;
22 import com.google.api.gax.grpc.testing.MockGrpcService;
23 import com.google.api.gax.grpc.testing.MockServiceHelper;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.InvalidArgumentException;
26 import com.google.api.gax.rpc.StatusCode;
27 import com.google.longrunning.Operation;
28 import com.google.protobuf.AbstractMessage;
29 import com.google.protobuf.Any;
30 import com.google.rpc.Status;
31 import io.grpc.StatusRuntimeException;
32 import java.io.IOException;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.List;
36 import java.util.UUID;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class DocumentUnderstandingServiceClientTest {
48   private static MockDocumentUnderstandingService mockDocumentUnderstandingService;
49   private static MockServiceHelper mockServiceHelper;
50   private LocalChannelProvider channelProvider;
51   private DocumentUnderstandingServiceClient client;
52 
53   @BeforeClass
startStaticServer()54   public static void startStaticServer() {
55     mockDocumentUnderstandingService = new MockDocumentUnderstandingService();
56     mockServiceHelper =
57         new MockServiceHelper(
58             UUID.randomUUID().toString(),
59             Arrays.<MockGrpcService>asList(mockDocumentUnderstandingService));
60     mockServiceHelper.start();
61   }
62 
63   @AfterClass
stopServer()64   public static void stopServer() {
65     mockServiceHelper.stop();
66   }
67 
68   @Before
setUp()69   public void setUp() throws IOException {
70     mockServiceHelper.reset();
71     channelProvider = mockServiceHelper.createChannelProvider();
72     DocumentUnderstandingServiceSettings settings =
73         DocumentUnderstandingServiceSettings.newBuilder()
74             .setTransportChannelProvider(channelProvider)
75             .setCredentialsProvider(NoCredentialsProvider.create())
76             .build();
77     client = DocumentUnderstandingServiceClient.create(settings);
78   }
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     client.close();
83   }
84 
85   @Test
batchProcessDocumentsTest()86   public void batchProcessDocumentsTest() throws Exception {
87     BatchProcessDocumentsResponse expectedResponse =
88         BatchProcessDocumentsResponse.newBuilder()
89             .addAllResponses(new ArrayList<ProcessDocumentResponse>())
90             .build();
91     Operation resultOperation =
92         Operation.newBuilder()
93             .setName("batchProcessDocumentsTest")
94             .setDone(true)
95             .setResponse(Any.pack(expectedResponse))
96             .build();
97     mockDocumentUnderstandingService.addResponse(resultOperation);
98 
99     List<ProcessDocumentRequest> requests = new ArrayList<>();
100 
101     BatchProcessDocumentsResponse actualResponse =
102         client.batchProcessDocumentsAsync(requests).get();
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<AbstractMessage> actualRequests = mockDocumentUnderstandingService.getRequests();
106     Assert.assertEquals(1, actualRequests.size());
107     BatchProcessDocumentsRequest actualRequest =
108         ((BatchProcessDocumentsRequest) actualRequests.get(0));
109 
110     Assert.assertEquals(requests, actualRequest.getRequestsList());
111     Assert.assertTrue(
112         channelProvider.isHeaderSent(
113             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
114             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
115   }
116 
117   @Test
batchProcessDocumentsExceptionTest()118   public void batchProcessDocumentsExceptionTest() throws Exception {
119     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
120     mockDocumentUnderstandingService.addException(exception);
121 
122     try {
123       List<ProcessDocumentRequest> requests = new ArrayList<>();
124       client.batchProcessDocumentsAsync(requests).get();
125       Assert.fail("No exception raised");
126     } catch (ExecutionException e) {
127       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
128       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
129       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
130     }
131   }
132 
133   @Test
processDocumentTest()134   public void processDocumentTest() throws Exception {
135     Document expectedResponse =
136         Document.newBuilder()
137             .setMimeType("mimeType-1392120434")
138             .setText("text3556653")
139             .addAllTextStyles(new ArrayList<Document.Style>())
140             .addAllPages(new ArrayList<Document.Page>())
141             .addAllEntities(new ArrayList<Document.Entity>())
142             .addAllEntityRelations(new ArrayList<Document.EntityRelation>())
143             .setShardInfo(Document.ShardInfo.newBuilder().build())
144             .addAllLabels(new ArrayList<Document.Label>())
145             .setError(Status.newBuilder().build())
146             .build();
147     mockDocumentUnderstandingService.addResponse(expectedResponse);
148 
149     ProcessDocumentRequest request =
150         ProcessDocumentRequest.newBuilder()
151             .setParent("parent-995424086")
152             .setInputConfig(InputConfig.newBuilder().build())
153             .setOutputConfig(OutputConfig.newBuilder().build())
154             .setDocumentType("documentType-1473196299")
155             .setTableExtractionParams(TableExtractionParams.newBuilder().build())
156             .setFormExtractionParams(FormExtractionParams.newBuilder().build())
157             .setEntityExtractionParams(EntityExtractionParams.newBuilder().build())
158             .setOcrParams(OcrParams.newBuilder().build())
159             .setAutomlParams(AutoMlParams.newBuilder().build())
160             .build();
161 
162     Document actualResponse = client.processDocument(request);
163     Assert.assertEquals(expectedResponse, actualResponse);
164 
165     List<AbstractMessage> actualRequests = mockDocumentUnderstandingService.getRequests();
166     Assert.assertEquals(1, actualRequests.size());
167     ProcessDocumentRequest actualRequest = ((ProcessDocumentRequest) actualRequests.get(0));
168 
169     Assert.assertEquals(request.getParent(), actualRequest.getParent());
170     Assert.assertEquals(request.getInputConfig(), actualRequest.getInputConfig());
171     Assert.assertEquals(request.getOutputConfig(), actualRequest.getOutputConfig());
172     Assert.assertEquals(request.getDocumentType(), actualRequest.getDocumentType());
173     Assert.assertEquals(
174         request.getTableExtractionParams(), actualRequest.getTableExtractionParams());
175     Assert.assertEquals(request.getFormExtractionParams(), actualRequest.getFormExtractionParams());
176     Assert.assertEquals(
177         request.getEntityExtractionParams(), actualRequest.getEntityExtractionParams());
178     Assert.assertEquals(request.getOcrParams(), actualRequest.getOcrParams());
179     Assert.assertEquals(request.getAutomlParams(), actualRequest.getAutomlParams());
180     Assert.assertTrue(
181         channelProvider.isHeaderSent(
182             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
183             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
184   }
185 
186   @Test
processDocumentExceptionTest()187   public void processDocumentExceptionTest() throws Exception {
188     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
189     mockDocumentUnderstandingService.addException(exception);
190 
191     try {
192       ProcessDocumentRequest request =
193           ProcessDocumentRequest.newBuilder()
194               .setParent("parent-995424086")
195               .setInputConfig(InputConfig.newBuilder().build())
196               .setOutputConfig(OutputConfig.newBuilder().build())
197               .setDocumentType("documentType-1473196299")
198               .setTableExtractionParams(TableExtractionParams.newBuilder().build())
199               .setFormExtractionParams(FormExtractionParams.newBuilder().build())
200               .setEntityExtractionParams(EntityExtractionParams.newBuilder().build())
201               .setOcrParams(OcrParams.newBuilder().build())
202               .setAutomlParams(AutoMlParams.newBuilder().build())
203               .build();
204       client.processDocument(request);
205       Assert.fail("No exception raised");
206     } catch (InvalidArgumentException e) {
207       // Expected exception.
208     }
209   }
210 }
211