• 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.enterpriseknowledgegraph.v1;
18 
19 import static com.google.cloud.enterpriseknowledgegraph.v1.EnterpriseKnowledgeGraphServiceClient.ListEntityReconciliationJobsPagedResponse;
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.protobuf.AbstractMessage;
30 import com.google.protobuf.Empty;
31 import com.google.protobuf.ListValue;
32 import com.google.protobuf.Timestamp;
33 import com.google.protobuf.Value;
34 import com.google.rpc.Status;
35 import io.grpc.StatusRuntimeException;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
40 import java.util.UUID;
41 import javax.annotation.Generated;
42 import org.junit.After;
43 import org.junit.AfterClass;
44 import org.junit.Assert;
45 import org.junit.Before;
46 import org.junit.BeforeClass;
47 import org.junit.Test;
48 
49 @Generated("by gapic-generator-java")
50 public class EnterpriseKnowledgeGraphServiceClientTest {
51   private static MockEnterpriseKnowledgeGraphService mockEnterpriseKnowledgeGraphService;
52   private static MockServiceHelper mockServiceHelper;
53   private LocalChannelProvider channelProvider;
54   private EnterpriseKnowledgeGraphServiceClient client;
55 
56   @BeforeClass
startStaticServer()57   public static void startStaticServer() {
58     mockEnterpriseKnowledgeGraphService = new MockEnterpriseKnowledgeGraphService();
59     mockServiceHelper =
60         new MockServiceHelper(
61             UUID.randomUUID().toString(),
62             Arrays.<MockGrpcService>asList(mockEnterpriseKnowledgeGraphService));
63     mockServiceHelper.start();
64   }
65 
66   @AfterClass
stopServer()67   public static void stopServer() {
68     mockServiceHelper.stop();
69   }
70 
71   @Before
setUp()72   public void setUp() throws IOException {
73     mockServiceHelper.reset();
74     channelProvider = mockServiceHelper.createChannelProvider();
75     EnterpriseKnowledgeGraphServiceSettings settings =
76         EnterpriseKnowledgeGraphServiceSettings.newBuilder()
77             .setTransportChannelProvider(channelProvider)
78             .setCredentialsProvider(NoCredentialsProvider.create())
79             .build();
80     client = EnterpriseKnowledgeGraphServiceClient.create(settings);
81   }
82 
83   @After
tearDown()84   public void tearDown() throws Exception {
85     client.close();
86   }
87 
88   @Test
createEntityReconciliationJobTest()89   public void createEntityReconciliationJobTest() throws Exception {
90     EntityReconciliationJob expectedResponse =
91         EntityReconciliationJob.newBuilder()
92             .setName(
93                 EntityReconciliationJobName.of(
94                         "[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]")
95                     .toString())
96             .setInputConfig(InputConfig.newBuilder().build())
97             .setOutputConfig(OutputConfig.newBuilder().build())
98             .setState(JobState.forNumber(0))
99             .setError(Status.newBuilder().build())
100             .setCreateTime(Timestamp.newBuilder().build())
101             .setEndTime(Timestamp.newBuilder().build())
102             .setUpdateTime(Timestamp.newBuilder().build())
103             .setReconConfig(ReconConfig.newBuilder().build())
104             .build();
105     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
106 
107     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
108     EntityReconciliationJob entityReconciliationJob = EntityReconciliationJob.newBuilder().build();
109 
110     EntityReconciliationJob actualResponse =
111         client.createEntityReconciliationJob(parent, entityReconciliationJob);
112     Assert.assertEquals(expectedResponse, actualResponse);
113 
114     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
115     Assert.assertEquals(1, actualRequests.size());
116     CreateEntityReconciliationJobRequest actualRequest =
117         ((CreateEntityReconciliationJobRequest) actualRequests.get(0));
118 
119     Assert.assertEquals(parent.toString(), actualRequest.getParent());
120     Assert.assertEquals(entityReconciliationJob, actualRequest.getEntityReconciliationJob());
121     Assert.assertTrue(
122         channelProvider.isHeaderSent(
123             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
124             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
125   }
126 
127   @Test
createEntityReconciliationJobExceptionTest()128   public void createEntityReconciliationJobExceptionTest() throws Exception {
129     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
130     mockEnterpriseKnowledgeGraphService.addException(exception);
131 
132     try {
133       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
134       EntityReconciliationJob entityReconciliationJob =
135           EntityReconciliationJob.newBuilder().build();
136       client.createEntityReconciliationJob(parent, entityReconciliationJob);
137       Assert.fail("No exception raised");
138     } catch (InvalidArgumentException e) {
139       // Expected exception.
140     }
141   }
142 
143   @Test
createEntityReconciliationJobTest2()144   public void createEntityReconciliationJobTest2() throws Exception {
145     EntityReconciliationJob expectedResponse =
146         EntityReconciliationJob.newBuilder()
147             .setName(
148                 EntityReconciliationJobName.of(
149                         "[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]")
150                     .toString())
151             .setInputConfig(InputConfig.newBuilder().build())
152             .setOutputConfig(OutputConfig.newBuilder().build())
153             .setState(JobState.forNumber(0))
154             .setError(Status.newBuilder().build())
155             .setCreateTime(Timestamp.newBuilder().build())
156             .setEndTime(Timestamp.newBuilder().build())
157             .setUpdateTime(Timestamp.newBuilder().build())
158             .setReconConfig(ReconConfig.newBuilder().build())
159             .build();
160     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
161 
162     String parent = "parent-995424086";
163     EntityReconciliationJob entityReconciliationJob = EntityReconciliationJob.newBuilder().build();
164 
165     EntityReconciliationJob actualResponse =
166         client.createEntityReconciliationJob(parent, entityReconciliationJob);
167     Assert.assertEquals(expectedResponse, actualResponse);
168 
169     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
170     Assert.assertEquals(1, actualRequests.size());
171     CreateEntityReconciliationJobRequest actualRequest =
172         ((CreateEntityReconciliationJobRequest) actualRequests.get(0));
173 
174     Assert.assertEquals(parent, actualRequest.getParent());
175     Assert.assertEquals(entityReconciliationJob, actualRequest.getEntityReconciliationJob());
176     Assert.assertTrue(
177         channelProvider.isHeaderSent(
178             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
179             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
180   }
181 
182   @Test
createEntityReconciliationJobExceptionTest2()183   public void createEntityReconciliationJobExceptionTest2() throws Exception {
184     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
185     mockEnterpriseKnowledgeGraphService.addException(exception);
186 
187     try {
188       String parent = "parent-995424086";
189       EntityReconciliationJob entityReconciliationJob =
190           EntityReconciliationJob.newBuilder().build();
191       client.createEntityReconciliationJob(parent, entityReconciliationJob);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
getEntityReconciliationJobTest()199   public void getEntityReconciliationJobTest() throws Exception {
200     EntityReconciliationJob expectedResponse =
201         EntityReconciliationJob.newBuilder()
202             .setName(
203                 EntityReconciliationJobName.of(
204                         "[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]")
205                     .toString())
206             .setInputConfig(InputConfig.newBuilder().build())
207             .setOutputConfig(OutputConfig.newBuilder().build())
208             .setState(JobState.forNumber(0))
209             .setError(Status.newBuilder().build())
210             .setCreateTime(Timestamp.newBuilder().build())
211             .setEndTime(Timestamp.newBuilder().build())
212             .setUpdateTime(Timestamp.newBuilder().build())
213             .setReconConfig(ReconConfig.newBuilder().build())
214             .build();
215     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
216 
217     EntityReconciliationJobName name =
218         EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
219 
220     EntityReconciliationJob actualResponse = client.getEntityReconciliationJob(name);
221     Assert.assertEquals(expectedResponse, actualResponse);
222 
223     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
224     Assert.assertEquals(1, actualRequests.size());
225     GetEntityReconciliationJobRequest actualRequest =
226         ((GetEntityReconciliationJobRequest) actualRequests.get(0));
227 
228     Assert.assertEquals(name.toString(), actualRequest.getName());
229     Assert.assertTrue(
230         channelProvider.isHeaderSent(
231             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
232             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
233   }
234 
235   @Test
getEntityReconciliationJobExceptionTest()236   public void getEntityReconciliationJobExceptionTest() throws Exception {
237     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
238     mockEnterpriseKnowledgeGraphService.addException(exception);
239 
240     try {
241       EntityReconciliationJobName name =
242           EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
243       client.getEntityReconciliationJob(name);
244       Assert.fail("No exception raised");
245     } catch (InvalidArgumentException e) {
246       // Expected exception.
247     }
248   }
249 
250   @Test
getEntityReconciliationJobTest2()251   public void getEntityReconciliationJobTest2() throws Exception {
252     EntityReconciliationJob expectedResponse =
253         EntityReconciliationJob.newBuilder()
254             .setName(
255                 EntityReconciliationJobName.of(
256                         "[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]")
257                     .toString())
258             .setInputConfig(InputConfig.newBuilder().build())
259             .setOutputConfig(OutputConfig.newBuilder().build())
260             .setState(JobState.forNumber(0))
261             .setError(Status.newBuilder().build())
262             .setCreateTime(Timestamp.newBuilder().build())
263             .setEndTime(Timestamp.newBuilder().build())
264             .setUpdateTime(Timestamp.newBuilder().build())
265             .setReconConfig(ReconConfig.newBuilder().build())
266             .build();
267     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
268 
269     String name = "name3373707";
270 
271     EntityReconciliationJob actualResponse = client.getEntityReconciliationJob(name);
272     Assert.assertEquals(expectedResponse, actualResponse);
273 
274     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
275     Assert.assertEquals(1, actualRequests.size());
276     GetEntityReconciliationJobRequest actualRequest =
277         ((GetEntityReconciliationJobRequest) actualRequests.get(0));
278 
279     Assert.assertEquals(name, actualRequest.getName());
280     Assert.assertTrue(
281         channelProvider.isHeaderSent(
282             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
283             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
284   }
285 
286   @Test
getEntityReconciliationJobExceptionTest2()287   public void getEntityReconciliationJobExceptionTest2() throws Exception {
288     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
289     mockEnterpriseKnowledgeGraphService.addException(exception);
290 
291     try {
292       String name = "name3373707";
293       client.getEntityReconciliationJob(name);
294       Assert.fail("No exception raised");
295     } catch (InvalidArgumentException e) {
296       // Expected exception.
297     }
298   }
299 
300   @Test
listEntityReconciliationJobsTest()301   public void listEntityReconciliationJobsTest() throws Exception {
302     EntityReconciliationJob responsesElement = EntityReconciliationJob.newBuilder().build();
303     ListEntityReconciliationJobsResponse expectedResponse =
304         ListEntityReconciliationJobsResponse.newBuilder()
305             .setNextPageToken("")
306             .addAllEntityReconciliationJobs(Arrays.asList(responsesElement))
307             .build();
308     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
309 
310     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
311 
312     ListEntityReconciliationJobsPagedResponse pagedListResponse =
313         client.listEntityReconciliationJobs(parent);
314 
315     List<EntityReconciliationJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
316 
317     Assert.assertEquals(1, resources.size());
318     Assert.assertEquals(
319         expectedResponse.getEntityReconciliationJobsList().get(0), resources.get(0));
320 
321     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
322     Assert.assertEquals(1, actualRequests.size());
323     ListEntityReconciliationJobsRequest actualRequest =
324         ((ListEntityReconciliationJobsRequest) actualRequests.get(0));
325 
326     Assert.assertEquals(parent.toString(), actualRequest.getParent());
327     Assert.assertTrue(
328         channelProvider.isHeaderSent(
329             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
330             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
331   }
332 
333   @Test
listEntityReconciliationJobsExceptionTest()334   public void listEntityReconciliationJobsExceptionTest() throws Exception {
335     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
336     mockEnterpriseKnowledgeGraphService.addException(exception);
337 
338     try {
339       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
340       client.listEntityReconciliationJobs(parent);
341       Assert.fail("No exception raised");
342     } catch (InvalidArgumentException e) {
343       // Expected exception.
344     }
345   }
346 
347   @Test
listEntityReconciliationJobsTest2()348   public void listEntityReconciliationJobsTest2() throws Exception {
349     EntityReconciliationJob responsesElement = EntityReconciliationJob.newBuilder().build();
350     ListEntityReconciliationJobsResponse expectedResponse =
351         ListEntityReconciliationJobsResponse.newBuilder()
352             .setNextPageToken("")
353             .addAllEntityReconciliationJobs(Arrays.asList(responsesElement))
354             .build();
355     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
356 
357     String parent = "parent-995424086";
358 
359     ListEntityReconciliationJobsPagedResponse pagedListResponse =
360         client.listEntityReconciliationJobs(parent);
361 
362     List<EntityReconciliationJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
363 
364     Assert.assertEquals(1, resources.size());
365     Assert.assertEquals(
366         expectedResponse.getEntityReconciliationJobsList().get(0), resources.get(0));
367 
368     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
369     Assert.assertEquals(1, actualRequests.size());
370     ListEntityReconciliationJobsRequest actualRequest =
371         ((ListEntityReconciliationJobsRequest) actualRequests.get(0));
372 
373     Assert.assertEquals(parent, actualRequest.getParent());
374     Assert.assertTrue(
375         channelProvider.isHeaderSent(
376             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
377             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
378   }
379 
380   @Test
listEntityReconciliationJobsExceptionTest2()381   public void listEntityReconciliationJobsExceptionTest2() throws Exception {
382     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
383     mockEnterpriseKnowledgeGraphService.addException(exception);
384 
385     try {
386       String parent = "parent-995424086";
387       client.listEntityReconciliationJobs(parent);
388       Assert.fail("No exception raised");
389     } catch (InvalidArgumentException e) {
390       // Expected exception.
391     }
392   }
393 
394   @Test
cancelEntityReconciliationJobTest()395   public void cancelEntityReconciliationJobTest() throws Exception {
396     Empty expectedResponse = Empty.newBuilder().build();
397     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
398 
399     EntityReconciliationJobName name =
400         EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
401 
402     client.cancelEntityReconciliationJob(name);
403 
404     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
405     Assert.assertEquals(1, actualRequests.size());
406     CancelEntityReconciliationJobRequest actualRequest =
407         ((CancelEntityReconciliationJobRequest) actualRequests.get(0));
408 
409     Assert.assertEquals(name.toString(), actualRequest.getName());
410     Assert.assertTrue(
411         channelProvider.isHeaderSent(
412             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
413             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
414   }
415 
416   @Test
cancelEntityReconciliationJobExceptionTest()417   public void cancelEntityReconciliationJobExceptionTest() throws Exception {
418     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
419     mockEnterpriseKnowledgeGraphService.addException(exception);
420 
421     try {
422       EntityReconciliationJobName name =
423           EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
424       client.cancelEntityReconciliationJob(name);
425       Assert.fail("No exception raised");
426     } catch (InvalidArgumentException e) {
427       // Expected exception.
428     }
429   }
430 
431   @Test
cancelEntityReconciliationJobTest2()432   public void cancelEntityReconciliationJobTest2() throws Exception {
433     Empty expectedResponse = Empty.newBuilder().build();
434     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
435 
436     String name = "name3373707";
437 
438     client.cancelEntityReconciliationJob(name);
439 
440     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
441     Assert.assertEquals(1, actualRequests.size());
442     CancelEntityReconciliationJobRequest actualRequest =
443         ((CancelEntityReconciliationJobRequest) actualRequests.get(0));
444 
445     Assert.assertEquals(name, actualRequest.getName());
446     Assert.assertTrue(
447         channelProvider.isHeaderSent(
448             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
449             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
450   }
451 
452   @Test
cancelEntityReconciliationJobExceptionTest2()453   public void cancelEntityReconciliationJobExceptionTest2() throws Exception {
454     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
455     mockEnterpriseKnowledgeGraphService.addException(exception);
456 
457     try {
458       String name = "name3373707";
459       client.cancelEntityReconciliationJob(name);
460       Assert.fail("No exception raised");
461     } catch (InvalidArgumentException e) {
462       // Expected exception.
463     }
464   }
465 
466   @Test
deleteEntityReconciliationJobTest()467   public void deleteEntityReconciliationJobTest() throws Exception {
468     Empty expectedResponse = Empty.newBuilder().build();
469     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
470 
471     EntityReconciliationJobName name =
472         EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
473 
474     client.deleteEntityReconciliationJob(name);
475 
476     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
477     Assert.assertEquals(1, actualRequests.size());
478     DeleteEntityReconciliationJobRequest actualRequest =
479         ((DeleteEntityReconciliationJobRequest) actualRequests.get(0));
480 
481     Assert.assertEquals(name.toString(), actualRequest.getName());
482     Assert.assertTrue(
483         channelProvider.isHeaderSent(
484             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
485             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
486   }
487 
488   @Test
deleteEntityReconciliationJobExceptionTest()489   public void deleteEntityReconciliationJobExceptionTest() throws Exception {
490     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
491     mockEnterpriseKnowledgeGraphService.addException(exception);
492 
493     try {
494       EntityReconciliationJobName name =
495           EntityReconciliationJobName.of("[PROJECT]", "[LOCATION]", "[ENTITY_RECONCILIATION_JOB]");
496       client.deleteEntityReconciliationJob(name);
497       Assert.fail("No exception raised");
498     } catch (InvalidArgumentException e) {
499       // Expected exception.
500     }
501   }
502 
503   @Test
deleteEntityReconciliationJobTest2()504   public void deleteEntityReconciliationJobTest2() throws Exception {
505     Empty expectedResponse = Empty.newBuilder().build();
506     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
507 
508     String name = "name3373707";
509 
510     client.deleteEntityReconciliationJob(name);
511 
512     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
513     Assert.assertEquals(1, actualRequests.size());
514     DeleteEntityReconciliationJobRequest actualRequest =
515         ((DeleteEntityReconciliationJobRequest) actualRequests.get(0));
516 
517     Assert.assertEquals(name, actualRequest.getName());
518     Assert.assertTrue(
519         channelProvider.isHeaderSent(
520             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
521             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
522   }
523 
524   @Test
deleteEntityReconciliationJobExceptionTest2()525   public void deleteEntityReconciliationJobExceptionTest2() throws Exception {
526     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
527     mockEnterpriseKnowledgeGraphService.addException(exception);
528 
529     try {
530       String name = "name3373707";
531       client.deleteEntityReconciliationJob(name);
532       Assert.fail("No exception raised");
533     } catch (InvalidArgumentException e) {
534       // Expected exception.
535     }
536   }
537 
538   @Test
lookupTest()539   public void lookupTest() throws Exception {
540     LookupResponse expectedResponse =
541         LookupResponse.newBuilder()
542             .setContext(Value.newBuilder().setBoolValue(true).build())
543             .setType(Value.newBuilder().setBoolValue(true).build())
544             .setItemListElement(ListValue.newBuilder().build())
545             .build();
546     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
547 
548     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
549     List<String> ids = new ArrayList<>();
550 
551     LookupResponse actualResponse = client.lookup(parent, ids);
552     Assert.assertEquals(expectedResponse, actualResponse);
553 
554     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
555     Assert.assertEquals(1, actualRequests.size());
556     LookupRequest actualRequest = ((LookupRequest) actualRequests.get(0));
557 
558     Assert.assertEquals(parent.toString(), actualRequest.getParent());
559     Assert.assertEquals(ids, actualRequest.getIdsList());
560     Assert.assertTrue(
561         channelProvider.isHeaderSent(
562             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
563             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
564   }
565 
566   @Test
lookupExceptionTest()567   public void lookupExceptionTest() throws Exception {
568     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
569     mockEnterpriseKnowledgeGraphService.addException(exception);
570 
571     try {
572       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
573       List<String> ids = new ArrayList<>();
574       client.lookup(parent, ids);
575       Assert.fail("No exception raised");
576     } catch (InvalidArgumentException e) {
577       // Expected exception.
578     }
579   }
580 
581   @Test
lookupTest2()582   public void lookupTest2() throws Exception {
583     LookupResponse expectedResponse =
584         LookupResponse.newBuilder()
585             .setContext(Value.newBuilder().setBoolValue(true).build())
586             .setType(Value.newBuilder().setBoolValue(true).build())
587             .setItemListElement(ListValue.newBuilder().build())
588             .build();
589     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
590 
591     String parent = "parent-995424086";
592     List<String> ids = new ArrayList<>();
593 
594     LookupResponse actualResponse = client.lookup(parent, ids);
595     Assert.assertEquals(expectedResponse, actualResponse);
596 
597     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
598     Assert.assertEquals(1, actualRequests.size());
599     LookupRequest actualRequest = ((LookupRequest) actualRequests.get(0));
600 
601     Assert.assertEquals(parent, actualRequest.getParent());
602     Assert.assertEquals(ids, actualRequest.getIdsList());
603     Assert.assertTrue(
604         channelProvider.isHeaderSent(
605             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
606             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
607   }
608 
609   @Test
lookupExceptionTest2()610   public void lookupExceptionTest2() throws Exception {
611     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
612     mockEnterpriseKnowledgeGraphService.addException(exception);
613 
614     try {
615       String parent = "parent-995424086";
616       List<String> ids = new ArrayList<>();
617       client.lookup(parent, ids);
618       Assert.fail("No exception raised");
619     } catch (InvalidArgumentException e) {
620       // Expected exception.
621     }
622   }
623 
624   @Test
searchTest()625   public void searchTest() throws Exception {
626     SearchResponse expectedResponse =
627         SearchResponse.newBuilder()
628             .setContext(Value.newBuilder().setBoolValue(true).build())
629             .setType(Value.newBuilder().setBoolValue(true).build())
630             .setItemListElement(ListValue.newBuilder().build())
631             .build();
632     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
633 
634     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
635     String query = "query107944136";
636 
637     SearchResponse actualResponse = client.search(parent, query);
638     Assert.assertEquals(expectedResponse, actualResponse);
639 
640     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
641     Assert.assertEquals(1, actualRequests.size());
642     SearchRequest actualRequest = ((SearchRequest) actualRequests.get(0));
643 
644     Assert.assertEquals(parent.toString(), actualRequest.getParent());
645     Assert.assertEquals(query, actualRequest.getQuery());
646     Assert.assertTrue(
647         channelProvider.isHeaderSent(
648             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
649             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
650   }
651 
652   @Test
searchExceptionTest()653   public void searchExceptionTest() throws Exception {
654     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
655     mockEnterpriseKnowledgeGraphService.addException(exception);
656 
657     try {
658       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
659       String query = "query107944136";
660       client.search(parent, query);
661       Assert.fail("No exception raised");
662     } catch (InvalidArgumentException e) {
663       // Expected exception.
664     }
665   }
666 
667   @Test
searchTest2()668   public void searchTest2() throws Exception {
669     SearchResponse expectedResponse =
670         SearchResponse.newBuilder()
671             .setContext(Value.newBuilder().setBoolValue(true).build())
672             .setType(Value.newBuilder().setBoolValue(true).build())
673             .setItemListElement(ListValue.newBuilder().build())
674             .build();
675     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
676 
677     String parent = "parent-995424086";
678     String query = "query107944136";
679 
680     SearchResponse actualResponse = client.search(parent, query);
681     Assert.assertEquals(expectedResponse, actualResponse);
682 
683     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
684     Assert.assertEquals(1, actualRequests.size());
685     SearchRequest actualRequest = ((SearchRequest) actualRequests.get(0));
686 
687     Assert.assertEquals(parent, actualRequest.getParent());
688     Assert.assertEquals(query, actualRequest.getQuery());
689     Assert.assertTrue(
690         channelProvider.isHeaderSent(
691             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
692             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
693   }
694 
695   @Test
searchExceptionTest2()696   public void searchExceptionTest2() throws Exception {
697     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
698     mockEnterpriseKnowledgeGraphService.addException(exception);
699 
700     try {
701       String parent = "parent-995424086";
702       String query = "query107944136";
703       client.search(parent, query);
704       Assert.fail("No exception raised");
705     } catch (InvalidArgumentException e) {
706       // Expected exception.
707     }
708   }
709 
710   @Test
lookupPublicKgTest()711   public void lookupPublicKgTest() throws Exception {
712     LookupPublicKgResponse expectedResponse =
713         LookupPublicKgResponse.newBuilder()
714             .setContext(Value.newBuilder().setBoolValue(true).build())
715             .setType(Value.newBuilder().setBoolValue(true).build())
716             .setItemListElement(ListValue.newBuilder().build())
717             .build();
718     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
719 
720     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
721     List<String> ids = new ArrayList<>();
722 
723     LookupPublicKgResponse actualResponse = client.lookupPublicKg(parent, ids);
724     Assert.assertEquals(expectedResponse, actualResponse);
725 
726     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
727     Assert.assertEquals(1, actualRequests.size());
728     LookupPublicKgRequest actualRequest = ((LookupPublicKgRequest) actualRequests.get(0));
729 
730     Assert.assertEquals(parent.toString(), actualRequest.getParent());
731     Assert.assertEquals(ids, actualRequest.getIdsList());
732     Assert.assertTrue(
733         channelProvider.isHeaderSent(
734             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
735             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
736   }
737 
738   @Test
lookupPublicKgExceptionTest()739   public void lookupPublicKgExceptionTest() throws Exception {
740     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
741     mockEnterpriseKnowledgeGraphService.addException(exception);
742 
743     try {
744       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
745       List<String> ids = new ArrayList<>();
746       client.lookupPublicKg(parent, ids);
747       Assert.fail("No exception raised");
748     } catch (InvalidArgumentException e) {
749       // Expected exception.
750     }
751   }
752 
753   @Test
lookupPublicKgTest2()754   public void lookupPublicKgTest2() throws Exception {
755     LookupPublicKgResponse expectedResponse =
756         LookupPublicKgResponse.newBuilder()
757             .setContext(Value.newBuilder().setBoolValue(true).build())
758             .setType(Value.newBuilder().setBoolValue(true).build())
759             .setItemListElement(ListValue.newBuilder().build())
760             .build();
761     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
762 
763     String parent = "parent-995424086";
764     List<String> ids = new ArrayList<>();
765 
766     LookupPublicKgResponse actualResponse = client.lookupPublicKg(parent, ids);
767     Assert.assertEquals(expectedResponse, actualResponse);
768 
769     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
770     Assert.assertEquals(1, actualRequests.size());
771     LookupPublicKgRequest actualRequest = ((LookupPublicKgRequest) actualRequests.get(0));
772 
773     Assert.assertEquals(parent, actualRequest.getParent());
774     Assert.assertEquals(ids, actualRequest.getIdsList());
775     Assert.assertTrue(
776         channelProvider.isHeaderSent(
777             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
778             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
779   }
780 
781   @Test
lookupPublicKgExceptionTest2()782   public void lookupPublicKgExceptionTest2() throws Exception {
783     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
784     mockEnterpriseKnowledgeGraphService.addException(exception);
785 
786     try {
787       String parent = "parent-995424086";
788       List<String> ids = new ArrayList<>();
789       client.lookupPublicKg(parent, ids);
790       Assert.fail("No exception raised");
791     } catch (InvalidArgumentException e) {
792       // Expected exception.
793     }
794   }
795 
796   @Test
searchPublicKgTest()797   public void searchPublicKgTest() throws Exception {
798     SearchPublicKgResponse expectedResponse =
799         SearchPublicKgResponse.newBuilder()
800             .setContext(Value.newBuilder().setBoolValue(true).build())
801             .setType(Value.newBuilder().setBoolValue(true).build())
802             .setItemListElement(ListValue.newBuilder().build())
803             .build();
804     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
805 
806     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
807     String query = "query107944136";
808 
809     SearchPublicKgResponse actualResponse = client.searchPublicKg(parent, query);
810     Assert.assertEquals(expectedResponse, actualResponse);
811 
812     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
813     Assert.assertEquals(1, actualRequests.size());
814     SearchPublicKgRequest actualRequest = ((SearchPublicKgRequest) actualRequests.get(0));
815 
816     Assert.assertEquals(parent.toString(), actualRequest.getParent());
817     Assert.assertEquals(query, actualRequest.getQuery());
818     Assert.assertTrue(
819         channelProvider.isHeaderSent(
820             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
821             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
822   }
823 
824   @Test
searchPublicKgExceptionTest()825   public void searchPublicKgExceptionTest() throws Exception {
826     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
827     mockEnterpriseKnowledgeGraphService.addException(exception);
828 
829     try {
830       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
831       String query = "query107944136";
832       client.searchPublicKg(parent, query);
833       Assert.fail("No exception raised");
834     } catch (InvalidArgumentException e) {
835       // Expected exception.
836     }
837   }
838 
839   @Test
searchPublicKgTest2()840   public void searchPublicKgTest2() throws Exception {
841     SearchPublicKgResponse expectedResponse =
842         SearchPublicKgResponse.newBuilder()
843             .setContext(Value.newBuilder().setBoolValue(true).build())
844             .setType(Value.newBuilder().setBoolValue(true).build())
845             .setItemListElement(ListValue.newBuilder().build())
846             .build();
847     mockEnterpriseKnowledgeGraphService.addResponse(expectedResponse);
848 
849     String parent = "parent-995424086";
850     String query = "query107944136";
851 
852     SearchPublicKgResponse actualResponse = client.searchPublicKg(parent, query);
853     Assert.assertEquals(expectedResponse, actualResponse);
854 
855     List<AbstractMessage> actualRequests = mockEnterpriseKnowledgeGraphService.getRequests();
856     Assert.assertEquals(1, actualRequests.size());
857     SearchPublicKgRequest actualRequest = ((SearchPublicKgRequest) actualRequests.get(0));
858 
859     Assert.assertEquals(parent, actualRequest.getParent());
860     Assert.assertEquals(query, actualRequest.getQuery());
861     Assert.assertTrue(
862         channelProvider.isHeaderSent(
863             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
864             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
865   }
866 
867   @Test
searchPublicKgExceptionTest2()868   public void searchPublicKgExceptionTest2() throws Exception {
869     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
870     mockEnterpriseKnowledgeGraphService.addException(exception);
871 
872     try {
873       String parent = "parent-995424086";
874       String query = "query107944136";
875       client.searchPublicKg(parent, query);
876       Assert.fail("No exception raised");
877     } catch (InvalidArgumentException e) {
878       // Expected exception.
879     }
880   }
881 }
882