• 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.contentwarehouse.v1;
18 
19 import static com.google.cloud.contentwarehouse.v1.DocumentServiceClient.SearchDocumentsPagedResponse;
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.common.collect.Lists;
29 import com.google.iam.v1.Policy;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Empty;
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.List;
39 import java.util.UUID;
40 import javax.annotation.Generated;
41 import org.junit.After;
42 import org.junit.AfterClass;
43 import org.junit.Assert;
44 import org.junit.Before;
45 import org.junit.BeforeClass;
46 import org.junit.Test;
47 
48 @Generated("by gapic-generator-java")
49 public class DocumentServiceClientTest {
50   private static MockDocumentService mockDocumentService;
51   private static MockServiceHelper mockServiceHelper;
52   private LocalChannelProvider channelProvider;
53   private DocumentServiceClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() {
57     mockDocumentService = new MockDocumentService();
58     mockServiceHelper =
59         new MockServiceHelper(
60             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockDocumentService));
61     mockServiceHelper.start();
62   }
63 
64   @AfterClass
stopServer()65   public static void stopServer() {
66     mockServiceHelper.stop();
67   }
68 
69   @Before
setUp()70   public void setUp() throws IOException {
71     mockServiceHelper.reset();
72     channelProvider = mockServiceHelper.createChannelProvider();
73     DocumentServiceSettings settings =
74         DocumentServiceSettings.newBuilder()
75             .setTransportChannelProvider(channelProvider)
76             .setCredentialsProvider(NoCredentialsProvider.create())
77             .build();
78     client = DocumentServiceClient.create(settings);
79   }
80 
81   @After
tearDown()82   public void tearDown() throws Exception {
83     client.close();
84   }
85 
86   @Test
createDocumentTest()87   public void createDocumentTest() throws Exception {
88     CreateDocumentResponse expectedResponse =
89         CreateDocumentResponse.newBuilder()
90             .setDocument(Document.newBuilder().build())
91             .setRuleEngineOutput(RuleEngineOutput.newBuilder().build())
92             .setMetadata(ResponseMetadata.newBuilder().build())
93             .addAllLongRunningOperations(new ArrayList<Operation>())
94             .build();
95     mockDocumentService.addResponse(expectedResponse);
96 
97     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
98     Document document = Document.newBuilder().build();
99 
100     CreateDocumentResponse actualResponse = client.createDocument(parent, document);
101     Assert.assertEquals(expectedResponse, actualResponse);
102 
103     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
104     Assert.assertEquals(1, actualRequests.size());
105     CreateDocumentRequest actualRequest = ((CreateDocumentRequest) actualRequests.get(0));
106 
107     Assert.assertEquals(parent.toString(), actualRequest.getParent());
108     Assert.assertEquals(document, actualRequest.getDocument());
109     Assert.assertTrue(
110         channelProvider.isHeaderSent(
111             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
112             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
113   }
114 
115   @Test
createDocumentExceptionTest()116   public void createDocumentExceptionTest() throws Exception {
117     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
118     mockDocumentService.addException(exception);
119 
120     try {
121       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
122       Document document = Document.newBuilder().build();
123       client.createDocument(parent, document);
124       Assert.fail("No exception raised");
125     } catch (InvalidArgumentException e) {
126       // Expected exception.
127     }
128   }
129 
130   @Test
createDocumentTest2()131   public void createDocumentTest2() throws Exception {
132     CreateDocumentResponse expectedResponse =
133         CreateDocumentResponse.newBuilder()
134             .setDocument(Document.newBuilder().build())
135             .setRuleEngineOutput(RuleEngineOutput.newBuilder().build())
136             .setMetadata(ResponseMetadata.newBuilder().build())
137             .addAllLongRunningOperations(new ArrayList<Operation>())
138             .build();
139     mockDocumentService.addResponse(expectedResponse);
140 
141     String parent = "parent-995424086";
142     Document document = Document.newBuilder().build();
143 
144     CreateDocumentResponse actualResponse = client.createDocument(parent, document);
145     Assert.assertEquals(expectedResponse, actualResponse);
146 
147     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
148     Assert.assertEquals(1, actualRequests.size());
149     CreateDocumentRequest actualRequest = ((CreateDocumentRequest) actualRequests.get(0));
150 
151     Assert.assertEquals(parent, actualRequest.getParent());
152     Assert.assertEquals(document, actualRequest.getDocument());
153     Assert.assertTrue(
154         channelProvider.isHeaderSent(
155             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
156             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
157   }
158 
159   @Test
createDocumentExceptionTest2()160   public void createDocumentExceptionTest2() throws Exception {
161     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
162     mockDocumentService.addException(exception);
163 
164     try {
165       String parent = "parent-995424086";
166       Document document = Document.newBuilder().build();
167       client.createDocument(parent, document);
168       Assert.fail("No exception raised");
169     } catch (InvalidArgumentException e) {
170       // Expected exception.
171     }
172   }
173 
174   @Test
getDocumentTest()175   public void getDocumentTest() throws Exception {
176     Document expectedResponse =
177         Document.newBuilder()
178             .setName(
179                 DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]")
180                     .toString())
181             .setReferenceId("referenceId-16211514")
182             .setDisplayName("displayName1714148973")
183             .setTitle("title110371416")
184             .setDisplayUri("displayUri-914528950")
185             .setDocumentSchemaName(
186                 DocumentSchemaName.of("[PROJECT]", "[LOCATION]", "[DOCUMENT_SCHEMA]").toString())
187             .setStructuredContentUri("structuredContentUri-1039251868")
188             .addAllProperties(new ArrayList<Property>())
189             .setUpdateTime(Timestamp.newBuilder().build())
190             .setCreateTime(Timestamp.newBuilder().build())
191             .setRawDocumentFileType(RawDocumentFileType.forNumber(0))
192             .setAsyncEnabled(true)
193             .setContentCategory(ContentCategory.forNumber(0))
194             .setTextExtractionDisabled(true)
195             .setTextExtractionEnabled(true)
196             .setCreator("creator1028554796")
197             .setUpdater("updater-234430263")
198             .build();
199     mockDocumentService.addResponse(expectedResponse);
200 
201     DocumentName name =
202         DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
203 
204     Document actualResponse = client.getDocument(name);
205     Assert.assertEquals(expectedResponse, actualResponse);
206 
207     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
208     Assert.assertEquals(1, actualRequests.size());
209     GetDocumentRequest actualRequest = ((GetDocumentRequest) actualRequests.get(0));
210 
211     Assert.assertEquals(name.toString(), actualRequest.getName());
212     Assert.assertTrue(
213         channelProvider.isHeaderSent(
214             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
215             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
216   }
217 
218   @Test
getDocumentExceptionTest()219   public void getDocumentExceptionTest() throws Exception {
220     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
221     mockDocumentService.addException(exception);
222 
223     try {
224       DocumentName name =
225           DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
226       client.getDocument(name);
227       Assert.fail("No exception raised");
228     } catch (InvalidArgumentException e) {
229       // Expected exception.
230     }
231   }
232 
233   @Test
getDocumentTest2()234   public void getDocumentTest2() throws Exception {
235     Document expectedResponse =
236         Document.newBuilder()
237             .setName(
238                 DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]")
239                     .toString())
240             .setReferenceId("referenceId-16211514")
241             .setDisplayName("displayName1714148973")
242             .setTitle("title110371416")
243             .setDisplayUri("displayUri-914528950")
244             .setDocumentSchemaName(
245                 DocumentSchemaName.of("[PROJECT]", "[LOCATION]", "[DOCUMENT_SCHEMA]").toString())
246             .setStructuredContentUri("structuredContentUri-1039251868")
247             .addAllProperties(new ArrayList<Property>())
248             .setUpdateTime(Timestamp.newBuilder().build())
249             .setCreateTime(Timestamp.newBuilder().build())
250             .setRawDocumentFileType(RawDocumentFileType.forNumber(0))
251             .setAsyncEnabled(true)
252             .setContentCategory(ContentCategory.forNumber(0))
253             .setTextExtractionDisabled(true)
254             .setTextExtractionEnabled(true)
255             .setCreator("creator1028554796")
256             .setUpdater("updater-234430263")
257             .build();
258     mockDocumentService.addResponse(expectedResponse);
259 
260     String name = "name3373707";
261 
262     Document actualResponse = client.getDocument(name);
263     Assert.assertEquals(expectedResponse, actualResponse);
264 
265     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
266     Assert.assertEquals(1, actualRequests.size());
267     GetDocumentRequest actualRequest = ((GetDocumentRequest) actualRequests.get(0));
268 
269     Assert.assertEquals(name, actualRequest.getName());
270     Assert.assertTrue(
271         channelProvider.isHeaderSent(
272             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
273             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
274   }
275 
276   @Test
getDocumentExceptionTest2()277   public void getDocumentExceptionTest2() throws Exception {
278     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
279     mockDocumentService.addException(exception);
280 
281     try {
282       String name = "name3373707";
283       client.getDocument(name);
284       Assert.fail("No exception raised");
285     } catch (InvalidArgumentException e) {
286       // Expected exception.
287     }
288   }
289 
290   @Test
updateDocumentTest()291   public void updateDocumentTest() throws Exception {
292     UpdateDocumentResponse expectedResponse =
293         UpdateDocumentResponse.newBuilder()
294             .setDocument(Document.newBuilder().build())
295             .setRuleEngineOutput(RuleEngineOutput.newBuilder().build())
296             .setMetadata(ResponseMetadata.newBuilder().build())
297             .build();
298     mockDocumentService.addResponse(expectedResponse);
299 
300     DocumentName name =
301         DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
302     Document document = Document.newBuilder().build();
303 
304     UpdateDocumentResponse actualResponse = client.updateDocument(name, document);
305     Assert.assertEquals(expectedResponse, actualResponse);
306 
307     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
308     Assert.assertEquals(1, actualRequests.size());
309     UpdateDocumentRequest actualRequest = ((UpdateDocumentRequest) actualRequests.get(0));
310 
311     Assert.assertEquals(name.toString(), actualRequest.getName());
312     Assert.assertEquals(document, actualRequest.getDocument());
313     Assert.assertTrue(
314         channelProvider.isHeaderSent(
315             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
316             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
317   }
318 
319   @Test
updateDocumentExceptionTest()320   public void updateDocumentExceptionTest() throws Exception {
321     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
322     mockDocumentService.addException(exception);
323 
324     try {
325       DocumentName name =
326           DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
327       Document document = Document.newBuilder().build();
328       client.updateDocument(name, document);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
updateDocumentTest2()336   public void updateDocumentTest2() throws Exception {
337     UpdateDocumentResponse expectedResponse =
338         UpdateDocumentResponse.newBuilder()
339             .setDocument(Document.newBuilder().build())
340             .setRuleEngineOutput(RuleEngineOutput.newBuilder().build())
341             .setMetadata(ResponseMetadata.newBuilder().build())
342             .build();
343     mockDocumentService.addResponse(expectedResponse);
344 
345     String name = "name3373707";
346     Document document = Document.newBuilder().build();
347 
348     UpdateDocumentResponse actualResponse = client.updateDocument(name, document);
349     Assert.assertEquals(expectedResponse, actualResponse);
350 
351     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
352     Assert.assertEquals(1, actualRequests.size());
353     UpdateDocumentRequest actualRequest = ((UpdateDocumentRequest) actualRequests.get(0));
354 
355     Assert.assertEquals(name, actualRequest.getName());
356     Assert.assertEquals(document, actualRequest.getDocument());
357     Assert.assertTrue(
358         channelProvider.isHeaderSent(
359             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
360             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
361   }
362 
363   @Test
updateDocumentExceptionTest2()364   public void updateDocumentExceptionTest2() throws Exception {
365     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
366     mockDocumentService.addException(exception);
367 
368     try {
369       String name = "name3373707";
370       Document document = Document.newBuilder().build();
371       client.updateDocument(name, document);
372       Assert.fail("No exception raised");
373     } catch (InvalidArgumentException e) {
374       // Expected exception.
375     }
376   }
377 
378   @Test
deleteDocumentTest()379   public void deleteDocumentTest() throws Exception {
380     Empty expectedResponse = Empty.newBuilder().build();
381     mockDocumentService.addResponse(expectedResponse);
382 
383     DocumentName name =
384         DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
385 
386     client.deleteDocument(name);
387 
388     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
389     Assert.assertEquals(1, actualRequests.size());
390     DeleteDocumentRequest actualRequest = ((DeleteDocumentRequest) actualRequests.get(0));
391 
392     Assert.assertEquals(name.toString(), actualRequest.getName());
393     Assert.assertTrue(
394         channelProvider.isHeaderSent(
395             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
396             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
397   }
398 
399   @Test
deleteDocumentExceptionTest()400   public void deleteDocumentExceptionTest() throws Exception {
401     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
402     mockDocumentService.addException(exception);
403 
404     try {
405       DocumentName name =
406           DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
407       client.deleteDocument(name);
408       Assert.fail("No exception raised");
409     } catch (InvalidArgumentException e) {
410       // Expected exception.
411     }
412   }
413 
414   @Test
deleteDocumentTest2()415   public void deleteDocumentTest2() throws Exception {
416     Empty expectedResponse = Empty.newBuilder().build();
417     mockDocumentService.addResponse(expectedResponse);
418 
419     String name = "name3373707";
420 
421     client.deleteDocument(name);
422 
423     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
424     Assert.assertEquals(1, actualRequests.size());
425     DeleteDocumentRequest actualRequest = ((DeleteDocumentRequest) actualRequests.get(0));
426 
427     Assert.assertEquals(name, actualRequest.getName());
428     Assert.assertTrue(
429         channelProvider.isHeaderSent(
430             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
431             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
432   }
433 
434   @Test
deleteDocumentExceptionTest2()435   public void deleteDocumentExceptionTest2() throws Exception {
436     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
437     mockDocumentService.addException(exception);
438 
439     try {
440       String name = "name3373707";
441       client.deleteDocument(name);
442       Assert.fail("No exception raised");
443     } catch (InvalidArgumentException e) {
444       // Expected exception.
445     }
446   }
447 
448   @Test
searchDocumentsTest()449   public void searchDocumentsTest() throws Exception {
450     SearchDocumentsResponse.MatchingDocument responsesElement =
451         SearchDocumentsResponse.MatchingDocument.newBuilder().build();
452     SearchDocumentsResponse expectedResponse =
453         SearchDocumentsResponse.newBuilder()
454             .setNextPageToken("")
455             .addAllMatchingDocuments(Arrays.asList(responsesElement))
456             .build();
457     mockDocumentService.addResponse(expectedResponse);
458 
459     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
460 
461     SearchDocumentsPagedResponse pagedListResponse = client.searchDocuments(parent);
462 
463     List<SearchDocumentsResponse.MatchingDocument> resources =
464         Lists.newArrayList(pagedListResponse.iterateAll());
465 
466     Assert.assertEquals(1, resources.size());
467     Assert.assertEquals(expectedResponse.getMatchingDocumentsList().get(0), resources.get(0));
468 
469     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
470     Assert.assertEquals(1, actualRequests.size());
471     SearchDocumentsRequest actualRequest = ((SearchDocumentsRequest) actualRequests.get(0));
472 
473     Assert.assertEquals(parent.toString(), actualRequest.getParent());
474     Assert.assertTrue(
475         channelProvider.isHeaderSent(
476             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
477             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
478   }
479 
480   @Test
searchDocumentsExceptionTest()481   public void searchDocumentsExceptionTest() throws Exception {
482     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
483     mockDocumentService.addException(exception);
484 
485     try {
486       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
487       client.searchDocuments(parent);
488       Assert.fail("No exception raised");
489     } catch (InvalidArgumentException e) {
490       // Expected exception.
491     }
492   }
493 
494   @Test
searchDocumentsTest2()495   public void searchDocumentsTest2() throws Exception {
496     SearchDocumentsResponse.MatchingDocument responsesElement =
497         SearchDocumentsResponse.MatchingDocument.newBuilder().build();
498     SearchDocumentsResponse expectedResponse =
499         SearchDocumentsResponse.newBuilder()
500             .setNextPageToken("")
501             .addAllMatchingDocuments(Arrays.asList(responsesElement))
502             .build();
503     mockDocumentService.addResponse(expectedResponse);
504 
505     String parent = "parent-995424086";
506 
507     SearchDocumentsPagedResponse pagedListResponse = client.searchDocuments(parent);
508 
509     List<SearchDocumentsResponse.MatchingDocument> resources =
510         Lists.newArrayList(pagedListResponse.iterateAll());
511 
512     Assert.assertEquals(1, resources.size());
513     Assert.assertEquals(expectedResponse.getMatchingDocumentsList().get(0), resources.get(0));
514 
515     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
516     Assert.assertEquals(1, actualRequests.size());
517     SearchDocumentsRequest actualRequest = ((SearchDocumentsRequest) actualRequests.get(0));
518 
519     Assert.assertEquals(parent, actualRequest.getParent());
520     Assert.assertTrue(
521         channelProvider.isHeaderSent(
522             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
523             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
524   }
525 
526   @Test
searchDocumentsExceptionTest2()527   public void searchDocumentsExceptionTest2() throws Exception {
528     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
529     mockDocumentService.addException(exception);
530 
531     try {
532       String parent = "parent-995424086";
533       client.searchDocuments(parent);
534       Assert.fail("No exception raised");
535     } catch (InvalidArgumentException e) {
536       // Expected exception.
537     }
538   }
539 
540   @Test
lockDocumentTest()541   public void lockDocumentTest() throws Exception {
542     Document expectedResponse =
543         Document.newBuilder()
544             .setName(
545                 DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]")
546                     .toString())
547             .setReferenceId("referenceId-16211514")
548             .setDisplayName("displayName1714148973")
549             .setTitle("title110371416")
550             .setDisplayUri("displayUri-914528950")
551             .setDocumentSchemaName(
552                 DocumentSchemaName.of("[PROJECT]", "[LOCATION]", "[DOCUMENT_SCHEMA]").toString())
553             .setStructuredContentUri("structuredContentUri-1039251868")
554             .addAllProperties(new ArrayList<Property>())
555             .setUpdateTime(Timestamp.newBuilder().build())
556             .setCreateTime(Timestamp.newBuilder().build())
557             .setRawDocumentFileType(RawDocumentFileType.forNumber(0))
558             .setAsyncEnabled(true)
559             .setContentCategory(ContentCategory.forNumber(0))
560             .setTextExtractionDisabled(true)
561             .setTextExtractionEnabled(true)
562             .setCreator("creator1028554796")
563             .setUpdater("updater-234430263")
564             .build();
565     mockDocumentService.addResponse(expectedResponse);
566 
567     DocumentName name =
568         DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
569 
570     Document actualResponse = client.lockDocument(name);
571     Assert.assertEquals(expectedResponse, actualResponse);
572 
573     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
574     Assert.assertEquals(1, actualRequests.size());
575     LockDocumentRequest actualRequest = ((LockDocumentRequest) actualRequests.get(0));
576 
577     Assert.assertEquals(name.toString(), actualRequest.getName());
578     Assert.assertTrue(
579         channelProvider.isHeaderSent(
580             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
581             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
582   }
583 
584   @Test
lockDocumentExceptionTest()585   public void lockDocumentExceptionTest() throws Exception {
586     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
587     mockDocumentService.addException(exception);
588 
589     try {
590       DocumentName name =
591           DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]");
592       client.lockDocument(name);
593       Assert.fail("No exception raised");
594     } catch (InvalidArgumentException e) {
595       // Expected exception.
596     }
597   }
598 
599   @Test
lockDocumentTest2()600   public void lockDocumentTest2() throws Exception {
601     Document expectedResponse =
602         Document.newBuilder()
603             .setName(
604                 DocumentName.ofProjectLocationDocumentName("[PROJECT]", "[LOCATION]", "[DOCUMENT]")
605                     .toString())
606             .setReferenceId("referenceId-16211514")
607             .setDisplayName("displayName1714148973")
608             .setTitle("title110371416")
609             .setDisplayUri("displayUri-914528950")
610             .setDocumentSchemaName(
611                 DocumentSchemaName.of("[PROJECT]", "[LOCATION]", "[DOCUMENT_SCHEMA]").toString())
612             .setStructuredContentUri("structuredContentUri-1039251868")
613             .addAllProperties(new ArrayList<Property>())
614             .setUpdateTime(Timestamp.newBuilder().build())
615             .setCreateTime(Timestamp.newBuilder().build())
616             .setRawDocumentFileType(RawDocumentFileType.forNumber(0))
617             .setAsyncEnabled(true)
618             .setContentCategory(ContentCategory.forNumber(0))
619             .setTextExtractionDisabled(true)
620             .setTextExtractionEnabled(true)
621             .setCreator("creator1028554796")
622             .setUpdater("updater-234430263")
623             .build();
624     mockDocumentService.addResponse(expectedResponse);
625 
626     String name = "name3373707";
627 
628     Document actualResponse = client.lockDocument(name);
629     Assert.assertEquals(expectedResponse, actualResponse);
630 
631     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
632     Assert.assertEquals(1, actualRequests.size());
633     LockDocumentRequest actualRequest = ((LockDocumentRequest) actualRequests.get(0));
634 
635     Assert.assertEquals(name, actualRequest.getName());
636     Assert.assertTrue(
637         channelProvider.isHeaderSent(
638             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
639             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
640   }
641 
642   @Test
lockDocumentExceptionTest2()643   public void lockDocumentExceptionTest2() throws Exception {
644     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
645     mockDocumentService.addException(exception);
646 
647     try {
648       String name = "name3373707";
649       client.lockDocument(name);
650       Assert.fail("No exception raised");
651     } catch (InvalidArgumentException e) {
652       // Expected exception.
653     }
654   }
655 
656   @Test
fetchAclTest()657   public void fetchAclTest() throws Exception {
658     FetchAclResponse expectedResponse =
659         FetchAclResponse.newBuilder()
660             .setPolicy(Policy.newBuilder().build())
661             .setMetadata(ResponseMetadata.newBuilder().build())
662             .build();
663     mockDocumentService.addResponse(expectedResponse);
664 
665     String resource = "resource-341064690";
666 
667     FetchAclResponse actualResponse = client.fetchAcl(resource);
668     Assert.assertEquals(expectedResponse, actualResponse);
669 
670     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
671     Assert.assertEquals(1, actualRequests.size());
672     FetchAclRequest actualRequest = ((FetchAclRequest) actualRequests.get(0));
673 
674     Assert.assertEquals(resource, actualRequest.getResource());
675     Assert.assertTrue(
676         channelProvider.isHeaderSent(
677             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
678             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
679   }
680 
681   @Test
fetchAclExceptionTest()682   public void fetchAclExceptionTest() throws Exception {
683     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
684     mockDocumentService.addException(exception);
685 
686     try {
687       String resource = "resource-341064690";
688       client.fetchAcl(resource);
689       Assert.fail("No exception raised");
690     } catch (InvalidArgumentException e) {
691       // Expected exception.
692     }
693   }
694 
695   @Test
setAclTest()696   public void setAclTest() throws Exception {
697     SetAclResponse expectedResponse =
698         SetAclResponse.newBuilder()
699             .setPolicy(Policy.newBuilder().build())
700             .setMetadata(ResponseMetadata.newBuilder().build())
701             .build();
702     mockDocumentService.addResponse(expectedResponse);
703 
704     String resource = "resource-341064690";
705     Policy policy = Policy.newBuilder().build();
706 
707     SetAclResponse actualResponse = client.setAcl(resource, policy);
708     Assert.assertEquals(expectedResponse, actualResponse);
709 
710     List<AbstractMessage> actualRequests = mockDocumentService.getRequests();
711     Assert.assertEquals(1, actualRequests.size());
712     SetAclRequest actualRequest = ((SetAclRequest) actualRequests.get(0));
713 
714     Assert.assertEquals(resource, actualRequest.getResource());
715     Assert.assertEquals(policy, actualRequest.getPolicy());
716     Assert.assertTrue(
717         channelProvider.isHeaderSent(
718             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
719             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
720   }
721 
722   @Test
setAclExceptionTest()723   public void setAclExceptionTest() throws Exception {
724     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
725     mockDocumentService.addException(exception);
726 
727     try {
728       String resource = "resource-341064690";
729       Policy policy = Policy.newBuilder().build();
730       client.setAcl(resource, policy);
731       Assert.fail("No exception raised");
732     } catch (InvalidArgumentException e) {
733       // Expected exception.
734     }
735   }
736 }
737