• 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.SynonymSetServiceClient.ListSynonymSetsPagedResponse;
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 io.grpc.StatusRuntimeException;
32 import java.io.IOException;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.List;
36 import java.util.UUID;
37 import javax.annotation.Generated;
38 import org.junit.After;
39 import org.junit.AfterClass;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.BeforeClass;
43 import org.junit.Test;
44 
45 @Generated("by gapic-generator-java")
46 public class SynonymSetServiceClientTest {
47   private static MockServiceHelper mockServiceHelper;
48   private static MockSynonymSetService mockSynonymSetService;
49   private LocalChannelProvider channelProvider;
50   private SynonymSetServiceClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() {
54     mockSynonymSetService = new MockSynonymSetService();
55     mockServiceHelper =
56         new MockServiceHelper(
57             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockSynonymSetService));
58     mockServiceHelper.start();
59   }
60 
61   @AfterClass
stopServer()62   public static void stopServer() {
63     mockServiceHelper.stop();
64   }
65 
66   @Before
setUp()67   public void setUp() throws IOException {
68     mockServiceHelper.reset();
69     channelProvider = mockServiceHelper.createChannelProvider();
70     SynonymSetServiceSettings settings =
71         SynonymSetServiceSettings.newBuilder()
72             .setTransportChannelProvider(channelProvider)
73             .setCredentialsProvider(NoCredentialsProvider.create())
74             .build();
75     client = SynonymSetServiceClient.create(settings);
76   }
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     client.close();
81   }
82 
83   @Test
createSynonymSetTest()84   public void createSynonymSetTest() throws Exception {
85     SynonymSet expectedResponse =
86         SynonymSet.newBuilder()
87             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
88             .setContext("context951530927")
89             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
90             .build();
91     mockSynonymSetService.addResponse(expectedResponse);
92 
93     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
94     SynonymSet synonymSet = SynonymSet.newBuilder().build();
95 
96     SynonymSet actualResponse = client.createSynonymSet(parent, synonymSet);
97     Assert.assertEquals(expectedResponse, actualResponse);
98 
99     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
100     Assert.assertEquals(1, actualRequests.size());
101     CreateSynonymSetRequest actualRequest = ((CreateSynonymSetRequest) actualRequests.get(0));
102 
103     Assert.assertEquals(parent.toString(), actualRequest.getParent());
104     Assert.assertEquals(synonymSet, actualRequest.getSynonymSet());
105     Assert.assertTrue(
106         channelProvider.isHeaderSent(
107             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
108             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
109   }
110 
111   @Test
createSynonymSetExceptionTest()112   public void createSynonymSetExceptionTest() throws Exception {
113     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
114     mockSynonymSetService.addException(exception);
115 
116     try {
117       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
118       SynonymSet synonymSet = SynonymSet.newBuilder().build();
119       client.createSynonymSet(parent, synonymSet);
120       Assert.fail("No exception raised");
121     } catch (InvalidArgumentException e) {
122       // Expected exception.
123     }
124   }
125 
126   @Test
createSynonymSetTest2()127   public void createSynonymSetTest2() throws Exception {
128     SynonymSet expectedResponse =
129         SynonymSet.newBuilder()
130             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
131             .setContext("context951530927")
132             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
133             .build();
134     mockSynonymSetService.addResponse(expectedResponse);
135 
136     String parent = "parent-995424086";
137     SynonymSet synonymSet = SynonymSet.newBuilder().build();
138 
139     SynonymSet actualResponse = client.createSynonymSet(parent, synonymSet);
140     Assert.assertEquals(expectedResponse, actualResponse);
141 
142     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
143     Assert.assertEquals(1, actualRequests.size());
144     CreateSynonymSetRequest actualRequest = ((CreateSynonymSetRequest) actualRequests.get(0));
145 
146     Assert.assertEquals(parent, actualRequest.getParent());
147     Assert.assertEquals(synonymSet, actualRequest.getSynonymSet());
148     Assert.assertTrue(
149         channelProvider.isHeaderSent(
150             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
151             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
152   }
153 
154   @Test
createSynonymSetExceptionTest2()155   public void createSynonymSetExceptionTest2() throws Exception {
156     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
157     mockSynonymSetService.addException(exception);
158 
159     try {
160       String parent = "parent-995424086";
161       SynonymSet synonymSet = SynonymSet.newBuilder().build();
162       client.createSynonymSet(parent, synonymSet);
163       Assert.fail("No exception raised");
164     } catch (InvalidArgumentException e) {
165       // Expected exception.
166     }
167   }
168 
169   @Test
getSynonymSetTest()170   public void getSynonymSetTest() throws Exception {
171     SynonymSet expectedResponse =
172         SynonymSet.newBuilder()
173             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
174             .setContext("context951530927")
175             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
176             .build();
177     mockSynonymSetService.addResponse(expectedResponse);
178 
179     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
180 
181     SynonymSet actualResponse = client.getSynonymSet(name);
182     Assert.assertEquals(expectedResponse, actualResponse);
183 
184     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
185     Assert.assertEquals(1, actualRequests.size());
186     GetSynonymSetRequest actualRequest = ((GetSynonymSetRequest) actualRequests.get(0));
187 
188     Assert.assertEquals(name.toString(), actualRequest.getName());
189     Assert.assertTrue(
190         channelProvider.isHeaderSent(
191             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
192             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
193   }
194 
195   @Test
getSynonymSetExceptionTest()196   public void getSynonymSetExceptionTest() throws Exception {
197     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
198     mockSynonymSetService.addException(exception);
199 
200     try {
201       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
202       client.getSynonymSet(name);
203       Assert.fail("No exception raised");
204     } catch (InvalidArgumentException e) {
205       // Expected exception.
206     }
207   }
208 
209   @Test
getSynonymSetTest2()210   public void getSynonymSetTest2() throws Exception {
211     SynonymSet expectedResponse =
212         SynonymSet.newBuilder()
213             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
214             .setContext("context951530927")
215             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
216             .build();
217     mockSynonymSetService.addResponse(expectedResponse);
218 
219     String name = "name3373707";
220 
221     SynonymSet actualResponse = client.getSynonymSet(name);
222     Assert.assertEquals(expectedResponse, actualResponse);
223 
224     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
225     Assert.assertEquals(1, actualRequests.size());
226     GetSynonymSetRequest actualRequest = ((GetSynonymSetRequest) actualRequests.get(0));
227 
228     Assert.assertEquals(name, actualRequest.getName());
229     Assert.assertTrue(
230         channelProvider.isHeaderSent(
231             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
232             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
233   }
234 
235   @Test
getSynonymSetExceptionTest2()236   public void getSynonymSetExceptionTest2() throws Exception {
237     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
238     mockSynonymSetService.addException(exception);
239 
240     try {
241       String name = "name3373707";
242       client.getSynonymSet(name);
243       Assert.fail("No exception raised");
244     } catch (InvalidArgumentException e) {
245       // Expected exception.
246     }
247   }
248 
249   @Test
updateSynonymSetTest()250   public void updateSynonymSetTest() throws Exception {
251     SynonymSet expectedResponse =
252         SynonymSet.newBuilder()
253             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
254             .setContext("context951530927")
255             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
256             .build();
257     mockSynonymSetService.addResponse(expectedResponse);
258 
259     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
260     SynonymSet synonymSet = SynonymSet.newBuilder().build();
261 
262     SynonymSet actualResponse = client.updateSynonymSet(name, synonymSet);
263     Assert.assertEquals(expectedResponse, actualResponse);
264 
265     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
266     Assert.assertEquals(1, actualRequests.size());
267     UpdateSynonymSetRequest actualRequest = ((UpdateSynonymSetRequest) actualRequests.get(0));
268 
269     Assert.assertEquals(name.toString(), actualRequest.getName());
270     Assert.assertEquals(synonymSet, actualRequest.getSynonymSet());
271     Assert.assertTrue(
272         channelProvider.isHeaderSent(
273             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
274             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
275   }
276 
277   @Test
updateSynonymSetExceptionTest()278   public void updateSynonymSetExceptionTest() throws Exception {
279     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
280     mockSynonymSetService.addException(exception);
281 
282     try {
283       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
284       SynonymSet synonymSet = SynonymSet.newBuilder().build();
285       client.updateSynonymSet(name, synonymSet);
286       Assert.fail("No exception raised");
287     } catch (InvalidArgumentException e) {
288       // Expected exception.
289     }
290   }
291 
292   @Test
updateSynonymSetTest2()293   public void updateSynonymSetTest2() throws Exception {
294     SynonymSet expectedResponse =
295         SynonymSet.newBuilder()
296             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
297             .setContext("context951530927")
298             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
299             .build();
300     mockSynonymSetService.addResponse(expectedResponse);
301 
302     String name = "name3373707";
303     SynonymSet synonymSet = SynonymSet.newBuilder().build();
304 
305     SynonymSet actualResponse = client.updateSynonymSet(name, synonymSet);
306     Assert.assertEquals(expectedResponse, actualResponse);
307 
308     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
309     Assert.assertEquals(1, actualRequests.size());
310     UpdateSynonymSetRequest actualRequest = ((UpdateSynonymSetRequest) actualRequests.get(0));
311 
312     Assert.assertEquals(name, actualRequest.getName());
313     Assert.assertEquals(synonymSet, actualRequest.getSynonymSet());
314     Assert.assertTrue(
315         channelProvider.isHeaderSent(
316             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
317             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
318   }
319 
320   @Test
updateSynonymSetExceptionTest2()321   public void updateSynonymSetExceptionTest2() throws Exception {
322     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
323     mockSynonymSetService.addException(exception);
324 
325     try {
326       String name = "name3373707";
327       SynonymSet synonymSet = SynonymSet.newBuilder().build();
328       client.updateSynonymSet(name, synonymSet);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
deleteSynonymSetTest()336   public void deleteSynonymSetTest() throws Exception {
337     Empty expectedResponse = Empty.newBuilder().build();
338     mockSynonymSetService.addResponse(expectedResponse);
339 
340     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
341 
342     client.deleteSynonymSet(name);
343 
344     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
345     Assert.assertEquals(1, actualRequests.size());
346     DeleteSynonymSetRequest actualRequest = ((DeleteSynonymSetRequest) actualRequests.get(0));
347 
348     Assert.assertEquals(name.toString(), actualRequest.getName());
349     Assert.assertTrue(
350         channelProvider.isHeaderSent(
351             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
352             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
353   }
354 
355   @Test
deleteSynonymSetExceptionTest()356   public void deleteSynonymSetExceptionTest() throws Exception {
357     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
358     mockSynonymSetService.addException(exception);
359 
360     try {
361       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
362       client.deleteSynonymSet(name);
363       Assert.fail("No exception raised");
364     } catch (InvalidArgumentException e) {
365       // Expected exception.
366     }
367   }
368 
369   @Test
deleteSynonymSetTest2()370   public void deleteSynonymSetTest2() throws Exception {
371     Empty expectedResponse = Empty.newBuilder().build();
372     mockSynonymSetService.addResponse(expectedResponse);
373 
374     String name = "name3373707";
375 
376     client.deleteSynonymSet(name);
377 
378     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
379     Assert.assertEquals(1, actualRequests.size());
380     DeleteSynonymSetRequest actualRequest = ((DeleteSynonymSetRequest) actualRequests.get(0));
381 
382     Assert.assertEquals(name, actualRequest.getName());
383     Assert.assertTrue(
384         channelProvider.isHeaderSent(
385             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
386             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
387   }
388 
389   @Test
deleteSynonymSetExceptionTest2()390   public void deleteSynonymSetExceptionTest2() throws Exception {
391     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
392     mockSynonymSetService.addException(exception);
393 
394     try {
395       String name = "name3373707";
396       client.deleteSynonymSet(name);
397       Assert.fail("No exception raised");
398     } catch (InvalidArgumentException e) {
399       // Expected exception.
400     }
401   }
402 
403   @Test
listSynonymSetsTest()404   public void listSynonymSetsTest() throws Exception {
405     SynonymSet responsesElement = SynonymSet.newBuilder().build();
406     ListSynonymSetsResponse expectedResponse =
407         ListSynonymSetsResponse.newBuilder()
408             .setNextPageToken("")
409             .addAllSynonymSets(Arrays.asList(responsesElement))
410             .build();
411     mockSynonymSetService.addResponse(expectedResponse);
412 
413     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
414 
415     ListSynonymSetsPagedResponse pagedListResponse = client.listSynonymSets(parent);
416 
417     List<SynonymSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
418 
419     Assert.assertEquals(1, resources.size());
420     Assert.assertEquals(expectedResponse.getSynonymSetsList().get(0), resources.get(0));
421 
422     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
423     Assert.assertEquals(1, actualRequests.size());
424     ListSynonymSetsRequest actualRequest = ((ListSynonymSetsRequest) actualRequests.get(0));
425 
426     Assert.assertEquals(parent.toString(), actualRequest.getParent());
427     Assert.assertTrue(
428         channelProvider.isHeaderSent(
429             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
430             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
431   }
432 
433   @Test
listSynonymSetsExceptionTest()434   public void listSynonymSetsExceptionTest() throws Exception {
435     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
436     mockSynonymSetService.addException(exception);
437 
438     try {
439       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
440       client.listSynonymSets(parent);
441       Assert.fail("No exception raised");
442     } catch (InvalidArgumentException e) {
443       // Expected exception.
444     }
445   }
446 
447   @Test
listSynonymSetsTest2()448   public void listSynonymSetsTest2() throws Exception {
449     SynonymSet responsesElement = SynonymSet.newBuilder().build();
450     ListSynonymSetsResponse expectedResponse =
451         ListSynonymSetsResponse.newBuilder()
452             .setNextPageToken("")
453             .addAllSynonymSets(Arrays.asList(responsesElement))
454             .build();
455     mockSynonymSetService.addResponse(expectedResponse);
456 
457     String parent = "parent-995424086";
458 
459     ListSynonymSetsPagedResponse pagedListResponse = client.listSynonymSets(parent);
460 
461     List<SynonymSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
462 
463     Assert.assertEquals(1, resources.size());
464     Assert.assertEquals(expectedResponse.getSynonymSetsList().get(0), resources.get(0));
465 
466     List<AbstractMessage> actualRequests = mockSynonymSetService.getRequests();
467     Assert.assertEquals(1, actualRequests.size());
468     ListSynonymSetsRequest actualRequest = ((ListSynonymSetsRequest) actualRequests.get(0));
469 
470     Assert.assertEquals(parent, actualRequest.getParent());
471     Assert.assertTrue(
472         channelProvider.isHeaderSent(
473             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
474             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
475   }
476 
477   @Test
listSynonymSetsExceptionTest2()478   public void listSynonymSetsExceptionTest2() throws Exception {
479     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
480     mockSynonymSetService.addException(exception);
481 
482     try {
483       String parent = "parent-995424086";
484       client.listSynonymSets(parent);
485       Assert.fail("No exception raised");
486     } catch (InvalidArgumentException e) {
487       // Expected exception.
488     }
489   }
490 }
491