• 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.dialogflow.v2;
18 
19 import static com.google.cloud.dialogflow.v2.DocumentsClient.ListDocumentsPagedResponse;
20 import static com.google.cloud.dialogflow.v2.DocumentsClient.ListLocationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.cloud.location.GetLocationRequest;
31 import com.google.cloud.location.ListLocationsRequest;
32 import com.google.cloud.location.ListLocationsResponse;
33 import com.google.cloud.location.Location;
34 import com.google.common.collect.Lists;
35 import com.google.longrunning.Operation;
36 import com.google.protobuf.AbstractMessage;
37 import com.google.protobuf.Any;
38 import com.google.protobuf.Empty;
39 import com.google.protobuf.FieldMask;
40 import com.google.rpc.Status;
41 import io.grpc.StatusRuntimeException;
42 import java.io.IOException;
43 import java.util.ArrayList;
44 import java.util.Arrays;
45 import java.util.HashMap;
46 import java.util.List;
47 import java.util.UUID;
48 import java.util.concurrent.ExecutionException;
49 import javax.annotation.Generated;
50 import org.junit.After;
51 import org.junit.AfterClass;
52 import org.junit.Assert;
53 import org.junit.Before;
54 import org.junit.BeforeClass;
55 import org.junit.Test;
56 
57 @Generated("by gapic-generator-java")
58 public class DocumentsClientTest {
59   private static MockDocuments mockDocuments;
60   private static MockLocations mockLocations;
61   private static MockServiceHelper mockServiceHelper;
62   private LocalChannelProvider channelProvider;
63   private DocumentsClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() {
67     mockDocuments = new MockDocuments();
68     mockLocations = new MockLocations();
69     mockServiceHelper =
70         new MockServiceHelper(
71             UUID.randomUUID().toString(),
72             Arrays.<MockGrpcService>asList(mockDocuments, mockLocations));
73     mockServiceHelper.start();
74   }
75 
76   @AfterClass
stopServer()77   public static void stopServer() {
78     mockServiceHelper.stop();
79   }
80 
81   @Before
setUp()82   public void setUp() throws IOException {
83     mockServiceHelper.reset();
84     channelProvider = mockServiceHelper.createChannelProvider();
85     DocumentsSettings settings =
86         DocumentsSettings.newBuilder()
87             .setTransportChannelProvider(channelProvider)
88             .setCredentialsProvider(NoCredentialsProvider.create())
89             .build();
90     client = DocumentsClient.create(settings);
91   }
92 
93   @After
tearDown()94   public void tearDown() throws Exception {
95     client.close();
96   }
97 
98   @Test
listDocumentsTest()99   public void listDocumentsTest() throws Exception {
100     Document responsesElement = Document.newBuilder().build();
101     ListDocumentsResponse expectedResponse =
102         ListDocumentsResponse.newBuilder()
103             .setNextPageToken("")
104             .addAllDocuments(Arrays.asList(responsesElement))
105             .build();
106     mockDocuments.addResponse(expectedResponse);
107 
108     KnowledgeBaseName parent =
109         KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]");
110 
111     ListDocumentsPagedResponse pagedListResponse = client.listDocuments(parent);
112 
113     List<Document> resources = Lists.newArrayList(pagedListResponse.iterateAll());
114 
115     Assert.assertEquals(1, resources.size());
116     Assert.assertEquals(expectedResponse.getDocumentsList().get(0), resources.get(0));
117 
118     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
119     Assert.assertEquals(1, actualRequests.size());
120     ListDocumentsRequest actualRequest = ((ListDocumentsRequest) actualRequests.get(0));
121 
122     Assert.assertEquals(parent.toString(), actualRequest.getParent());
123     Assert.assertTrue(
124         channelProvider.isHeaderSent(
125             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
126             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
127   }
128 
129   @Test
listDocumentsExceptionTest()130   public void listDocumentsExceptionTest() throws Exception {
131     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
132     mockDocuments.addException(exception);
133 
134     try {
135       KnowledgeBaseName parent =
136           KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]");
137       client.listDocuments(parent);
138       Assert.fail("No exception raised");
139     } catch (InvalidArgumentException e) {
140       // Expected exception.
141     }
142   }
143 
144   @Test
listDocumentsTest2()145   public void listDocumentsTest2() throws Exception {
146     Document responsesElement = Document.newBuilder().build();
147     ListDocumentsResponse expectedResponse =
148         ListDocumentsResponse.newBuilder()
149             .setNextPageToken("")
150             .addAllDocuments(Arrays.asList(responsesElement))
151             .build();
152     mockDocuments.addResponse(expectedResponse);
153 
154     String parent = "parent-995424086";
155 
156     ListDocumentsPagedResponse pagedListResponse = client.listDocuments(parent);
157 
158     List<Document> resources = Lists.newArrayList(pagedListResponse.iterateAll());
159 
160     Assert.assertEquals(1, resources.size());
161     Assert.assertEquals(expectedResponse.getDocumentsList().get(0), resources.get(0));
162 
163     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
164     Assert.assertEquals(1, actualRequests.size());
165     ListDocumentsRequest actualRequest = ((ListDocumentsRequest) actualRequests.get(0));
166 
167     Assert.assertEquals(parent, actualRequest.getParent());
168     Assert.assertTrue(
169         channelProvider.isHeaderSent(
170             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
171             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
172   }
173 
174   @Test
listDocumentsExceptionTest2()175   public void listDocumentsExceptionTest2() throws Exception {
176     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
177     mockDocuments.addException(exception);
178 
179     try {
180       String parent = "parent-995424086";
181       client.listDocuments(parent);
182       Assert.fail("No exception raised");
183     } catch (InvalidArgumentException e) {
184       // Expected exception.
185     }
186   }
187 
188   @Test
getDocumentTest()189   public void getDocumentTest() throws Exception {
190     Document expectedResponse =
191         Document.newBuilder()
192             .setName(
193                 DocumentName.ofProjectKnowledgeBaseDocumentName(
194                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
195                     .toString())
196             .setDisplayName("displayName1714148973")
197             .setMimeType("mimeType-1392120434")
198             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
199             .setEnableAutoReload(true)
200             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
201             .putAllMetadata(new HashMap<String, String>())
202             .build();
203     mockDocuments.addResponse(expectedResponse);
204 
205     DocumentName name =
206         DocumentName.ofProjectKnowledgeBaseDocumentName(
207             "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
208 
209     Document actualResponse = client.getDocument(name);
210     Assert.assertEquals(expectedResponse, actualResponse);
211 
212     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
213     Assert.assertEquals(1, actualRequests.size());
214     GetDocumentRequest actualRequest = ((GetDocumentRequest) actualRequests.get(0));
215 
216     Assert.assertEquals(name.toString(), actualRequest.getName());
217     Assert.assertTrue(
218         channelProvider.isHeaderSent(
219             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
220             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
221   }
222 
223   @Test
getDocumentExceptionTest()224   public void getDocumentExceptionTest() throws Exception {
225     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
226     mockDocuments.addException(exception);
227 
228     try {
229       DocumentName name =
230           DocumentName.ofProjectKnowledgeBaseDocumentName(
231               "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
232       client.getDocument(name);
233       Assert.fail("No exception raised");
234     } catch (InvalidArgumentException e) {
235       // Expected exception.
236     }
237   }
238 
239   @Test
getDocumentTest2()240   public void getDocumentTest2() throws Exception {
241     Document expectedResponse =
242         Document.newBuilder()
243             .setName(
244                 DocumentName.ofProjectKnowledgeBaseDocumentName(
245                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
246                     .toString())
247             .setDisplayName("displayName1714148973")
248             .setMimeType("mimeType-1392120434")
249             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
250             .setEnableAutoReload(true)
251             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
252             .putAllMetadata(new HashMap<String, String>())
253             .build();
254     mockDocuments.addResponse(expectedResponse);
255 
256     String name = "name3373707";
257 
258     Document actualResponse = client.getDocument(name);
259     Assert.assertEquals(expectedResponse, actualResponse);
260 
261     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
262     Assert.assertEquals(1, actualRequests.size());
263     GetDocumentRequest actualRequest = ((GetDocumentRequest) actualRequests.get(0));
264 
265     Assert.assertEquals(name, actualRequest.getName());
266     Assert.assertTrue(
267         channelProvider.isHeaderSent(
268             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
269             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
270   }
271 
272   @Test
getDocumentExceptionTest2()273   public void getDocumentExceptionTest2() throws Exception {
274     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
275     mockDocuments.addException(exception);
276 
277     try {
278       String name = "name3373707";
279       client.getDocument(name);
280       Assert.fail("No exception raised");
281     } catch (InvalidArgumentException e) {
282       // Expected exception.
283     }
284   }
285 
286   @Test
createDocumentTest()287   public void createDocumentTest() throws Exception {
288     Document expectedResponse =
289         Document.newBuilder()
290             .setName(
291                 DocumentName.ofProjectKnowledgeBaseDocumentName(
292                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
293                     .toString())
294             .setDisplayName("displayName1714148973")
295             .setMimeType("mimeType-1392120434")
296             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
297             .setEnableAutoReload(true)
298             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
299             .putAllMetadata(new HashMap<String, String>())
300             .build();
301     Operation resultOperation =
302         Operation.newBuilder()
303             .setName("createDocumentTest")
304             .setDone(true)
305             .setResponse(Any.pack(expectedResponse))
306             .build();
307     mockDocuments.addResponse(resultOperation);
308 
309     KnowledgeBaseName parent =
310         KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]");
311     Document document = Document.newBuilder().build();
312 
313     Document actualResponse = client.createDocumentAsync(parent, document).get();
314     Assert.assertEquals(expectedResponse, actualResponse);
315 
316     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
317     Assert.assertEquals(1, actualRequests.size());
318     CreateDocumentRequest actualRequest = ((CreateDocumentRequest) actualRequests.get(0));
319 
320     Assert.assertEquals(parent.toString(), actualRequest.getParent());
321     Assert.assertEquals(document, actualRequest.getDocument());
322     Assert.assertTrue(
323         channelProvider.isHeaderSent(
324             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
325             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
326   }
327 
328   @Test
createDocumentExceptionTest()329   public void createDocumentExceptionTest() throws Exception {
330     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
331     mockDocuments.addException(exception);
332 
333     try {
334       KnowledgeBaseName parent =
335           KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]");
336       Document document = Document.newBuilder().build();
337       client.createDocumentAsync(parent, document).get();
338       Assert.fail("No exception raised");
339     } catch (ExecutionException e) {
340       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
341       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
342       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
343     }
344   }
345 
346   @Test
createDocumentTest2()347   public void createDocumentTest2() throws Exception {
348     Document expectedResponse =
349         Document.newBuilder()
350             .setName(
351                 DocumentName.ofProjectKnowledgeBaseDocumentName(
352                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
353                     .toString())
354             .setDisplayName("displayName1714148973")
355             .setMimeType("mimeType-1392120434")
356             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
357             .setEnableAutoReload(true)
358             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
359             .putAllMetadata(new HashMap<String, String>())
360             .build();
361     Operation resultOperation =
362         Operation.newBuilder()
363             .setName("createDocumentTest")
364             .setDone(true)
365             .setResponse(Any.pack(expectedResponse))
366             .build();
367     mockDocuments.addResponse(resultOperation);
368 
369     String parent = "parent-995424086";
370     Document document = Document.newBuilder().build();
371 
372     Document actualResponse = client.createDocumentAsync(parent, document).get();
373     Assert.assertEquals(expectedResponse, actualResponse);
374 
375     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
376     Assert.assertEquals(1, actualRequests.size());
377     CreateDocumentRequest actualRequest = ((CreateDocumentRequest) actualRequests.get(0));
378 
379     Assert.assertEquals(parent, actualRequest.getParent());
380     Assert.assertEquals(document, actualRequest.getDocument());
381     Assert.assertTrue(
382         channelProvider.isHeaderSent(
383             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
384             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
385   }
386 
387   @Test
createDocumentExceptionTest2()388   public void createDocumentExceptionTest2() throws Exception {
389     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
390     mockDocuments.addException(exception);
391 
392     try {
393       String parent = "parent-995424086";
394       Document document = Document.newBuilder().build();
395       client.createDocumentAsync(parent, document).get();
396       Assert.fail("No exception raised");
397     } catch (ExecutionException e) {
398       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
399       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
400       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
401     }
402   }
403 
404   @Test
importDocumentsTest()405   public void importDocumentsTest() throws Exception {
406     ImportDocumentsResponse expectedResponse =
407         ImportDocumentsResponse.newBuilder().addAllWarnings(new ArrayList<Status>()).build();
408     Operation resultOperation =
409         Operation.newBuilder()
410             .setName("importDocumentsTest")
411             .setDone(true)
412             .setResponse(Any.pack(expectedResponse))
413             .build();
414     mockDocuments.addResponse(resultOperation);
415 
416     ImportDocumentsRequest request =
417         ImportDocumentsRequest.newBuilder()
418             .setParent(
419                 KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]")
420                     .toString())
421             .setDocumentTemplate(ImportDocumentTemplate.newBuilder().build())
422             .setImportGcsCustomMetadata(true)
423             .build();
424 
425     ImportDocumentsResponse actualResponse = client.importDocumentsAsync(request).get();
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
429     Assert.assertEquals(1, actualRequests.size());
430     ImportDocumentsRequest actualRequest = ((ImportDocumentsRequest) actualRequests.get(0));
431 
432     Assert.assertEquals(request.getParent(), actualRequest.getParent());
433     Assert.assertEquals(request.getGcsSource(), actualRequest.getGcsSource());
434     Assert.assertEquals(request.getDocumentTemplate(), actualRequest.getDocumentTemplate());
435     Assert.assertEquals(
436         request.getImportGcsCustomMetadata(), actualRequest.getImportGcsCustomMetadata());
437     Assert.assertTrue(
438         channelProvider.isHeaderSent(
439             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
440             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
441   }
442 
443   @Test
importDocumentsExceptionTest()444   public void importDocumentsExceptionTest() throws Exception {
445     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
446     mockDocuments.addException(exception);
447 
448     try {
449       ImportDocumentsRequest request =
450           ImportDocumentsRequest.newBuilder()
451               .setParent(
452                   KnowledgeBaseName.ofProjectKnowledgeBaseName("[PROJECT]", "[KNOWLEDGE_BASE]")
453                       .toString())
454               .setDocumentTemplate(ImportDocumentTemplate.newBuilder().build())
455               .setImportGcsCustomMetadata(true)
456               .build();
457       client.importDocumentsAsync(request).get();
458       Assert.fail("No exception raised");
459     } catch (ExecutionException e) {
460       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
461       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
462       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
463     }
464   }
465 
466   @Test
deleteDocumentTest()467   public void deleteDocumentTest() throws Exception {
468     Empty expectedResponse = Empty.newBuilder().build();
469     Operation resultOperation =
470         Operation.newBuilder()
471             .setName("deleteDocumentTest")
472             .setDone(true)
473             .setResponse(Any.pack(expectedResponse))
474             .build();
475     mockDocuments.addResponse(resultOperation);
476 
477     DocumentName name =
478         DocumentName.ofProjectKnowledgeBaseDocumentName(
479             "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
480 
481     client.deleteDocumentAsync(name).get();
482 
483     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
484     Assert.assertEquals(1, actualRequests.size());
485     DeleteDocumentRequest actualRequest = ((DeleteDocumentRequest) actualRequests.get(0));
486 
487     Assert.assertEquals(name.toString(), actualRequest.getName());
488     Assert.assertTrue(
489         channelProvider.isHeaderSent(
490             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
491             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
492   }
493 
494   @Test
deleteDocumentExceptionTest()495   public void deleteDocumentExceptionTest() throws Exception {
496     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
497     mockDocuments.addException(exception);
498 
499     try {
500       DocumentName name =
501           DocumentName.ofProjectKnowledgeBaseDocumentName(
502               "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
503       client.deleteDocumentAsync(name).get();
504       Assert.fail("No exception raised");
505     } catch (ExecutionException e) {
506       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
507       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
508       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
509     }
510   }
511 
512   @Test
deleteDocumentTest2()513   public void deleteDocumentTest2() throws Exception {
514     Empty expectedResponse = Empty.newBuilder().build();
515     Operation resultOperation =
516         Operation.newBuilder()
517             .setName("deleteDocumentTest")
518             .setDone(true)
519             .setResponse(Any.pack(expectedResponse))
520             .build();
521     mockDocuments.addResponse(resultOperation);
522 
523     String name = "name3373707";
524 
525     client.deleteDocumentAsync(name).get();
526 
527     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
528     Assert.assertEquals(1, actualRequests.size());
529     DeleteDocumentRequest actualRequest = ((DeleteDocumentRequest) actualRequests.get(0));
530 
531     Assert.assertEquals(name, actualRequest.getName());
532     Assert.assertTrue(
533         channelProvider.isHeaderSent(
534             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
535             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
536   }
537 
538   @Test
deleteDocumentExceptionTest2()539   public void deleteDocumentExceptionTest2() throws Exception {
540     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
541     mockDocuments.addException(exception);
542 
543     try {
544       String name = "name3373707";
545       client.deleteDocumentAsync(name).get();
546       Assert.fail("No exception raised");
547     } catch (ExecutionException e) {
548       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
549       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
550       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
551     }
552   }
553 
554   @Test
updateDocumentTest()555   public void updateDocumentTest() throws Exception {
556     Document expectedResponse =
557         Document.newBuilder()
558             .setName(
559                 DocumentName.ofProjectKnowledgeBaseDocumentName(
560                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
561                     .toString())
562             .setDisplayName("displayName1714148973")
563             .setMimeType("mimeType-1392120434")
564             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
565             .setEnableAutoReload(true)
566             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
567             .putAllMetadata(new HashMap<String, String>())
568             .build();
569     Operation resultOperation =
570         Operation.newBuilder()
571             .setName("updateDocumentTest")
572             .setDone(true)
573             .setResponse(Any.pack(expectedResponse))
574             .build();
575     mockDocuments.addResponse(resultOperation);
576 
577     Document document = Document.newBuilder().build();
578     FieldMask updateMask = FieldMask.newBuilder().build();
579 
580     Document actualResponse = client.updateDocumentAsync(document, updateMask).get();
581     Assert.assertEquals(expectedResponse, actualResponse);
582 
583     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
584     Assert.assertEquals(1, actualRequests.size());
585     UpdateDocumentRequest actualRequest = ((UpdateDocumentRequest) actualRequests.get(0));
586 
587     Assert.assertEquals(document, actualRequest.getDocument());
588     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
589     Assert.assertTrue(
590         channelProvider.isHeaderSent(
591             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
592             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
593   }
594 
595   @Test
updateDocumentExceptionTest()596   public void updateDocumentExceptionTest() throws Exception {
597     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
598     mockDocuments.addException(exception);
599 
600     try {
601       Document document = Document.newBuilder().build();
602       FieldMask updateMask = FieldMask.newBuilder().build();
603       client.updateDocumentAsync(document, updateMask).get();
604       Assert.fail("No exception raised");
605     } catch (ExecutionException e) {
606       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
607       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
608       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
609     }
610   }
611 
612   @Test
reloadDocumentTest()613   public void reloadDocumentTest() throws Exception {
614     Document expectedResponse =
615         Document.newBuilder()
616             .setName(
617                 DocumentName.ofProjectKnowledgeBaseDocumentName(
618                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
619                     .toString())
620             .setDisplayName("displayName1714148973")
621             .setMimeType("mimeType-1392120434")
622             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
623             .setEnableAutoReload(true)
624             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
625             .putAllMetadata(new HashMap<String, String>())
626             .build();
627     Operation resultOperation =
628         Operation.newBuilder()
629             .setName("reloadDocumentTest")
630             .setDone(true)
631             .setResponse(Any.pack(expectedResponse))
632             .build();
633     mockDocuments.addResponse(resultOperation);
634 
635     DocumentName name =
636         DocumentName.ofProjectKnowledgeBaseDocumentName(
637             "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
638     String contentUri = "contentUri264542771";
639 
640     Document actualResponse = client.reloadDocumentAsync(name, contentUri).get();
641     Assert.assertEquals(expectedResponse, actualResponse);
642 
643     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
644     Assert.assertEquals(1, actualRequests.size());
645     ReloadDocumentRequest actualRequest = ((ReloadDocumentRequest) actualRequests.get(0));
646 
647     Assert.assertEquals(name.toString(), actualRequest.getName());
648     Assert.assertEquals(contentUri, actualRequest.getContentUri());
649     Assert.assertTrue(
650         channelProvider.isHeaderSent(
651             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
652             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
653   }
654 
655   @Test
reloadDocumentExceptionTest()656   public void reloadDocumentExceptionTest() throws Exception {
657     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
658     mockDocuments.addException(exception);
659 
660     try {
661       DocumentName name =
662           DocumentName.ofProjectKnowledgeBaseDocumentName(
663               "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
664       String contentUri = "contentUri264542771";
665       client.reloadDocumentAsync(name, contentUri).get();
666       Assert.fail("No exception raised");
667     } catch (ExecutionException e) {
668       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
669       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
670       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
671     }
672   }
673 
674   @Test
reloadDocumentTest2()675   public void reloadDocumentTest2() throws Exception {
676     Document expectedResponse =
677         Document.newBuilder()
678             .setName(
679                 DocumentName.ofProjectKnowledgeBaseDocumentName(
680                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
681                     .toString())
682             .setDisplayName("displayName1714148973")
683             .setMimeType("mimeType-1392120434")
684             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
685             .setEnableAutoReload(true)
686             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
687             .putAllMetadata(new HashMap<String, String>())
688             .build();
689     Operation resultOperation =
690         Operation.newBuilder()
691             .setName("reloadDocumentTest")
692             .setDone(true)
693             .setResponse(Any.pack(expectedResponse))
694             .build();
695     mockDocuments.addResponse(resultOperation);
696 
697     String name = "name3373707";
698     String contentUri = "contentUri264542771";
699 
700     Document actualResponse = client.reloadDocumentAsync(name, contentUri).get();
701     Assert.assertEquals(expectedResponse, actualResponse);
702 
703     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
704     Assert.assertEquals(1, actualRequests.size());
705     ReloadDocumentRequest actualRequest = ((ReloadDocumentRequest) actualRequests.get(0));
706 
707     Assert.assertEquals(name, actualRequest.getName());
708     Assert.assertEquals(contentUri, actualRequest.getContentUri());
709     Assert.assertTrue(
710         channelProvider.isHeaderSent(
711             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
712             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
713   }
714 
715   @Test
reloadDocumentExceptionTest2()716   public void reloadDocumentExceptionTest2() throws Exception {
717     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
718     mockDocuments.addException(exception);
719 
720     try {
721       String name = "name3373707";
722       String contentUri = "contentUri264542771";
723       client.reloadDocumentAsync(name, contentUri).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
exportDocumentTest()733   public void exportDocumentTest() throws Exception {
734     Document expectedResponse =
735         Document.newBuilder()
736             .setName(
737                 DocumentName.ofProjectKnowledgeBaseDocumentName(
738                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
739                     .toString())
740             .setDisplayName("displayName1714148973")
741             .setMimeType("mimeType-1392120434")
742             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
743             .setEnableAutoReload(true)
744             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
745             .putAllMetadata(new HashMap<String, String>())
746             .build();
747     Operation resultOperation =
748         Operation.newBuilder()
749             .setName("exportDocumentTest")
750             .setDone(true)
751             .setResponse(Any.pack(expectedResponse))
752             .build();
753     mockDocuments.addResponse(resultOperation);
754 
755     ExportDocumentRequest request =
756         ExportDocumentRequest.newBuilder()
757             .setName(
758                 DocumentName.ofProjectKnowledgeBaseDocumentName(
759                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
760                     .toString())
761             .setExportFullContent(true)
762             .setSmartMessagingPartialUpdate(true)
763             .build();
764 
765     Document actualResponse = client.exportDocumentAsync(request).get();
766     Assert.assertEquals(expectedResponse, actualResponse);
767 
768     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
769     Assert.assertEquals(1, actualRequests.size());
770     ExportDocumentRequest actualRequest = ((ExportDocumentRequest) actualRequests.get(0));
771 
772     Assert.assertEquals(request.getName(), actualRequest.getName());
773     Assert.assertEquals(request.getGcsDestination(), actualRequest.getGcsDestination());
774     Assert.assertEquals(request.getExportFullContent(), actualRequest.getExportFullContent());
775     Assert.assertEquals(
776         request.getSmartMessagingPartialUpdate(), actualRequest.getSmartMessagingPartialUpdate());
777     Assert.assertTrue(
778         channelProvider.isHeaderSent(
779             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
780             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
781   }
782 
783   @Test
exportDocumentExceptionTest()784   public void exportDocumentExceptionTest() throws Exception {
785     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
786     mockDocuments.addException(exception);
787 
788     try {
789       ExportDocumentRequest request =
790           ExportDocumentRequest.newBuilder()
791               .setName(
792                   DocumentName.ofProjectKnowledgeBaseDocumentName(
793                           "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
794                       .toString())
795               .setExportFullContent(true)
796               .setSmartMessagingPartialUpdate(true)
797               .build();
798       client.exportDocumentAsync(request).get();
799       Assert.fail("No exception raised");
800     } catch (ExecutionException e) {
801       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
802       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
803       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
804     }
805   }
806 
807   @Test
listLocationsTest()808   public void listLocationsTest() throws Exception {
809     Location responsesElement = Location.newBuilder().build();
810     ListLocationsResponse expectedResponse =
811         ListLocationsResponse.newBuilder()
812             .setNextPageToken("")
813             .addAllLocations(Arrays.asList(responsesElement))
814             .build();
815     mockLocations.addResponse(expectedResponse);
816 
817     ListLocationsRequest request =
818         ListLocationsRequest.newBuilder()
819             .setName("name3373707")
820             .setFilter("filter-1274492040")
821             .setPageSize(883849137)
822             .setPageToken("pageToken873572522")
823             .build();
824 
825     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
826 
827     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
828 
829     Assert.assertEquals(1, resources.size());
830     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
831 
832     List<AbstractMessage> actualRequests = mockLocations.getRequests();
833     Assert.assertEquals(1, actualRequests.size());
834     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
835 
836     Assert.assertEquals(request.getName(), actualRequest.getName());
837     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
838     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
839     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
840     Assert.assertTrue(
841         channelProvider.isHeaderSent(
842             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
843             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
844   }
845 
846   @Test
listLocationsExceptionTest()847   public void listLocationsExceptionTest() throws Exception {
848     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
849     mockLocations.addException(exception);
850 
851     try {
852       ListLocationsRequest request =
853           ListLocationsRequest.newBuilder()
854               .setName("name3373707")
855               .setFilter("filter-1274492040")
856               .setPageSize(883849137)
857               .setPageToken("pageToken873572522")
858               .build();
859       client.listLocations(request);
860       Assert.fail("No exception raised");
861     } catch (InvalidArgumentException e) {
862       // Expected exception.
863     }
864   }
865 
866   @Test
getLocationTest()867   public void getLocationTest() throws Exception {
868     Location expectedResponse =
869         Location.newBuilder()
870             .setName("name3373707")
871             .setLocationId("locationId1541836720")
872             .setDisplayName("displayName1714148973")
873             .putAllLabels(new HashMap<String, String>())
874             .setMetadata(Any.newBuilder().build())
875             .build();
876     mockLocations.addResponse(expectedResponse);
877 
878     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
879 
880     Location actualResponse = client.getLocation(request);
881     Assert.assertEquals(expectedResponse, actualResponse);
882 
883     List<AbstractMessage> actualRequests = mockLocations.getRequests();
884     Assert.assertEquals(1, actualRequests.size());
885     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
886 
887     Assert.assertEquals(request.getName(), actualRequest.getName());
888     Assert.assertTrue(
889         channelProvider.isHeaderSent(
890             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
891             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
892   }
893 
894   @Test
getLocationExceptionTest()895   public void getLocationExceptionTest() throws Exception {
896     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
897     mockLocations.addException(exception);
898 
899     try {
900       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
901       client.getLocation(request);
902       Assert.fail("No exception raised");
903     } catch (InvalidArgumentException e) {
904       // Expected exception.
905     }
906   }
907 }
908