• 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.language.v1;
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.protobuf.AbstractMessage;
27 import io.grpc.StatusRuntimeException;
28 import java.io.IOException;
29 import java.util.ArrayList;
30 import java.util.Arrays;
31 import java.util.List;
32 import java.util.UUID;
33 import javax.annotation.Generated;
34 import org.junit.After;
35 import org.junit.AfterClass;
36 import org.junit.Assert;
37 import org.junit.Before;
38 import org.junit.BeforeClass;
39 import org.junit.Test;
40 
41 @Generated("by gapic-generator-java")
42 public class LanguageServiceClientTest {
43   private static MockLanguageService mockLanguageService;
44   private static MockServiceHelper mockServiceHelper;
45   private LocalChannelProvider channelProvider;
46   private LanguageServiceClient client;
47 
48   @BeforeClass
startStaticServer()49   public static void startStaticServer() {
50     mockLanguageService = new MockLanguageService();
51     mockServiceHelper =
52         new MockServiceHelper(
53             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockLanguageService));
54     mockServiceHelper.start();
55   }
56 
57   @AfterClass
stopServer()58   public static void stopServer() {
59     mockServiceHelper.stop();
60   }
61 
62   @Before
setUp()63   public void setUp() throws IOException {
64     mockServiceHelper.reset();
65     channelProvider = mockServiceHelper.createChannelProvider();
66     LanguageServiceSettings settings =
67         LanguageServiceSettings.newBuilder()
68             .setTransportChannelProvider(channelProvider)
69             .setCredentialsProvider(NoCredentialsProvider.create())
70             .build();
71     client = LanguageServiceClient.create(settings);
72   }
73 
74   @After
tearDown()75   public void tearDown() throws Exception {
76     client.close();
77   }
78 
79   @Test
analyzeSentimentTest()80   public void analyzeSentimentTest() throws Exception {
81     AnalyzeSentimentResponse expectedResponse =
82         AnalyzeSentimentResponse.newBuilder()
83             .setDocumentSentiment(Sentiment.newBuilder().build())
84             .setLanguage("language-1613589672")
85             .addAllSentences(new ArrayList<Sentence>())
86             .build();
87     mockLanguageService.addResponse(expectedResponse);
88 
89     Document document = Document.newBuilder().build();
90 
91     AnalyzeSentimentResponse actualResponse = client.analyzeSentiment(document);
92     Assert.assertEquals(expectedResponse, actualResponse);
93 
94     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
95     Assert.assertEquals(1, actualRequests.size());
96     AnalyzeSentimentRequest actualRequest = ((AnalyzeSentimentRequest) actualRequests.get(0));
97 
98     Assert.assertEquals(document, actualRequest.getDocument());
99     Assert.assertTrue(
100         channelProvider.isHeaderSent(
101             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
102             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
103   }
104 
105   @Test
analyzeSentimentExceptionTest()106   public void analyzeSentimentExceptionTest() throws Exception {
107     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
108     mockLanguageService.addException(exception);
109 
110     try {
111       Document document = Document.newBuilder().build();
112       client.analyzeSentiment(document);
113       Assert.fail("No exception raised");
114     } catch (InvalidArgumentException e) {
115       // Expected exception.
116     }
117   }
118 
119   @Test
analyzeSentimentTest2()120   public void analyzeSentimentTest2() throws Exception {
121     AnalyzeSentimentResponse expectedResponse =
122         AnalyzeSentimentResponse.newBuilder()
123             .setDocumentSentiment(Sentiment.newBuilder().build())
124             .setLanguage("language-1613589672")
125             .addAllSentences(new ArrayList<Sentence>())
126             .build();
127     mockLanguageService.addResponse(expectedResponse);
128 
129     Document document = Document.newBuilder().build();
130     EncodingType encodingType = EncodingType.forNumber(0);
131 
132     AnalyzeSentimentResponse actualResponse = client.analyzeSentiment(document, encodingType);
133     Assert.assertEquals(expectedResponse, actualResponse);
134 
135     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
136     Assert.assertEquals(1, actualRequests.size());
137     AnalyzeSentimentRequest actualRequest = ((AnalyzeSentimentRequest) actualRequests.get(0));
138 
139     Assert.assertEquals(document, actualRequest.getDocument());
140     Assert.assertEquals(encodingType, actualRequest.getEncodingType());
141     Assert.assertTrue(
142         channelProvider.isHeaderSent(
143             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
144             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
145   }
146 
147   @Test
analyzeSentimentExceptionTest2()148   public void analyzeSentimentExceptionTest2() throws Exception {
149     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
150     mockLanguageService.addException(exception);
151 
152     try {
153       Document document = Document.newBuilder().build();
154       EncodingType encodingType = EncodingType.forNumber(0);
155       client.analyzeSentiment(document, encodingType);
156       Assert.fail("No exception raised");
157     } catch (InvalidArgumentException e) {
158       // Expected exception.
159     }
160   }
161 
162   @Test
analyzeEntitiesTest()163   public void analyzeEntitiesTest() throws Exception {
164     AnalyzeEntitiesResponse expectedResponse =
165         AnalyzeEntitiesResponse.newBuilder()
166             .addAllEntities(new ArrayList<Entity>())
167             .setLanguage("language-1613589672")
168             .build();
169     mockLanguageService.addResponse(expectedResponse);
170 
171     Document document = Document.newBuilder().build();
172 
173     AnalyzeEntitiesResponse actualResponse = client.analyzeEntities(document);
174     Assert.assertEquals(expectedResponse, actualResponse);
175 
176     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
177     Assert.assertEquals(1, actualRequests.size());
178     AnalyzeEntitiesRequest actualRequest = ((AnalyzeEntitiesRequest) actualRequests.get(0));
179 
180     Assert.assertEquals(document, actualRequest.getDocument());
181     Assert.assertTrue(
182         channelProvider.isHeaderSent(
183             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
184             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
185   }
186 
187   @Test
analyzeEntitiesExceptionTest()188   public void analyzeEntitiesExceptionTest() throws Exception {
189     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
190     mockLanguageService.addException(exception);
191 
192     try {
193       Document document = Document.newBuilder().build();
194       client.analyzeEntities(document);
195       Assert.fail("No exception raised");
196     } catch (InvalidArgumentException e) {
197       // Expected exception.
198     }
199   }
200 
201   @Test
analyzeEntitiesTest2()202   public void analyzeEntitiesTest2() throws Exception {
203     AnalyzeEntitiesResponse expectedResponse =
204         AnalyzeEntitiesResponse.newBuilder()
205             .addAllEntities(new ArrayList<Entity>())
206             .setLanguage("language-1613589672")
207             .build();
208     mockLanguageService.addResponse(expectedResponse);
209 
210     Document document = Document.newBuilder().build();
211     EncodingType encodingType = EncodingType.forNumber(0);
212 
213     AnalyzeEntitiesResponse actualResponse = client.analyzeEntities(document, encodingType);
214     Assert.assertEquals(expectedResponse, actualResponse);
215 
216     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
217     Assert.assertEquals(1, actualRequests.size());
218     AnalyzeEntitiesRequest actualRequest = ((AnalyzeEntitiesRequest) actualRequests.get(0));
219 
220     Assert.assertEquals(document, actualRequest.getDocument());
221     Assert.assertEquals(encodingType, actualRequest.getEncodingType());
222     Assert.assertTrue(
223         channelProvider.isHeaderSent(
224             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
225             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
226   }
227 
228   @Test
analyzeEntitiesExceptionTest2()229   public void analyzeEntitiesExceptionTest2() throws Exception {
230     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
231     mockLanguageService.addException(exception);
232 
233     try {
234       Document document = Document.newBuilder().build();
235       EncodingType encodingType = EncodingType.forNumber(0);
236       client.analyzeEntities(document, encodingType);
237       Assert.fail("No exception raised");
238     } catch (InvalidArgumentException e) {
239       // Expected exception.
240     }
241   }
242 
243   @Test
analyzeEntitySentimentTest()244   public void analyzeEntitySentimentTest() throws Exception {
245     AnalyzeEntitySentimentResponse expectedResponse =
246         AnalyzeEntitySentimentResponse.newBuilder()
247             .addAllEntities(new ArrayList<Entity>())
248             .setLanguage("language-1613589672")
249             .build();
250     mockLanguageService.addResponse(expectedResponse);
251 
252     Document document = Document.newBuilder().build();
253 
254     AnalyzeEntitySentimentResponse actualResponse = client.analyzeEntitySentiment(document);
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
258     Assert.assertEquals(1, actualRequests.size());
259     AnalyzeEntitySentimentRequest actualRequest =
260         ((AnalyzeEntitySentimentRequest) actualRequests.get(0));
261 
262     Assert.assertEquals(document, actualRequest.getDocument());
263     Assert.assertTrue(
264         channelProvider.isHeaderSent(
265             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
266             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
267   }
268 
269   @Test
analyzeEntitySentimentExceptionTest()270   public void analyzeEntitySentimentExceptionTest() throws Exception {
271     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
272     mockLanguageService.addException(exception);
273 
274     try {
275       Document document = Document.newBuilder().build();
276       client.analyzeEntitySentiment(document);
277       Assert.fail("No exception raised");
278     } catch (InvalidArgumentException e) {
279       // Expected exception.
280     }
281   }
282 
283   @Test
analyzeEntitySentimentTest2()284   public void analyzeEntitySentimentTest2() throws Exception {
285     AnalyzeEntitySentimentResponse expectedResponse =
286         AnalyzeEntitySentimentResponse.newBuilder()
287             .addAllEntities(new ArrayList<Entity>())
288             .setLanguage("language-1613589672")
289             .build();
290     mockLanguageService.addResponse(expectedResponse);
291 
292     Document document = Document.newBuilder().build();
293     EncodingType encodingType = EncodingType.forNumber(0);
294 
295     AnalyzeEntitySentimentResponse actualResponse =
296         client.analyzeEntitySentiment(document, encodingType);
297     Assert.assertEquals(expectedResponse, actualResponse);
298 
299     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
300     Assert.assertEquals(1, actualRequests.size());
301     AnalyzeEntitySentimentRequest actualRequest =
302         ((AnalyzeEntitySentimentRequest) actualRequests.get(0));
303 
304     Assert.assertEquals(document, actualRequest.getDocument());
305     Assert.assertEquals(encodingType, actualRequest.getEncodingType());
306     Assert.assertTrue(
307         channelProvider.isHeaderSent(
308             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
309             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
310   }
311 
312   @Test
analyzeEntitySentimentExceptionTest2()313   public void analyzeEntitySentimentExceptionTest2() throws Exception {
314     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
315     mockLanguageService.addException(exception);
316 
317     try {
318       Document document = Document.newBuilder().build();
319       EncodingType encodingType = EncodingType.forNumber(0);
320       client.analyzeEntitySentiment(document, encodingType);
321       Assert.fail("No exception raised");
322     } catch (InvalidArgumentException e) {
323       // Expected exception.
324     }
325   }
326 
327   @Test
analyzeSyntaxTest()328   public void analyzeSyntaxTest() throws Exception {
329     AnalyzeSyntaxResponse expectedResponse =
330         AnalyzeSyntaxResponse.newBuilder()
331             .addAllSentences(new ArrayList<Sentence>())
332             .addAllTokens(new ArrayList<Token>())
333             .setLanguage("language-1613589672")
334             .build();
335     mockLanguageService.addResponse(expectedResponse);
336 
337     Document document = Document.newBuilder().build();
338 
339     AnalyzeSyntaxResponse actualResponse = client.analyzeSyntax(document);
340     Assert.assertEquals(expectedResponse, actualResponse);
341 
342     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
343     Assert.assertEquals(1, actualRequests.size());
344     AnalyzeSyntaxRequest actualRequest = ((AnalyzeSyntaxRequest) actualRequests.get(0));
345 
346     Assert.assertEquals(document, actualRequest.getDocument());
347     Assert.assertTrue(
348         channelProvider.isHeaderSent(
349             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
350             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
351   }
352 
353   @Test
analyzeSyntaxExceptionTest()354   public void analyzeSyntaxExceptionTest() throws Exception {
355     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
356     mockLanguageService.addException(exception);
357 
358     try {
359       Document document = Document.newBuilder().build();
360       client.analyzeSyntax(document);
361       Assert.fail("No exception raised");
362     } catch (InvalidArgumentException e) {
363       // Expected exception.
364     }
365   }
366 
367   @Test
analyzeSyntaxTest2()368   public void analyzeSyntaxTest2() throws Exception {
369     AnalyzeSyntaxResponse expectedResponse =
370         AnalyzeSyntaxResponse.newBuilder()
371             .addAllSentences(new ArrayList<Sentence>())
372             .addAllTokens(new ArrayList<Token>())
373             .setLanguage("language-1613589672")
374             .build();
375     mockLanguageService.addResponse(expectedResponse);
376 
377     Document document = Document.newBuilder().build();
378     EncodingType encodingType = EncodingType.forNumber(0);
379 
380     AnalyzeSyntaxResponse actualResponse = client.analyzeSyntax(document, encodingType);
381     Assert.assertEquals(expectedResponse, actualResponse);
382 
383     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
384     Assert.assertEquals(1, actualRequests.size());
385     AnalyzeSyntaxRequest actualRequest = ((AnalyzeSyntaxRequest) actualRequests.get(0));
386 
387     Assert.assertEquals(document, actualRequest.getDocument());
388     Assert.assertEquals(encodingType, actualRequest.getEncodingType());
389     Assert.assertTrue(
390         channelProvider.isHeaderSent(
391             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
392             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
393   }
394 
395   @Test
analyzeSyntaxExceptionTest2()396   public void analyzeSyntaxExceptionTest2() throws Exception {
397     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
398     mockLanguageService.addException(exception);
399 
400     try {
401       Document document = Document.newBuilder().build();
402       EncodingType encodingType = EncodingType.forNumber(0);
403       client.analyzeSyntax(document, encodingType);
404       Assert.fail("No exception raised");
405     } catch (InvalidArgumentException e) {
406       // Expected exception.
407     }
408   }
409 
410   @Test
classifyTextTest()411   public void classifyTextTest() throws Exception {
412     ClassifyTextResponse expectedResponse =
413         ClassifyTextResponse.newBuilder()
414             .addAllCategories(new ArrayList<ClassificationCategory>())
415             .build();
416     mockLanguageService.addResponse(expectedResponse);
417 
418     Document document = Document.newBuilder().build();
419 
420     ClassifyTextResponse actualResponse = client.classifyText(document);
421     Assert.assertEquals(expectedResponse, actualResponse);
422 
423     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
424     Assert.assertEquals(1, actualRequests.size());
425     ClassifyTextRequest actualRequest = ((ClassifyTextRequest) actualRequests.get(0));
426 
427     Assert.assertEquals(document, actualRequest.getDocument());
428     Assert.assertTrue(
429         channelProvider.isHeaderSent(
430             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
431             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
432   }
433 
434   @Test
classifyTextExceptionTest()435   public void classifyTextExceptionTest() throws Exception {
436     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
437     mockLanguageService.addException(exception);
438 
439     try {
440       Document document = Document.newBuilder().build();
441       client.classifyText(document);
442       Assert.fail("No exception raised");
443     } catch (InvalidArgumentException e) {
444       // Expected exception.
445     }
446   }
447 
448   @Test
annotateTextTest()449   public void annotateTextTest() throws Exception {
450     AnnotateTextResponse expectedResponse =
451         AnnotateTextResponse.newBuilder()
452             .addAllSentences(new ArrayList<Sentence>())
453             .addAllTokens(new ArrayList<Token>())
454             .addAllEntities(new ArrayList<Entity>())
455             .setDocumentSentiment(Sentiment.newBuilder().build())
456             .setLanguage("language-1613589672")
457             .addAllCategories(new ArrayList<ClassificationCategory>())
458             .build();
459     mockLanguageService.addResponse(expectedResponse);
460 
461     Document document = Document.newBuilder().build();
462     AnnotateTextRequest.Features features = AnnotateTextRequest.Features.newBuilder().build();
463 
464     AnnotateTextResponse actualResponse = client.annotateText(document, features);
465     Assert.assertEquals(expectedResponse, actualResponse);
466 
467     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
468     Assert.assertEquals(1, actualRequests.size());
469     AnnotateTextRequest actualRequest = ((AnnotateTextRequest) actualRequests.get(0));
470 
471     Assert.assertEquals(document, actualRequest.getDocument());
472     Assert.assertEquals(features, actualRequest.getFeatures());
473     Assert.assertTrue(
474         channelProvider.isHeaderSent(
475             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
476             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
477   }
478 
479   @Test
annotateTextExceptionTest()480   public void annotateTextExceptionTest() throws Exception {
481     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
482     mockLanguageService.addException(exception);
483 
484     try {
485       Document document = Document.newBuilder().build();
486       AnnotateTextRequest.Features features = AnnotateTextRequest.Features.newBuilder().build();
487       client.annotateText(document, features);
488       Assert.fail("No exception raised");
489     } catch (InvalidArgumentException e) {
490       // Expected exception.
491     }
492   }
493 
494   @Test
annotateTextTest2()495   public void annotateTextTest2() throws Exception {
496     AnnotateTextResponse expectedResponse =
497         AnnotateTextResponse.newBuilder()
498             .addAllSentences(new ArrayList<Sentence>())
499             .addAllTokens(new ArrayList<Token>())
500             .addAllEntities(new ArrayList<Entity>())
501             .setDocumentSentiment(Sentiment.newBuilder().build())
502             .setLanguage("language-1613589672")
503             .addAllCategories(new ArrayList<ClassificationCategory>())
504             .build();
505     mockLanguageService.addResponse(expectedResponse);
506 
507     Document document = Document.newBuilder().build();
508     AnnotateTextRequest.Features features = AnnotateTextRequest.Features.newBuilder().build();
509     EncodingType encodingType = EncodingType.forNumber(0);
510 
511     AnnotateTextResponse actualResponse = client.annotateText(document, features, encodingType);
512     Assert.assertEquals(expectedResponse, actualResponse);
513 
514     List<AbstractMessage> actualRequests = mockLanguageService.getRequests();
515     Assert.assertEquals(1, actualRequests.size());
516     AnnotateTextRequest actualRequest = ((AnnotateTextRequest) actualRequests.get(0));
517 
518     Assert.assertEquals(document, actualRequest.getDocument());
519     Assert.assertEquals(features, actualRequest.getFeatures());
520     Assert.assertEquals(encodingType, actualRequest.getEncodingType());
521     Assert.assertTrue(
522         channelProvider.isHeaderSent(
523             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
524             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
525   }
526 
527   @Test
annotateTextExceptionTest2()528   public void annotateTextExceptionTest2() throws Exception {
529     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
530     mockLanguageService.addException(exception);
531 
532     try {
533       Document document = Document.newBuilder().build();
534       AnnotateTextRequest.Features features = AnnotateTextRequest.Features.newBuilder().build();
535       EncodingType encodingType = EncodingType.forNumber(0);
536       client.annotateText(document, features, encodingType);
537       Assert.fail("No exception raised");
538     } catch (InvalidArgumentException e) {
539       // Expected exception.
540     }
541   }
542 }
543