• 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.httpjson.GaxHttpJsonProperties;
23 import com.google.api.gax.httpjson.testing.MockHttpService;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.ApiException;
26 import com.google.api.gax.rpc.ApiExceptionFactory;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.api.gax.rpc.testing.FakeStatusCode;
30 import com.google.cloud.contentwarehouse.v1.stub.HttpJsonSynonymSetServiceStub;
31 import com.google.common.collect.Lists;
32 import com.google.protobuf.Empty;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.List;
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 SynonymSetServiceClientHttpJsonTest {
47   private static MockHttpService mockService;
48   private static SynonymSetServiceClient client;
49 
50   @BeforeClass
startStaticServer()51   public static void startStaticServer() throws IOException {
52     mockService =
53         new MockHttpService(
54             HttpJsonSynonymSetServiceStub.getMethodDescriptors(),
55             SynonymSetServiceSettings.getDefaultEndpoint());
56     SynonymSetServiceSettings settings =
57         SynonymSetServiceSettings.newHttpJsonBuilder()
58             .setTransportChannelProvider(
59                 SynonymSetServiceSettings.defaultHttpJsonTransportProviderBuilder()
60                     .setHttpTransport(mockService)
61                     .build())
62             .setCredentialsProvider(NoCredentialsProvider.create())
63             .build();
64     client = SynonymSetServiceClient.create(settings);
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     client.close();
70   }
71 
72   @Before
setUp()73   public void setUp() {}
74 
75   @After
tearDown()76   public void tearDown() throws Exception {
77     mockService.reset();
78   }
79 
80   @Test
createSynonymSetTest()81   public void createSynonymSetTest() throws Exception {
82     SynonymSet expectedResponse =
83         SynonymSet.newBuilder()
84             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
85             .setContext("context951530927")
86             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
87             .build();
88     mockService.addResponse(expectedResponse);
89 
90     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
91     SynonymSet synonymSet = SynonymSet.newBuilder().build();
92 
93     SynonymSet actualResponse = client.createSynonymSet(parent, synonymSet);
94     Assert.assertEquals(expectedResponse, actualResponse);
95 
96     List<String> actualRequests = mockService.getRequestPaths();
97     Assert.assertEquals(1, actualRequests.size());
98 
99     String apiClientHeaderKey =
100         mockService
101             .getRequestHeaders()
102             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
103             .iterator()
104             .next();
105     Assert.assertTrue(
106         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
107             .matcher(apiClientHeaderKey)
108             .matches());
109   }
110 
111   @Test
createSynonymSetExceptionTest()112   public void createSynonymSetExceptionTest() throws Exception {
113     ApiException exception =
114         ApiExceptionFactory.createException(
115             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
116     mockService.addException(exception);
117 
118     try {
119       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
120       SynonymSet synonymSet = SynonymSet.newBuilder().build();
121       client.createSynonymSet(parent, synonymSet);
122       Assert.fail("No exception raised");
123     } catch (InvalidArgumentException e) {
124       // Expected exception.
125     }
126   }
127 
128   @Test
createSynonymSetTest2()129   public void createSynonymSetTest2() throws Exception {
130     SynonymSet expectedResponse =
131         SynonymSet.newBuilder()
132             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
133             .setContext("context951530927")
134             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
135             .build();
136     mockService.addResponse(expectedResponse);
137 
138     String parent = "projects/project-5833/locations/location-5833";
139     SynonymSet synonymSet = SynonymSet.newBuilder().build();
140 
141     SynonymSet actualResponse = client.createSynonymSet(parent, synonymSet);
142     Assert.assertEquals(expectedResponse, actualResponse);
143 
144     List<String> actualRequests = mockService.getRequestPaths();
145     Assert.assertEquals(1, actualRequests.size());
146 
147     String apiClientHeaderKey =
148         mockService
149             .getRequestHeaders()
150             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
151             .iterator()
152             .next();
153     Assert.assertTrue(
154         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
155             .matcher(apiClientHeaderKey)
156             .matches());
157   }
158 
159   @Test
createSynonymSetExceptionTest2()160   public void createSynonymSetExceptionTest2() throws Exception {
161     ApiException exception =
162         ApiExceptionFactory.createException(
163             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
164     mockService.addException(exception);
165 
166     try {
167       String parent = "projects/project-5833/locations/location-5833";
168       SynonymSet synonymSet = SynonymSet.newBuilder().build();
169       client.createSynonymSet(parent, synonymSet);
170       Assert.fail("No exception raised");
171     } catch (InvalidArgumentException e) {
172       // Expected exception.
173     }
174   }
175 
176   @Test
getSynonymSetTest()177   public void getSynonymSetTest() throws Exception {
178     SynonymSet expectedResponse =
179         SynonymSet.newBuilder()
180             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
181             .setContext("context951530927")
182             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
183             .build();
184     mockService.addResponse(expectedResponse);
185 
186     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
187 
188     SynonymSet actualResponse = client.getSynonymSet(name);
189     Assert.assertEquals(expectedResponse, actualResponse);
190 
191     List<String> actualRequests = mockService.getRequestPaths();
192     Assert.assertEquals(1, actualRequests.size());
193 
194     String apiClientHeaderKey =
195         mockService
196             .getRequestHeaders()
197             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
198             .iterator()
199             .next();
200     Assert.assertTrue(
201         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
202             .matcher(apiClientHeaderKey)
203             .matches());
204   }
205 
206   @Test
getSynonymSetExceptionTest()207   public void getSynonymSetExceptionTest() throws Exception {
208     ApiException exception =
209         ApiExceptionFactory.createException(
210             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
211     mockService.addException(exception);
212 
213     try {
214       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
215       client.getSynonymSet(name);
216       Assert.fail("No exception raised");
217     } catch (InvalidArgumentException e) {
218       // Expected exception.
219     }
220   }
221 
222   @Test
getSynonymSetTest2()223   public void getSynonymSetTest2() throws Exception {
224     SynonymSet expectedResponse =
225         SynonymSet.newBuilder()
226             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
227             .setContext("context951530927")
228             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
229             .build();
230     mockService.addResponse(expectedResponse);
231 
232     String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
233 
234     SynonymSet actualResponse = client.getSynonymSet(name);
235     Assert.assertEquals(expectedResponse, actualResponse);
236 
237     List<String> actualRequests = mockService.getRequestPaths();
238     Assert.assertEquals(1, actualRequests.size());
239 
240     String apiClientHeaderKey =
241         mockService
242             .getRequestHeaders()
243             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
244             .iterator()
245             .next();
246     Assert.assertTrue(
247         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
248             .matcher(apiClientHeaderKey)
249             .matches());
250   }
251 
252   @Test
getSynonymSetExceptionTest2()253   public void getSynonymSetExceptionTest2() throws Exception {
254     ApiException exception =
255         ApiExceptionFactory.createException(
256             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
257     mockService.addException(exception);
258 
259     try {
260       String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
261       client.getSynonymSet(name);
262       Assert.fail("No exception raised");
263     } catch (InvalidArgumentException e) {
264       // Expected exception.
265     }
266   }
267 
268   @Test
updateSynonymSetTest()269   public void updateSynonymSetTest() throws Exception {
270     SynonymSet expectedResponse =
271         SynonymSet.newBuilder()
272             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
273             .setContext("context951530927")
274             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
275             .build();
276     mockService.addResponse(expectedResponse);
277 
278     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
279     SynonymSet synonymSet = SynonymSet.newBuilder().build();
280 
281     SynonymSet actualResponse = client.updateSynonymSet(name, synonymSet);
282     Assert.assertEquals(expectedResponse, actualResponse);
283 
284     List<String> actualRequests = mockService.getRequestPaths();
285     Assert.assertEquals(1, actualRequests.size());
286 
287     String apiClientHeaderKey =
288         mockService
289             .getRequestHeaders()
290             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
291             .iterator()
292             .next();
293     Assert.assertTrue(
294         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
295             .matcher(apiClientHeaderKey)
296             .matches());
297   }
298 
299   @Test
updateSynonymSetExceptionTest()300   public void updateSynonymSetExceptionTest() throws Exception {
301     ApiException exception =
302         ApiExceptionFactory.createException(
303             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
304     mockService.addException(exception);
305 
306     try {
307       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
308       SynonymSet synonymSet = SynonymSet.newBuilder().build();
309       client.updateSynonymSet(name, synonymSet);
310       Assert.fail("No exception raised");
311     } catch (InvalidArgumentException e) {
312       // Expected exception.
313     }
314   }
315 
316   @Test
updateSynonymSetTest2()317   public void updateSynonymSetTest2() throws Exception {
318     SynonymSet expectedResponse =
319         SynonymSet.newBuilder()
320             .setName(SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]").toString())
321             .setContext("context951530927")
322             .addAllSynonyms(new ArrayList<SynonymSet.Synonym>())
323             .build();
324     mockService.addResponse(expectedResponse);
325 
326     String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
327     SynonymSet synonymSet = SynonymSet.newBuilder().build();
328 
329     SynonymSet actualResponse = client.updateSynonymSet(name, synonymSet);
330     Assert.assertEquals(expectedResponse, actualResponse);
331 
332     List<String> actualRequests = mockService.getRequestPaths();
333     Assert.assertEquals(1, actualRequests.size());
334 
335     String apiClientHeaderKey =
336         mockService
337             .getRequestHeaders()
338             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
339             .iterator()
340             .next();
341     Assert.assertTrue(
342         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
343             .matcher(apiClientHeaderKey)
344             .matches());
345   }
346 
347   @Test
updateSynonymSetExceptionTest2()348   public void updateSynonymSetExceptionTest2() throws Exception {
349     ApiException exception =
350         ApiExceptionFactory.createException(
351             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
352     mockService.addException(exception);
353 
354     try {
355       String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
356       SynonymSet synonymSet = SynonymSet.newBuilder().build();
357       client.updateSynonymSet(name, synonymSet);
358       Assert.fail("No exception raised");
359     } catch (InvalidArgumentException e) {
360       // Expected exception.
361     }
362   }
363 
364   @Test
deleteSynonymSetTest()365   public void deleteSynonymSetTest() throws Exception {
366     Empty expectedResponse = Empty.newBuilder().build();
367     mockService.addResponse(expectedResponse);
368 
369     SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
370 
371     client.deleteSynonymSet(name);
372 
373     List<String> actualRequests = mockService.getRequestPaths();
374     Assert.assertEquals(1, actualRequests.size());
375 
376     String apiClientHeaderKey =
377         mockService
378             .getRequestHeaders()
379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
380             .iterator()
381             .next();
382     Assert.assertTrue(
383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
384             .matcher(apiClientHeaderKey)
385             .matches());
386   }
387 
388   @Test
deleteSynonymSetExceptionTest()389   public void deleteSynonymSetExceptionTest() throws Exception {
390     ApiException exception =
391         ApiExceptionFactory.createException(
392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
393     mockService.addException(exception);
394 
395     try {
396       SynonymSetName name = SynonymSetName.of("[PROJECT]", "[LOCATION]", "[CONTEXT]");
397       client.deleteSynonymSet(name);
398       Assert.fail("No exception raised");
399     } catch (InvalidArgumentException e) {
400       // Expected exception.
401     }
402   }
403 
404   @Test
deleteSynonymSetTest2()405   public void deleteSynonymSetTest2() throws Exception {
406     Empty expectedResponse = Empty.newBuilder().build();
407     mockService.addResponse(expectedResponse);
408 
409     String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
410 
411     client.deleteSynonymSet(name);
412 
413     List<String> actualRequests = mockService.getRequestPaths();
414     Assert.assertEquals(1, actualRequests.size());
415 
416     String apiClientHeaderKey =
417         mockService
418             .getRequestHeaders()
419             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
420             .iterator()
421             .next();
422     Assert.assertTrue(
423         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
424             .matcher(apiClientHeaderKey)
425             .matches());
426   }
427 
428   @Test
deleteSynonymSetExceptionTest2()429   public void deleteSynonymSetExceptionTest2() throws Exception {
430     ApiException exception =
431         ApiExceptionFactory.createException(
432             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
433     mockService.addException(exception);
434 
435     try {
436       String name = "projects/project-5186/locations/location-5186/synonymSets/synonymSet-5186";
437       client.deleteSynonymSet(name);
438       Assert.fail("No exception raised");
439     } catch (InvalidArgumentException e) {
440       // Expected exception.
441     }
442   }
443 
444   @Test
listSynonymSetsTest()445   public void listSynonymSetsTest() throws Exception {
446     SynonymSet responsesElement = SynonymSet.newBuilder().build();
447     ListSynonymSetsResponse expectedResponse =
448         ListSynonymSetsResponse.newBuilder()
449             .setNextPageToken("")
450             .addAllSynonymSets(Arrays.asList(responsesElement))
451             .build();
452     mockService.addResponse(expectedResponse);
453 
454     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
455 
456     ListSynonymSetsPagedResponse pagedListResponse = client.listSynonymSets(parent);
457 
458     List<SynonymSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
459 
460     Assert.assertEquals(1, resources.size());
461     Assert.assertEquals(expectedResponse.getSynonymSetsList().get(0), resources.get(0));
462 
463     List<String> actualRequests = mockService.getRequestPaths();
464     Assert.assertEquals(1, actualRequests.size());
465 
466     String apiClientHeaderKey =
467         mockService
468             .getRequestHeaders()
469             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
470             .iterator()
471             .next();
472     Assert.assertTrue(
473         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
474             .matcher(apiClientHeaderKey)
475             .matches());
476   }
477 
478   @Test
listSynonymSetsExceptionTest()479   public void listSynonymSetsExceptionTest() throws Exception {
480     ApiException exception =
481         ApiExceptionFactory.createException(
482             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
483     mockService.addException(exception);
484 
485     try {
486       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
487       client.listSynonymSets(parent);
488       Assert.fail("No exception raised");
489     } catch (InvalidArgumentException e) {
490       // Expected exception.
491     }
492   }
493 
494   @Test
listSynonymSetsTest2()495   public void listSynonymSetsTest2() throws Exception {
496     SynonymSet responsesElement = SynonymSet.newBuilder().build();
497     ListSynonymSetsResponse expectedResponse =
498         ListSynonymSetsResponse.newBuilder()
499             .setNextPageToken("")
500             .addAllSynonymSets(Arrays.asList(responsesElement))
501             .build();
502     mockService.addResponse(expectedResponse);
503 
504     String parent = "projects/project-5833/locations/location-5833";
505 
506     ListSynonymSetsPagedResponse pagedListResponse = client.listSynonymSets(parent);
507 
508     List<SynonymSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
509 
510     Assert.assertEquals(1, resources.size());
511     Assert.assertEquals(expectedResponse.getSynonymSetsList().get(0), resources.get(0));
512 
513     List<String> actualRequests = mockService.getRequestPaths();
514     Assert.assertEquals(1, actualRequests.size());
515 
516     String apiClientHeaderKey =
517         mockService
518             .getRequestHeaders()
519             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
520             .iterator()
521             .next();
522     Assert.assertTrue(
523         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
524             .matcher(apiClientHeaderKey)
525             .matches());
526   }
527 
528   @Test
listSynonymSetsExceptionTest2()529   public void listSynonymSetsExceptionTest2() throws Exception {
530     ApiException exception =
531         ApiExceptionFactory.createException(
532             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
533     mockService.addException(exception);
534 
535     try {
536       String parent = "projects/project-5833/locations/location-5833";
537       client.listSynonymSets(parent);
538       Assert.fail("No exception raised");
539     } catch (InvalidArgumentException e) {
540       // Expected exception.
541     }
542   }
543 }
544