• 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.v2beta1;
18 
19 import static com.google.cloud.dialogflow.v2beta1.DocumentsClient.ListDocumentsPagedResponse;
20 import static com.google.cloud.dialogflow.v2beta1.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 
579     Document actualResponse = client.updateDocumentAsync(document).get();
580     Assert.assertEquals(expectedResponse, actualResponse);
581 
582     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
583     Assert.assertEquals(1, actualRequests.size());
584     UpdateDocumentRequest actualRequest = ((UpdateDocumentRequest) actualRequests.get(0));
585 
586     Assert.assertEquals(document, actualRequest.getDocument());
587     Assert.assertTrue(
588         channelProvider.isHeaderSent(
589             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
590             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
591   }
592 
593   @Test
updateDocumentExceptionTest()594   public void updateDocumentExceptionTest() throws Exception {
595     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
596     mockDocuments.addException(exception);
597 
598     try {
599       Document document = Document.newBuilder().build();
600       client.updateDocumentAsync(document).get();
601       Assert.fail("No exception raised");
602     } catch (ExecutionException e) {
603       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
604       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
605       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
606     }
607   }
608 
609   @Test
updateDocumentTest2()610   public void updateDocumentTest2() throws Exception {
611     Document expectedResponse =
612         Document.newBuilder()
613             .setName(
614                 DocumentName.ofProjectKnowledgeBaseDocumentName(
615                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
616                     .toString())
617             .setDisplayName("displayName1714148973")
618             .setMimeType("mimeType-1392120434")
619             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
620             .setEnableAutoReload(true)
621             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
622             .putAllMetadata(new HashMap<String, String>())
623             .build();
624     Operation resultOperation =
625         Operation.newBuilder()
626             .setName("updateDocumentTest")
627             .setDone(true)
628             .setResponse(Any.pack(expectedResponse))
629             .build();
630     mockDocuments.addResponse(resultOperation);
631 
632     Document document = Document.newBuilder().build();
633     FieldMask updateMask = FieldMask.newBuilder().build();
634 
635     Document actualResponse = client.updateDocumentAsync(document, updateMask).get();
636     Assert.assertEquals(expectedResponse, actualResponse);
637 
638     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
639     Assert.assertEquals(1, actualRequests.size());
640     UpdateDocumentRequest actualRequest = ((UpdateDocumentRequest) actualRequests.get(0));
641 
642     Assert.assertEquals(document, actualRequest.getDocument());
643     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
644     Assert.assertTrue(
645         channelProvider.isHeaderSent(
646             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
647             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
648   }
649 
650   @Test
updateDocumentExceptionTest2()651   public void updateDocumentExceptionTest2() throws Exception {
652     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
653     mockDocuments.addException(exception);
654 
655     try {
656       Document document = Document.newBuilder().build();
657       FieldMask updateMask = FieldMask.newBuilder().build();
658       client.updateDocumentAsync(document, updateMask).get();
659       Assert.fail("No exception raised");
660     } catch (ExecutionException e) {
661       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
662       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
663       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
664     }
665   }
666 
667   @Test
reloadDocumentTest()668   public void reloadDocumentTest() throws Exception {
669     Document expectedResponse =
670         Document.newBuilder()
671             .setName(
672                 DocumentName.ofProjectKnowledgeBaseDocumentName(
673                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
674                     .toString())
675             .setDisplayName("displayName1714148973")
676             .setMimeType("mimeType-1392120434")
677             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
678             .setEnableAutoReload(true)
679             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
680             .putAllMetadata(new HashMap<String, String>())
681             .build();
682     Operation resultOperation =
683         Operation.newBuilder()
684             .setName("reloadDocumentTest")
685             .setDone(true)
686             .setResponse(Any.pack(expectedResponse))
687             .build();
688     mockDocuments.addResponse(resultOperation);
689 
690     DocumentName name =
691         DocumentName.ofProjectKnowledgeBaseDocumentName(
692             "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
693     GcsSource gcsSource = GcsSource.newBuilder().build();
694 
695     Document actualResponse = client.reloadDocumentAsync(name, gcsSource).get();
696     Assert.assertEquals(expectedResponse, actualResponse);
697 
698     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
699     Assert.assertEquals(1, actualRequests.size());
700     ReloadDocumentRequest actualRequest = ((ReloadDocumentRequest) actualRequests.get(0));
701 
702     Assert.assertEquals(name.toString(), actualRequest.getName());
703     Assert.assertEquals(gcsSource, actualRequest.getGcsSource());
704     Assert.assertTrue(
705         channelProvider.isHeaderSent(
706             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
707             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
708   }
709 
710   @Test
reloadDocumentExceptionTest()711   public void reloadDocumentExceptionTest() throws Exception {
712     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
713     mockDocuments.addException(exception);
714 
715     try {
716       DocumentName name =
717           DocumentName.ofProjectKnowledgeBaseDocumentName(
718               "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]");
719       GcsSource gcsSource = GcsSource.newBuilder().build();
720       client.reloadDocumentAsync(name, gcsSource).get();
721       Assert.fail("No exception raised");
722     } catch (ExecutionException e) {
723       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
724       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
725       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
726     }
727   }
728 
729   @Test
reloadDocumentTest2()730   public void reloadDocumentTest2() throws Exception {
731     Document expectedResponse =
732         Document.newBuilder()
733             .setName(
734                 DocumentName.ofProjectKnowledgeBaseDocumentName(
735                         "[PROJECT]", "[KNOWLEDGE_BASE]", "[DOCUMENT]")
736                     .toString())
737             .setDisplayName("displayName1714148973")
738             .setMimeType("mimeType-1392120434")
739             .addAllKnowledgeTypes(new ArrayList<Document.KnowledgeType>())
740             .setEnableAutoReload(true)
741             .setLatestReloadStatus(Document.ReloadStatus.newBuilder().build())
742             .putAllMetadata(new HashMap<String, String>())
743             .build();
744     Operation resultOperation =
745         Operation.newBuilder()
746             .setName("reloadDocumentTest")
747             .setDone(true)
748             .setResponse(Any.pack(expectedResponse))
749             .build();
750     mockDocuments.addResponse(resultOperation);
751 
752     String name = "name3373707";
753     GcsSource gcsSource = GcsSource.newBuilder().build();
754 
755     Document actualResponse = client.reloadDocumentAsync(name, gcsSource).get();
756     Assert.assertEquals(expectedResponse, actualResponse);
757 
758     List<AbstractMessage> actualRequests = mockDocuments.getRequests();
759     Assert.assertEquals(1, actualRequests.size());
760     ReloadDocumentRequest actualRequest = ((ReloadDocumentRequest) actualRequests.get(0));
761 
762     Assert.assertEquals(name, actualRequest.getName());
763     Assert.assertEquals(gcsSource, actualRequest.getGcsSource());
764     Assert.assertTrue(
765         channelProvider.isHeaderSent(
766             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
767             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
768   }
769 
770   @Test
reloadDocumentExceptionTest2()771   public void reloadDocumentExceptionTest2() throws Exception {
772     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
773     mockDocuments.addException(exception);
774 
775     try {
776       String name = "name3373707";
777       GcsSource gcsSource = GcsSource.newBuilder().build();
778       client.reloadDocumentAsync(name, gcsSource).get();
779       Assert.fail("No exception raised");
780     } catch (ExecutionException e) {
781       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
782       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
783       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
784     }
785   }
786 
787   @Test
listLocationsTest()788   public void listLocationsTest() throws Exception {
789     Location responsesElement = Location.newBuilder().build();
790     ListLocationsResponse expectedResponse =
791         ListLocationsResponse.newBuilder()
792             .setNextPageToken("")
793             .addAllLocations(Arrays.asList(responsesElement))
794             .build();
795     mockLocations.addResponse(expectedResponse);
796 
797     ListLocationsRequest request =
798         ListLocationsRequest.newBuilder()
799             .setName("name3373707")
800             .setFilter("filter-1274492040")
801             .setPageSize(883849137)
802             .setPageToken("pageToken873572522")
803             .build();
804 
805     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
806 
807     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
808 
809     Assert.assertEquals(1, resources.size());
810     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
811 
812     List<AbstractMessage> actualRequests = mockLocations.getRequests();
813     Assert.assertEquals(1, actualRequests.size());
814     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
815 
816     Assert.assertEquals(request.getName(), actualRequest.getName());
817     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
818     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
819     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
820     Assert.assertTrue(
821         channelProvider.isHeaderSent(
822             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
823             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
824   }
825 
826   @Test
listLocationsExceptionTest()827   public void listLocationsExceptionTest() throws Exception {
828     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
829     mockLocations.addException(exception);
830 
831     try {
832       ListLocationsRequest request =
833           ListLocationsRequest.newBuilder()
834               .setName("name3373707")
835               .setFilter("filter-1274492040")
836               .setPageSize(883849137)
837               .setPageToken("pageToken873572522")
838               .build();
839       client.listLocations(request);
840       Assert.fail("No exception raised");
841     } catch (InvalidArgumentException e) {
842       // Expected exception.
843     }
844   }
845 
846   @Test
getLocationTest()847   public void getLocationTest() throws Exception {
848     Location expectedResponse =
849         Location.newBuilder()
850             .setName("name3373707")
851             .setLocationId("locationId1541836720")
852             .setDisplayName("displayName1714148973")
853             .putAllLabels(new HashMap<String, String>())
854             .setMetadata(Any.newBuilder().build())
855             .build();
856     mockLocations.addResponse(expectedResponse);
857 
858     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
859 
860     Location actualResponse = client.getLocation(request);
861     Assert.assertEquals(expectedResponse, actualResponse);
862 
863     List<AbstractMessage> actualRequests = mockLocations.getRequests();
864     Assert.assertEquals(1, actualRequests.size());
865     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
866 
867     Assert.assertEquals(request.getName(), actualRequest.getName());
868     Assert.assertTrue(
869         channelProvider.isHeaderSent(
870             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
871             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
872   }
873 
874   @Test
getLocationExceptionTest()875   public void getLocationExceptionTest() throws Exception {
876     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
877     mockLocations.addException(exception);
878 
879     try {
880       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
881       client.getLocation(request);
882       Assert.fail("No exception raised");
883     } catch (InvalidArgumentException e) {
884       // Expected exception.
885     }
886   }
887 }
888