• 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.translate.v3beta1;
18 
19 import static com.google.cloud.translate.v3beta1.TranslationServiceClient.ListGlossariesPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.grpc.GaxGrpcProperties;
23 import com.google.api.gax.grpc.testing.LocalChannelProvider;
24 import com.google.api.gax.grpc.testing.MockGrpcService;
25 import com.google.api.gax.grpc.testing.MockServiceHelper;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Timestamp;
34 import io.grpc.StatusRuntimeException;
35 import java.io.IOException;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.HashMap;
39 import java.util.List;
40 import java.util.UUID;
41 import java.util.concurrent.ExecutionException;
42 import javax.annotation.Generated;
43 import org.junit.After;
44 import org.junit.AfterClass;
45 import org.junit.Assert;
46 import org.junit.Before;
47 import org.junit.BeforeClass;
48 import org.junit.Test;
49 
50 @Generated("by gapic-generator-java")
51 public class TranslationServiceClientTest {
52   private static MockServiceHelper mockServiceHelper;
53   private static MockTranslationService mockTranslationService;
54   private LocalChannelProvider channelProvider;
55   private TranslationServiceClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() {
59     mockTranslationService = new MockTranslationService();
60     mockServiceHelper =
61         new MockServiceHelper(
62             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockTranslationService));
63     mockServiceHelper.start();
64   }
65 
66   @AfterClass
stopServer()67   public static void stopServer() {
68     mockServiceHelper.stop();
69   }
70 
71   @Before
setUp()72   public void setUp() throws IOException {
73     mockServiceHelper.reset();
74     channelProvider = mockServiceHelper.createChannelProvider();
75     TranslationServiceSettings settings =
76         TranslationServiceSettings.newBuilder()
77             .setTransportChannelProvider(channelProvider)
78             .setCredentialsProvider(NoCredentialsProvider.create())
79             .build();
80     client = TranslationServiceClient.create(settings);
81   }
82 
83   @After
tearDown()84   public void tearDown() throws Exception {
85     client.close();
86   }
87 
88   @Test
translateTextTest()89   public void translateTextTest() throws Exception {
90     TranslateTextResponse expectedResponse =
91         TranslateTextResponse.newBuilder()
92             .addAllTranslations(new ArrayList<Translation>())
93             .addAllGlossaryTranslations(new ArrayList<Translation>())
94             .build();
95     mockTranslationService.addResponse(expectedResponse);
96 
97     TranslateTextRequest request =
98         TranslateTextRequest.newBuilder()
99             .addAllContents(new ArrayList<String>())
100             .setMimeType("mimeType-1392120434")
101             .setSourceLanguageCode("sourceLanguageCode1645917472")
102             .setTargetLanguageCode("targetLanguageCode-106414698")
103             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
104             .setModel("model104069929")
105             .setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder().build())
106             .putAllLabels(new HashMap<String, String>())
107             .build();
108 
109     TranslateTextResponse actualResponse = client.translateText(request);
110     Assert.assertEquals(expectedResponse, actualResponse);
111 
112     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
113     Assert.assertEquals(1, actualRequests.size());
114     TranslateTextRequest actualRequest = ((TranslateTextRequest) actualRequests.get(0));
115 
116     Assert.assertEquals(request.getContentsList(), actualRequest.getContentsList());
117     Assert.assertEquals(request.getMimeType(), actualRequest.getMimeType());
118     Assert.assertEquals(request.getSourceLanguageCode(), actualRequest.getSourceLanguageCode());
119     Assert.assertEquals(request.getTargetLanguageCode(), actualRequest.getTargetLanguageCode());
120     Assert.assertEquals(request.getParent(), actualRequest.getParent());
121     Assert.assertEquals(request.getModel(), actualRequest.getModel());
122     Assert.assertEquals(request.getGlossaryConfig(), actualRequest.getGlossaryConfig());
123     Assert.assertEquals(request.getLabelsMap(), actualRequest.getLabelsMap());
124     Assert.assertTrue(
125         channelProvider.isHeaderSent(
126             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
127             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
128   }
129 
130   @Test
translateTextExceptionTest()131   public void translateTextExceptionTest() throws Exception {
132     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
133     mockTranslationService.addException(exception);
134 
135     try {
136       TranslateTextRequest request =
137           TranslateTextRequest.newBuilder()
138               .addAllContents(new ArrayList<String>())
139               .setMimeType("mimeType-1392120434")
140               .setSourceLanguageCode("sourceLanguageCode1645917472")
141               .setTargetLanguageCode("targetLanguageCode-106414698")
142               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
143               .setModel("model104069929")
144               .setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder().build())
145               .putAllLabels(new HashMap<String, String>())
146               .build();
147       client.translateText(request);
148       Assert.fail("No exception raised");
149     } catch (InvalidArgumentException e) {
150       // Expected exception.
151     }
152   }
153 
154   @Test
detectLanguageTest()155   public void detectLanguageTest() throws Exception {
156     DetectLanguageResponse expectedResponse =
157         DetectLanguageResponse.newBuilder()
158             .addAllLanguages(new ArrayList<DetectedLanguage>())
159             .build();
160     mockTranslationService.addResponse(expectedResponse);
161 
162     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
163     String model = "model104069929";
164     String mimeType = "mimeType-1392120434";
165 
166     DetectLanguageResponse actualResponse = client.detectLanguage(parent, model, mimeType);
167     Assert.assertEquals(expectedResponse, actualResponse);
168 
169     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
170     Assert.assertEquals(1, actualRequests.size());
171     DetectLanguageRequest actualRequest = ((DetectLanguageRequest) actualRequests.get(0));
172 
173     Assert.assertEquals(parent.toString(), actualRequest.getParent());
174     Assert.assertEquals(model, actualRequest.getModel());
175     Assert.assertEquals(mimeType, actualRequest.getMimeType());
176     Assert.assertTrue(
177         channelProvider.isHeaderSent(
178             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
179             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
180   }
181 
182   @Test
detectLanguageExceptionTest()183   public void detectLanguageExceptionTest() throws Exception {
184     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
185     mockTranslationService.addException(exception);
186 
187     try {
188       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
189       String model = "model104069929";
190       String mimeType = "mimeType-1392120434";
191       client.detectLanguage(parent, model, mimeType);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
detectLanguageTest2()199   public void detectLanguageTest2() throws Exception {
200     DetectLanguageResponse expectedResponse =
201         DetectLanguageResponse.newBuilder()
202             .addAllLanguages(new ArrayList<DetectedLanguage>())
203             .build();
204     mockTranslationService.addResponse(expectedResponse);
205 
206     String parent = "parent-995424086";
207     String model = "model104069929";
208     String mimeType = "mimeType-1392120434";
209 
210     DetectLanguageResponse actualResponse = client.detectLanguage(parent, model, mimeType);
211     Assert.assertEquals(expectedResponse, actualResponse);
212 
213     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
214     Assert.assertEquals(1, actualRequests.size());
215     DetectLanguageRequest actualRequest = ((DetectLanguageRequest) actualRequests.get(0));
216 
217     Assert.assertEquals(parent, actualRequest.getParent());
218     Assert.assertEquals(model, actualRequest.getModel());
219     Assert.assertEquals(mimeType, actualRequest.getMimeType());
220     Assert.assertTrue(
221         channelProvider.isHeaderSent(
222             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
223             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
224   }
225 
226   @Test
detectLanguageExceptionTest2()227   public void detectLanguageExceptionTest2() throws Exception {
228     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
229     mockTranslationService.addException(exception);
230 
231     try {
232       String parent = "parent-995424086";
233       String model = "model104069929";
234       String mimeType = "mimeType-1392120434";
235       client.detectLanguage(parent, model, mimeType);
236       Assert.fail("No exception raised");
237     } catch (InvalidArgumentException e) {
238       // Expected exception.
239     }
240   }
241 
242   @Test
getSupportedLanguagesTest()243   public void getSupportedLanguagesTest() throws Exception {
244     SupportedLanguages expectedResponse =
245         SupportedLanguages.newBuilder().addAllLanguages(new ArrayList<SupportedLanguage>()).build();
246     mockTranslationService.addResponse(expectedResponse);
247 
248     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
249     String displayLanguageCode = "displayLanguageCode-1457478841";
250     String model = "model104069929";
251 
252     SupportedLanguages actualResponse =
253         client.getSupportedLanguages(parent, displayLanguageCode, model);
254     Assert.assertEquals(expectedResponse, actualResponse);
255 
256     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
257     Assert.assertEquals(1, actualRequests.size());
258     GetSupportedLanguagesRequest actualRequest =
259         ((GetSupportedLanguagesRequest) actualRequests.get(0));
260 
261     Assert.assertEquals(parent.toString(), actualRequest.getParent());
262     Assert.assertEquals(displayLanguageCode, actualRequest.getDisplayLanguageCode());
263     Assert.assertEquals(model, actualRequest.getModel());
264     Assert.assertTrue(
265         channelProvider.isHeaderSent(
266             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
267             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
268   }
269 
270   @Test
getSupportedLanguagesExceptionTest()271   public void getSupportedLanguagesExceptionTest() throws Exception {
272     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
273     mockTranslationService.addException(exception);
274 
275     try {
276       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
277       String displayLanguageCode = "displayLanguageCode-1457478841";
278       String model = "model104069929";
279       client.getSupportedLanguages(parent, displayLanguageCode, model);
280       Assert.fail("No exception raised");
281     } catch (InvalidArgumentException e) {
282       // Expected exception.
283     }
284   }
285 
286   @Test
getSupportedLanguagesTest2()287   public void getSupportedLanguagesTest2() throws Exception {
288     SupportedLanguages expectedResponse =
289         SupportedLanguages.newBuilder().addAllLanguages(new ArrayList<SupportedLanguage>()).build();
290     mockTranslationService.addResponse(expectedResponse);
291 
292     String parent = "parent-995424086";
293     String displayLanguageCode = "displayLanguageCode-1457478841";
294     String model = "model104069929";
295 
296     SupportedLanguages actualResponse =
297         client.getSupportedLanguages(parent, displayLanguageCode, model);
298     Assert.assertEquals(expectedResponse, actualResponse);
299 
300     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
301     Assert.assertEquals(1, actualRequests.size());
302     GetSupportedLanguagesRequest actualRequest =
303         ((GetSupportedLanguagesRequest) actualRequests.get(0));
304 
305     Assert.assertEquals(parent, actualRequest.getParent());
306     Assert.assertEquals(displayLanguageCode, actualRequest.getDisplayLanguageCode());
307     Assert.assertEquals(model, actualRequest.getModel());
308     Assert.assertTrue(
309         channelProvider.isHeaderSent(
310             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
311             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
312   }
313 
314   @Test
getSupportedLanguagesExceptionTest2()315   public void getSupportedLanguagesExceptionTest2() throws Exception {
316     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
317     mockTranslationService.addException(exception);
318 
319     try {
320       String parent = "parent-995424086";
321       String displayLanguageCode = "displayLanguageCode-1457478841";
322       String model = "model104069929";
323       client.getSupportedLanguages(parent, displayLanguageCode, model);
324       Assert.fail("No exception raised");
325     } catch (InvalidArgumentException e) {
326       // Expected exception.
327     }
328   }
329 
330   @Test
translateDocumentTest()331   public void translateDocumentTest() throws Exception {
332     TranslateDocumentResponse expectedResponse =
333         TranslateDocumentResponse.newBuilder()
334             .setDocumentTranslation(DocumentTranslation.newBuilder().build())
335             .setGlossaryDocumentTranslation(DocumentTranslation.newBuilder().build())
336             .setModel("model104069929")
337             .setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder().build())
338             .build();
339     mockTranslationService.addResponse(expectedResponse);
340 
341     TranslateDocumentRequest request =
342         TranslateDocumentRequest.newBuilder()
343             .setParent("parent-995424086")
344             .setSourceLanguageCode("sourceLanguageCode1645917472")
345             .setTargetLanguageCode("targetLanguageCode-106414698")
346             .setDocumentInputConfig(DocumentInputConfig.newBuilder().build())
347             .setDocumentOutputConfig(DocumentOutputConfig.newBuilder().build())
348             .setModel("model104069929")
349             .setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder().build())
350             .putAllLabels(new HashMap<String, String>())
351             .build();
352 
353     TranslateDocumentResponse actualResponse = client.translateDocument(request);
354     Assert.assertEquals(expectedResponse, actualResponse);
355 
356     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
357     Assert.assertEquals(1, actualRequests.size());
358     TranslateDocumentRequest actualRequest = ((TranslateDocumentRequest) actualRequests.get(0));
359 
360     Assert.assertEquals(request.getParent(), actualRequest.getParent());
361     Assert.assertEquals(request.getSourceLanguageCode(), actualRequest.getSourceLanguageCode());
362     Assert.assertEquals(request.getTargetLanguageCode(), actualRequest.getTargetLanguageCode());
363     Assert.assertEquals(request.getDocumentInputConfig(), actualRequest.getDocumentInputConfig());
364     Assert.assertEquals(request.getDocumentOutputConfig(), actualRequest.getDocumentOutputConfig());
365     Assert.assertEquals(request.getModel(), actualRequest.getModel());
366     Assert.assertEquals(request.getGlossaryConfig(), actualRequest.getGlossaryConfig());
367     Assert.assertEquals(request.getLabelsMap(), actualRequest.getLabelsMap());
368     Assert.assertTrue(
369         channelProvider.isHeaderSent(
370             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
371             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
372   }
373 
374   @Test
translateDocumentExceptionTest()375   public void translateDocumentExceptionTest() throws Exception {
376     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
377     mockTranslationService.addException(exception);
378 
379     try {
380       TranslateDocumentRequest request =
381           TranslateDocumentRequest.newBuilder()
382               .setParent("parent-995424086")
383               .setSourceLanguageCode("sourceLanguageCode1645917472")
384               .setTargetLanguageCode("targetLanguageCode-106414698")
385               .setDocumentInputConfig(DocumentInputConfig.newBuilder().build())
386               .setDocumentOutputConfig(DocumentOutputConfig.newBuilder().build())
387               .setModel("model104069929")
388               .setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder().build())
389               .putAllLabels(new HashMap<String, String>())
390               .build();
391       client.translateDocument(request);
392       Assert.fail("No exception raised");
393     } catch (InvalidArgumentException e) {
394       // Expected exception.
395     }
396   }
397 
398   @Test
batchTranslateTextTest()399   public void batchTranslateTextTest() throws Exception {
400     BatchTranslateResponse expectedResponse =
401         BatchTranslateResponse.newBuilder()
402             .setTotalCharacters(-1368640955)
403             .setTranslatedCharacters(-1337326221)
404             .setFailedCharacters(1723028396)
405             .setSubmitTime(Timestamp.newBuilder().build())
406             .setEndTime(Timestamp.newBuilder().build())
407             .build();
408     Operation resultOperation =
409         Operation.newBuilder()
410             .setName("batchTranslateTextTest")
411             .setDone(true)
412             .setResponse(Any.pack(expectedResponse))
413             .build();
414     mockTranslationService.addResponse(resultOperation);
415 
416     BatchTranslateTextRequest request =
417         BatchTranslateTextRequest.newBuilder()
418             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
419             .setSourceLanguageCode("sourceLanguageCode1645917472")
420             .addAllTargetLanguageCodes(new ArrayList<String>())
421             .putAllModels(new HashMap<String, String>())
422             .addAllInputConfigs(new ArrayList<InputConfig>())
423             .setOutputConfig(OutputConfig.newBuilder().build())
424             .putAllGlossaries(new HashMap<String, TranslateTextGlossaryConfig>())
425             .putAllLabels(new HashMap<String, String>())
426             .build();
427 
428     BatchTranslateResponse actualResponse = client.batchTranslateTextAsync(request).get();
429     Assert.assertEquals(expectedResponse, actualResponse);
430 
431     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
432     Assert.assertEquals(1, actualRequests.size());
433     BatchTranslateTextRequest actualRequest = ((BatchTranslateTextRequest) actualRequests.get(0));
434 
435     Assert.assertEquals(request.getParent(), actualRequest.getParent());
436     Assert.assertEquals(request.getSourceLanguageCode(), actualRequest.getSourceLanguageCode());
437     Assert.assertEquals(
438         request.getTargetLanguageCodesList(), actualRequest.getTargetLanguageCodesList());
439     Assert.assertEquals(request.getModelsMap(), actualRequest.getModelsMap());
440     Assert.assertEquals(request.getInputConfigsList(), actualRequest.getInputConfigsList());
441     Assert.assertEquals(request.getOutputConfig(), actualRequest.getOutputConfig());
442     Assert.assertEquals(request.getGlossariesMap(), actualRequest.getGlossariesMap());
443     Assert.assertEquals(request.getLabelsMap(), actualRequest.getLabelsMap());
444     Assert.assertTrue(
445         channelProvider.isHeaderSent(
446             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
447             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
448   }
449 
450   @Test
batchTranslateTextExceptionTest()451   public void batchTranslateTextExceptionTest() throws Exception {
452     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
453     mockTranslationService.addException(exception);
454 
455     try {
456       BatchTranslateTextRequest request =
457           BatchTranslateTextRequest.newBuilder()
458               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
459               .setSourceLanguageCode("sourceLanguageCode1645917472")
460               .addAllTargetLanguageCodes(new ArrayList<String>())
461               .putAllModels(new HashMap<String, String>())
462               .addAllInputConfigs(new ArrayList<InputConfig>())
463               .setOutputConfig(OutputConfig.newBuilder().build())
464               .putAllGlossaries(new HashMap<String, TranslateTextGlossaryConfig>())
465               .putAllLabels(new HashMap<String, String>())
466               .build();
467       client.batchTranslateTextAsync(request).get();
468       Assert.fail("No exception raised");
469     } catch (ExecutionException e) {
470       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
471       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
472       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
473     }
474   }
475 
476   @Test
batchTranslateDocumentTest()477   public void batchTranslateDocumentTest() throws Exception {
478     BatchTranslateDocumentResponse expectedResponse =
479         BatchTranslateDocumentResponse.newBuilder()
480             .setTotalPages(-396186871)
481             .setTranslatedPages(-1652747493)
482             .setFailedPages(-2002254526)
483             .setTotalBillablePages(1292117569)
484             .setTotalCharacters(-1368640955)
485             .setTranslatedCharacters(-1337326221)
486             .setFailedCharacters(1723028396)
487             .setTotalBillableCharacters(1242495501)
488             .setSubmitTime(Timestamp.newBuilder().build())
489             .setEndTime(Timestamp.newBuilder().build())
490             .build();
491     Operation resultOperation =
492         Operation.newBuilder()
493             .setName("batchTranslateDocumentTest")
494             .setDone(true)
495             .setResponse(Any.pack(expectedResponse))
496             .build();
497     mockTranslationService.addResponse(resultOperation);
498 
499     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
500     String sourceLanguageCode = "sourceLanguageCode1645917472";
501     List<String> targetLanguageCodes = new ArrayList<>();
502     List<BatchDocumentInputConfig> inputConfigs = new ArrayList<>();
503     BatchDocumentOutputConfig outputConfig = BatchDocumentOutputConfig.newBuilder().build();
504 
505     BatchTranslateDocumentResponse actualResponse =
506         client
507             .batchTranslateDocumentAsync(
508                 parent, sourceLanguageCode, targetLanguageCodes, inputConfigs, outputConfig)
509             .get();
510     Assert.assertEquals(expectedResponse, actualResponse);
511 
512     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
513     Assert.assertEquals(1, actualRequests.size());
514     BatchTranslateDocumentRequest actualRequest =
515         ((BatchTranslateDocumentRequest) actualRequests.get(0));
516 
517     Assert.assertEquals(parent.toString(), actualRequest.getParent());
518     Assert.assertEquals(sourceLanguageCode, actualRequest.getSourceLanguageCode());
519     Assert.assertEquals(targetLanguageCodes, actualRequest.getTargetLanguageCodesList());
520     Assert.assertEquals(inputConfigs, actualRequest.getInputConfigsList());
521     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
522     Assert.assertTrue(
523         channelProvider.isHeaderSent(
524             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
525             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
526   }
527 
528   @Test
batchTranslateDocumentExceptionTest()529   public void batchTranslateDocumentExceptionTest() throws Exception {
530     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
531     mockTranslationService.addException(exception);
532 
533     try {
534       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
535       String sourceLanguageCode = "sourceLanguageCode1645917472";
536       List<String> targetLanguageCodes = new ArrayList<>();
537       List<BatchDocumentInputConfig> inputConfigs = new ArrayList<>();
538       BatchDocumentOutputConfig outputConfig = BatchDocumentOutputConfig.newBuilder().build();
539       client
540           .batchTranslateDocumentAsync(
541               parent, sourceLanguageCode, targetLanguageCodes, inputConfigs, outputConfig)
542           .get();
543       Assert.fail("No exception raised");
544     } catch (ExecutionException e) {
545       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
546       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
547       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
548     }
549   }
550 
551   @Test
batchTranslateDocumentTest2()552   public void batchTranslateDocumentTest2() throws Exception {
553     BatchTranslateDocumentResponse expectedResponse =
554         BatchTranslateDocumentResponse.newBuilder()
555             .setTotalPages(-396186871)
556             .setTranslatedPages(-1652747493)
557             .setFailedPages(-2002254526)
558             .setTotalBillablePages(1292117569)
559             .setTotalCharacters(-1368640955)
560             .setTranslatedCharacters(-1337326221)
561             .setFailedCharacters(1723028396)
562             .setTotalBillableCharacters(1242495501)
563             .setSubmitTime(Timestamp.newBuilder().build())
564             .setEndTime(Timestamp.newBuilder().build())
565             .build();
566     Operation resultOperation =
567         Operation.newBuilder()
568             .setName("batchTranslateDocumentTest")
569             .setDone(true)
570             .setResponse(Any.pack(expectedResponse))
571             .build();
572     mockTranslationService.addResponse(resultOperation);
573 
574     String parent = "parent-995424086";
575     String sourceLanguageCode = "sourceLanguageCode1645917472";
576     List<String> targetLanguageCodes = new ArrayList<>();
577     List<BatchDocumentInputConfig> inputConfigs = new ArrayList<>();
578     BatchDocumentOutputConfig outputConfig = BatchDocumentOutputConfig.newBuilder().build();
579 
580     BatchTranslateDocumentResponse actualResponse =
581         client
582             .batchTranslateDocumentAsync(
583                 parent, sourceLanguageCode, targetLanguageCodes, inputConfigs, outputConfig)
584             .get();
585     Assert.assertEquals(expectedResponse, actualResponse);
586 
587     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
588     Assert.assertEquals(1, actualRequests.size());
589     BatchTranslateDocumentRequest actualRequest =
590         ((BatchTranslateDocumentRequest) actualRequests.get(0));
591 
592     Assert.assertEquals(parent, actualRequest.getParent());
593     Assert.assertEquals(sourceLanguageCode, actualRequest.getSourceLanguageCode());
594     Assert.assertEquals(targetLanguageCodes, actualRequest.getTargetLanguageCodesList());
595     Assert.assertEquals(inputConfigs, actualRequest.getInputConfigsList());
596     Assert.assertEquals(outputConfig, actualRequest.getOutputConfig());
597     Assert.assertTrue(
598         channelProvider.isHeaderSent(
599             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
600             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
601   }
602 
603   @Test
batchTranslateDocumentExceptionTest2()604   public void batchTranslateDocumentExceptionTest2() throws Exception {
605     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
606     mockTranslationService.addException(exception);
607 
608     try {
609       String parent = "parent-995424086";
610       String sourceLanguageCode = "sourceLanguageCode1645917472";
611       List<String> targetLanguageCodes = new ArrayList<>();
612       List<BatchDocumentInputConfig> inputConfigs = new ArrayList<>();
613       BatchDocumentOutputConfig outputConfig = BatchDocumentOutputConfig.newBuilder().build();
614       client
615           .batchTranslateDocumentAsync(
616               parent, sourceLanguageCode, targetLanguageCodes, inputConfigs, outputConfig)
617           .get();
618       Assert.fail("No exception raised");
619     } catch (ExecutionException e) {
620       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
621       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
622       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
623     }
624   }
625 
626   @Test
createGlossaryTest()627   public void createGlossaryTest() throws Exception {
628     Glossary expectedResponse =
629         Glossary.newBuilder()
630             .setName(GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]").toString())
631             .setInputConfig(GlossaryInputConfig.newBuilder().build())
632             .setEntryCount(-811131134)
633             .setSubmitTime(Timestamp.newBuilder().build())
634             .setEndTime(Timestamp.newBuilder().build())
635             .build();
636     Operation resultOperation =
637         Operation.newBuilder()
638             .setName("createGlossaryTest")
639             .setDone(true)
640             .setResponse(Any.pack(expectedResponse))
641             .build();
642     mockTranslationService.addResponse(resultOperation);
643 
644     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
645     Glossary glossary = Glossary.newBuilder().build();
646 
647     Glossary actualResponse = client.createGlossaryAsync(parent, glossary).get();
648     Assert.assertEquals(expectedResponse, actualResponse);
649 
650     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
651     Assert.assertEquals(1, actualRequests.size());
652     CreateGlossaryRequest actualRequest = ((CreateGlossaryRequest) actualRequests.get(0));
653 
654     Assert.assertEquals(parent.toString(), actualRequest.getParent());
655     Assert.assertEquals(glossary, actualRequest.getGlossary());
656     Assert.assertTrue(
657         channelProvider.isHeaderSent(
658             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
659             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
660   }
661 
662   @Test
createGlossaryExceptionTest()663   public void createGlossaryExceptionTest() throws Exception {
664     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
665     mockTranslationService.addException(exception);
666 
667     try {
668       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
669       Glossary glossary = Glossary.newBuilder().build();
670       client.createGlossaryAsync(parent, glossary).get();
671       Assert.fail("No exception raised");
672     } catch (ExecutionException e) {
673       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
674       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
675       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
676     }
677   }
678 
679   @Test
createGlossaryTest2()680   public void createGlossaryTest2() throws Exception {
681     Glossary expectedResponse =
682         Glossary.newBuilder()
683             .setName(GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]").toString())
684             .setInputConfig(GlossaryInputConfig.newBuilder().build())
685             .setEntryCount(-811131134)
686             .setSubmitTime(Timestamp.newBuilder().build())
687             .setEndTime(Timestamp.newBuilder().build())
688             .build();
689     Operation resultOperation =
690         Operation.newBuilder()
691             .setName("createGlossaryTest")
692             .setDone(true)
693             .setResponse(Any.pack(expectedResponse))
694             .build();
695     mockTranslationService.addResponse(resultOperation);
696 
697     String parent = "parent-995424086";
698     Glossary glossary = Glossary.newBuilder().build();
699 
700     Glossary actualResponse = client.createGlossaryAsync(parent, glossary).get();
701     Assert.assertEquals(expectedResponse, actualResponse);
702 
703     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
704     Assert.assertEquals(1, actualRequests.size());
705     CreateGlossaryRequest actualRequest = ((CreateGlossaryRequest) actualRequests.get(0));
706 
707     Assert.assertEquals(parent, actualRequest.getParent());
708     Assert.assertEquals(glossary, actualRequest.getGlossary());
709     Assert.assertTrue(
710         channelProvider.isHeaderSent(
711             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
712             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
713   }
714 
715   @Test
createGlossaryExceptionTest2()716   public void createGlossaryExceptionTest2() throws Exception {
717     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
718     mockTranslationService.addException(exception);
719 
720     try {
721       String parent = "parent-995424086";
722       Glossary glossary = Glossary.newBuilder().build();
723       client.createGlossaryAsync(parent, glossary).get();
724       Assert.fail("No exception raised");
725     } catch (ExecutionException e) {
726       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
727       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
728       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
729     }
730   }
731 
732   @Test
listGlossariesTest()733   public void listGlossariesTest() throws Exception {
734     Glossary responsesElement = Glossary.newBuilder().build();
735     ListGlossariesResponse expectedResponse =
736         ListGlossariesResponse.newBuilder()
737             .setNextPageToken("")
738             .addAllGlossaries(Arrays.asList(responsesElement))
739             .build();
740     mockTranslationService.addResponse(expectedResponse);
741 
742     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
743     String filter = "filter-1274492040";
744 
745     ListGlossariesPagedResponse pagedListResponse = client.listGlossaries(parent, filter);
746 
747     List<Glossary> resources = Lists.newArrayList(pagedListResponse.iterateAll());
748 
749     Assert.assertEquals(1, resources.size());
750     Assert.assertEquals(expectedResponse.getGlossariesList().get(0), resources.get(0));
751 
752     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
753     Assert.assertEquals(1, actualRequests.size());
754     ListGlossariesRequest actualRequest = ((ListGlossariesRequest) actualRequests.get(0));
755 
756     Assert.assertEquals(parent.toString(), actualRequest.getParent());
757     Assert.assertEquals(filter, actualRequest.getFilter());
758     Assert.assertTrue(
759         channelProvider.isHeaderSent(
760             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
761             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
762   }
763 
764   @Test
listGlossariesExceptionTest()765   public void listGlossariesExceptionTest() throws Exception {
766     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
767     mockTranslationService.addException(exception);
768 
769     try {
770       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
771       String filter = "filter-1274492040";
772       client.listGlossaries(parent, filter);
773       Assert.fail("No exception raised");
774     } catch (InvalidArgumentException e) {
775       // Expected exception.
776     }
777   }
778 
779   @Test
listGlossariesTest2()780   public void listGlossariesTest2() throws Exception {
781     Glossary responsesElement = Glossary.newBuilder().build();
782     ListGlossariesResponse expectedResponse =
783         ListGlossariesResponse.newBuilder()
784             .setNextPageToken("")
785             .addAllGlossaries(Arrays.asList(responsesElement))
786             .build();
787     mockTranslationService.addResponse(expectedResponse);
788 
789     String parent = "parent-995424086";
790     String filter = "filter-1274492040";
791 
792     ListGlossariesPagedResponse pagedListResponse = client.listGlossaries(parent, filter);
793 
794     List<Glossary> resources = Lists.newArrayList(pagedListResponse.iterateAll());
795 
796     Assert.assertEquals(1, resources.size());
797     Assert.assertEquals(expectedResponse.getGlossariesList().get(0), resources.get(0));
798 
799     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
800     Assert.assertEquals(1, actualRequests.size());
801     ListGlossariesRequest actualRequest = ((ListGlossariesRequest) actualRequests.get(0));
802 
803     Assert.assertEquals(parent, actualRequest.getParent());
804     Assert.assertEquals(filter, actualRequest.getFilter());
805     Assert.assertTrue(
806         channelProvider.isHeaderSent(
807             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
808             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
809   }
810 
811   @Test
listGlossariesExceptionTest2()812   public void listGlossariesExceptionTest2() throws Exception {
813     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
814     mockTranslationService.addException(exception);
815 
816     try {
817       String parent = "parent-995424086";
818       String filter = "filter-1274492040";
819       client.listGlossaries(parent, filter);
820       Assert.fail("No exception raised");
821     } catch (InvalidArgumentException e) {
822       // Expected exception.
823     }
824   }
825 
826   @Test
getGlossaryTest()827   public void getGlossaryTest() throws Exception {
828     Glossary expectedResponse =
829         Glossary.newBuilder()
830             .setName(GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]").toString())
831             .setInputConfig(GlossaryInputConfig.newBuilder().build())
832             .setEntryCount(-811131134)
833             .setSubmitTime(Timestamp.newBuilder().build())
834             .setEndTime(Timestamp.newBuilder().build())
835             .build();
836     mockTranslationService.addResponse(expectedResponse);
837 
838     GlossaryName name = GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
839 
840     Glossary actualResponse = client.getGlossary(name);
841     Assert.assertEquals(expectedResponse, actualResponse);
842 
843     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
844     Assert.assertEquals(1, actualRequests.size());
845     GetGlossaryRequest actualRequest = ((GetGlossaryRequest) actualRequests.get(0));
846 
847     Assert.assertEquals(name.toString(), actualRequest.getName());
848     Assert.assertTrue(
849         channelProvider.isHeaderSent(
850             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
851             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
852   }
853 
854   @Test
getGlossaryExceptionTest()855   public void getGlossaryExceptionTest() throws Exception {
856     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
857     mockTranslationService.addException(exception);
858 
859     try {
860       GlossaryName name = GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
861       client.getGlossary(name);
862       Assert.fail("No exception raised");
863     } catch (InvalidArgumentException e) {
864       // Expected exception.
865     }
866   }
867 
868   @Test
getGlossaryTest2()869   public void getGlossaryTest2() throws Exception {
870     Glossary expectedResponse =
871         Glossary.newBuilder()
872             .setName(GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]").toString())
873             .setInputConfig(GlossaryInputConfig.newBuilder().build())
874             .setEntryCount(-811131134)
875             .setSubmitTime(Timestamp.newBuilder().build())
876             .setEndTime(Timestamp.newBuilder().build())
877             .build();
878     mockTranslationService.addResponse(expectedResponse);
879 
880     String name = "name3373707";
881 
882     Glossary actualResponse = client.getGlossary(name);
883     Assert.assertEquals(expectedResponse, actualResponse);
884 
885     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
886     Assert.assertEquals(1, actualRequests.size());
887     GetGlossaryRequest actualRequest = ((GetGlossaryRequest) actualRequests.get(0));
888 
889     Assert.assertEquals(name, actualRequest.getName());
890     Assert.assertTrue(
891         channelProvider.isHeaderSent(
892             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
893             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
894   }
895 
896   @Test
getGlossaryExceptionTest2()897   public void getGlossaryExceptionTest2() throws Exception {
898     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
899     mockTranslationService.addException(exception);
900 
901     try {
902       String name = "name3373707";
903       client.getGlossary(name);
904       Assert.fail("No exception raised");
905     } catch (InvalidArgumentException e) {
906       // Expected exception.
907     }
908   }
909 
910   @Test
deleteGlossaryTest()911   public void deleteGlossaryTest() throws Exception {
912     DeleteGlossaryResponse expectedResponse =
913         DeleteGlossaryResponse.newBuilder()
914             .setName("name3373707")
915             .setSubmitTime(Timestamp.newBuilder().build())
916             .setEndTime(Timestamp.newBuilder().build())
917             .build();
918     Operation resultOperation =
919         Operation.newBuilder()
920             .setName("deleteGlossaryTest")
921             .setDone(true)
922             .setResponse(Any.pack(expectedResponse))
923             .build();
924     mockTranslationService.addResponse(resultOperation);
925 
926     GlossaryName name = GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
927 
928     DeleteGlossaryResponse actualResponse = client.deleteGlossaryAsync(name).get();
929     Assert.assertEquals(expectedResponse, actualResponse);
930 
931     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
932     Assert.assertEquals(1, actualRequests.size());
933     DeleteGlossaryRequest actualRequest = ((DeleteGlossaryRequest) actualRequests.get(0));
934 
935     Assert.assertEquals(name.toString(), actualRequest.getName());
936     Assert.assertTrue(
937         channelProvider.isHeaderSent(
938             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
939             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
940   }
941 
942   @Test
deleteGlossaryExceptionTest()943   public void deleteGlossaryExceptionTest() throws Exception {
944     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
945     mockTranslationService.addException(exception);
946 
947     try {
948       GlossaryName name = GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
949       client.deleteGlossaryAsync(name).get();
950       Assert.fail("No exception raised");
951     } catch (ExecutionException e) {
952       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
953       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
954       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
955     }
956   }
957 
958   @Test
deleteGlossaryTest2()959   public void deleteGlossaryTest2() throws Exception {
960     DeleteGlossaryResponse expectedResponse =
961         DeleteGlossaryResponse.newBuilder()
962             .setName("name3373707")
963             .setSubmitTime(Timestamp.newBuilder().build())
964             .setEndTime(Timestamp.newBuilder().build())
965             .build();
966     Operation resultOperation =
967         Operation.newBuilder()
968             .setName("deleteGlossaryTest")
969             .setDone(true)
970             .setResponse(Any.pack(expectedResponse))
971             .build();
972     mockTranslationService.addResponse(resultOperation);
973 
974     String name = "name3373707";
975 
976     DeleteGlossaryResponse actualResponse = client.deleteGlossaryAsync(name).get();
977     Assert.assertEquals(expectedResponse, actualResponse);
978 
979     List<AbstractMessage> actualRequests = mockTranslationService.getRequests();
980     Assert.assertEquals(1, actualRequests.size());
981     DeleteGlossaryRequest actualRequest = ((DeleteGlossaryRequest) actualRequests.get(0));
982 
983     Assert.assertEquals(name, actualRequest.getName());
984     Assert.assertTrue(
985         channelProvider.isHeaderSent(
986             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
987             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
988   }
989 
990   @Test
deleteGlossaryExceptionTest2()991   public void deleteGlossaryExceptionTest2() throws Exception {
992     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
993     mockTranslationService.addException(exception);
994 
995     try {
996       String name = "name3373707";
997       client.deleteGlossaryAsync(name).get();
998       Assert.fail("No exception raised");
999     } catch (ExecutionException e) {
1000       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1001       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1002       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1003     }
1004   }
1005 }
1006