• 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.RuleSetServiceClient.ListRuleSetsPagedResponse;
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 RuleSetServiceClientTest {
47   private static MockRuleSetService mockRuleSetService;
48   private static MockServiceHelper mockServiceHelper;
49   private LocalChannelProvider channelProvider;
50   private RuleSetServiceClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() {
54     mockRuleSetService = new MockRuleSetService();
55     mockServiceHelper =
56         new MockServiceHelper(
57             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockRuleSetService));
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     RuleSetServiceSettings settings =
71         RuleSetServiceSettings.newBuilder()
72             .setTransportChannelProvider(channelProvider)
73             .setCredentialsProvider(NoCredentialsProvider.create())
74             .build();
75     client = RuleSetServiceClient.create(settings);
76   }
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     client.close();
81   }
82 
83   @Test
createRuleSetTest()84   public void createRuleSetTest() throws Exception {
85     RuleSet expectedResponse =
86         RuleSet.newBuilder()
87             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
88             .setDescription("description-1724546052")
89             .setSource("source-896505829")
90             .addAllRules(new ArrayList<Rule>())
91             .build();
92     mockRuleSetService.addResponse(expectedResponse);
93 
94     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
95     RuleSet ruleSet = RuleSet.newBuilder().build();
96 
97     RuleSet actualResponse = client.createRuleSet(parent, ruleSet);
98     Assert.assertEquals(expectedResponse, actualResponse);
99 
100     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
101     Assert.assertEquals(1, actualRequests.size());
102     CreateRuleSetRequest actualRequest = ((CreateRuleSetRequest) actualRequests.get(0));
103 
104     Assert.assertEquals(parent.toString(), actualRequest.getParent());
105     Assert.assertEquals(ruleSet, actualRequest.getRuleSet());
106     Assert.assertTrue(
107         channelProvider.isHeaderSent(
108             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
109             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
110   }
111 
112   @Test
createRuleSetExceptionTest()113   public void createRuleSetExceptionTest() throws Exception {
114     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
115     mockRuleSetService.addException(exception);
116 
117     try {
118       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
119       RuleSet ruleSet = RuleSet.newBuilder().build();
120       client.createRuleSet(parent, ruleSet);
121       Assert.fail("No exception raised");
122     } catch (InvalidArgumentException e) {
123       // Expected exception.
124     }
125   }
126 
127   @Test
createRuleSetTest2()128   public void createRuleSetTest2() throws Exception {
129     RuleSet expectedResponse =
130         RuleSet.newBuilder()
131             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
132             .setDescription("description-1724546052")
133             .setSource("source-896505829")
134             .addAllRules(new ArrayList<Rule>())
135             .build();
136     mockRuleSetService.addResponse(expectedResponse);
137 
138     String parent = "parent-995424086";
139     RuleSet ruleSet = RuleSet.newBuilder().build();
140 
141     RuleSet actualResponse = client.createRuleSet(parent, ruleSet);
142     Assert.assertEquals(expectedResponse, actualResponse);
143 
144     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
145     Assert.assertEquals(1, actualRequests.size());
146     CreateRuleSetRequest actualRequest = ((CreateRuleSetRequest) actualRequests.get(0));
147 
148     Assert.assertEquals(parent, actualRequest.getParent());
149     Assert.assertEquals(ruleSet, actualRequest.getRuleSet());
150     Assert.assertTrue(
151         channelProvider.isHeaderSent(
152             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
153             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
154   }
155 
156   @Test
createRuleSetExceptionTest2()157   public void createRuleSetExceptionTest2() throws Exception {
158     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
159     mockRuleSetService.addException(exception);
160 
161     try {
162       String parent = "parent-995424086";
163       RuleSet ruleSet = RuleSet.newBuilder().build();
164       client.createRuleSet(parent, ruleSet);
165       Assert.fail("No exception raised");
166     } catch (InvalidArgumentException e) {
167       // Expected exception.
168     }
169   }
170 
171   @Test
getRuleSetTest()172   public void getRuleSetTest() throws Exception {
173     RuleSet expectedResponse =
174         RuleSet.newBuilder()
175             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
176             .setDescription("description-1724546052")
177             .setSource("source-896505829")
178             .addAllRules(new ArrayList<Rule>())
179             .build();
180     mockRuleSetService.addResponse(expectedResponse);
181 
182     RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
183 
184     RuleSet actualResponse = client.getRuleSet(name);
185     Assert.assertEquals(expectedResponse, actualResponse);
186 
187     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
188     Assert.assertEquals(1, actualRequests.size());
189     GetRuleSetRequest actualRequest = ((GetRuleSetRequest) actualRequests.get(0));
190 
191     Assert.assertEquals(name.toString(), actualRequest.getName());
192     Assert.assertTrue(
193         channelProvider.isHeaderSent(
194             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
195             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
196   }
197 
198   @Test
getRuleSetExceptionTest()199   public void getRuleSetExceptionTest() throws Exception {
200     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
201     mockRuleSetService.addException(exception);
202 
203     try {
204       RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
205       client.getRuleSet(name);
206       Assert.fail("No exception raised");
207     } catch (InvalidArgumentException e) {
208       // Expected exception.
209     }
210   }
211 
212   @Test
getRuleSetTest2()213   public void getRuleSetTest2() throws Exception {
214     RuleSet expectedResponse =
215         RuleSet.newBuilder()
216             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
217             .setDescription("description-1724546052")
218             .setSource("source-896505829")
219             .addAllRules(new ArrayList<Rule>())
220             .build();
221     mockRuleSetService.addResponse(expectedResponse);
222 
223     String name = "name3373707";
224 
225     RuleSet actualResponse = client.getRuleSet(name);
226     Assert.assertEquals(expectedResponse, actualResponse);
227 
228     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
229     Assert.assertEquals(1, actualRequests.size());
230     GetRuleSetRequest actualRequest = ((GetRuleSetRequest) actualRequests.get(0));
231 
232     Assert.assertEquals(name, actualRequest.getName());
233     Assert.assertTrue(
234         channelProvider.isHeaderSent(
235             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
236             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
237   }
238 
239   @Test
getRuleSetExceptionTest2()240   public void getRuleSetExceptionTest2() throws Exception {
241     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
242     mockRuleSetService.addException(exception);
243 
244     try {
245       String name = "name3373707";
246       client.getRuleSet(name);
247       Assert.fail("No exception raised");
248     } catch (InvalidArgumentException e) {
249       // Expected exception.
250     }
251   }
252 
253   @Test
updateRuleSetTest()254   public void updateRuleSetTest() throws Exception {
255     RuleSet expectedResponse =
256         RuleSet.newBuilder()
257             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
258             .setDescription("description-1724546052")
259             .setSource("source-896505829")
260             .addAllRules(new ArrayList<Rule>())
261             .build();
262     mockRuleSetService.addResponse(expectedResponse);
263 
264     RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
265     RuleSet ruleSet = RuleSet.newBuilder().build();
266 
267     RuleSet actualResponse = client.updateRuleSet(name, ruleSet);
268     Assert.assertEquals(expectedResponse, actualResponse);
269 
270     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
271     Assert.assertEquals(1, actualRequests.size());
272     UpdateRuleSetRequest actualRequest = ((UpdateRuleSetRequest) actualRequests.get(0));
273 
274     Assert.assertEquals(name.toString(), actualRequest.getName());
275     Assert.assertEquals(ruleSet, actualRequest.getRuleSet());
276     Assert.assertTrue(
277         channelProvider.isHeaderSent(
278             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
279             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
280   }
281 
282   @Test
updateRuleSetExceptionTest()283   public void updateRuleSetExceptionTest() throws Exception {
284     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
285     mockRuleSetService.addException(exception);
286 
287     try {
288       RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
289       RuleSet ruleSet = RuleSet.newBuilder().build();
290       client.updateRuleSet(name, ruleSet);
291       Assert.fail("No exception raised");
292     } catch (InvalidArgumentException e) {
293       // Expected exception.
294     }
295   }
296 
297   @Test
updateRuleSetTest2()298   public void updateRuleSetTest2() throws Exception {
299     RuleSet expectedResponse =
300         RuleSet.newBuilder()
301             .setName(RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]").toString())
302             .setDescription("description-1724546052")
303             .setSource("source-896505829")
304             .addAllRules(new ArrayList<Rule>())
305             .build();
306     mockRuleSetService.addResponse(expectedResponse);
307 
308     String name = "name3373707";
309     RuleSet ruleSet = RuleSet.newBuilder().build();
310 
311     RuleSet actualResponse = client.updateRuleSet(name, ruleSet);
312     Assert.assertEquals(expectedResponse, actualResponse);
313 
314     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
315     Assert.assertEquals(1, actualRequests.size());
316     UpdateRuleSetRequest actualRequest = ((UpdateRuleSetRequest) actualRequests.get(0));
317 
318     Assert.assertEquals(name, actualRequest.getName());
319     Assert.assertEquals(ruleSet, actualRequest.getRuleSet());
320     Assert.assertTrue(
321         channelProvider.isHeaderSent(
322             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
323             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
324   }
325 
326   @Test
updateRuleSetExceptionTest2()327   public void updateRuleSetExceptionTest2() throws Exception {
328     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
329     mockRuleSetService.addException(exception);
330 
331     try {
332       String name = "name3373707";
333       RuleSet ruleSet = RuleSet.newBuilder().build();
334       client.updateRuleSet(name, ruleSet);
335       Assert.fail("No exception raised");
336     } catch (InvalidArgumentException e) {
337       // Expected exception.
338     }
339   }
340 
341   @Test
deleteRuleSetTest()342   public void deleteRuleSetTest() throws Exception {
343     Empty expectedResponse = Empty.newBuilder().build();
344     mockRuleSetService.addResponse(expectedResponse);
345 
346     RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
347 
348     client.deleteRuleSet(name);
349 
350     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
351     Assert.assertEquals(1, actualRequests.size());
352     DeleteRuleSetRequest actualRequest = ((DeleteRuleSetRequest) actualRequests.get(0));
353 
354     Assert.assertEquals(name.toString(), actualRequest.getName());
355     Assert.assertTrue(
356         channelProvider.isHeaderSent(
357             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
358             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
359   }
360 
361   @Test
deleteRuleSetExceptionTest()362   public void deleteRuleSetExceptionTest() throws Exception {
363     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
364     mockRuleSetService.addException(exception);
365 
366     try {
367       RuleSetName name = RuleSetName.of("[PROJECT]", "[LOCATION]", "[RULE_SET]");
368       client.deleteRuleSet(name);
369       Assert.fail("No exception raised");
370     } catch (InvalidArgumentException e) {
371       // Expected exception.
372     }
373   }
374 
375   @Test
deleteRuleSetTest2()376   public void deleteRuleSetTest2() throws Exception {
377     Empty expectedResponse = Empty.newBuilder().build();
378     mockRuleSetService.addResponse(expectedResponse);
379 
380     String name = "name3373707";
381 
382     client.deleteRuleSet(name);
383 
384     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
385     Assert.assertEquals(1, actualRequests.size());
386     DeleteRuleSetRequest actualRequest = ((DeleteRuleSetRequest) actualRequests.get(0));
387 
388     Assert.assertEquals(name, actualRequest.getName());
389     Assert.assertTrue(
390         channelProvider.isHeaderSent(
391             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
392             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
393   }
394 
395   @Test
deleteRuleSetExceptionTest2()396   public void deleteRuleSetExceptionTest2() throws Exception {
397     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
398     mockRuleSetService.addException(exception);
399 
400     try {
401       String name = "name3373707";
402       client.deleteRuleSet(name);
403       Assert.fail("No exception raised");
404     } catch (InvalidArgumentException e) {
405       // Expected exception.
406     }
407   }
408 
409   @Test
listRuleSetsTest()410   public void listRuleSetsTest() throws Exception {
411     RuleSet responsesElement = RuleSet.newBuilder().build();
412     ListRuleSetsResponse expectedResponse =
413         ListRuleSetsResponse.newBuilder()
414             .setNextPageToken("")
415             .addAllRuleSets(Arrays.asList(responsesElement))
416             .build();
417     mockRuleSetService.addResponse(expectedResponse);
418 
419     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
420 
421     ListRuleSetsPagedResponse pagedListResponse = client.listRuleSets(parent);
422 
423     List<RuleSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
424 
425     Assert.assertEquals(1, resources.size());
426     Assert.assertEquals(expectedResponse.getRuleSetsList().get(0), resources.get(0));
427 
428     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
429     Assert.assertEquals(1, actualRequests.size());
430     ListRuleSetsRequest actualRequest = ((ListRuleSetsRequest) actualRequests.get(0));
431 
432     Assert.assertEquals(parent.toString(), actualRequest.getParent());
433     Assert.assertTrue(
434         channelProvider.isHeaderSent(
435             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
436             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
437   }
438 
439   @Test
listRuleSetsExceptionTest()440   public void listRuleSetsExceptionTest() throws Exception {
441     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
442     mockRuleSetService.addException(exception);
443 
444     try {
445       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
446       client.listRuleSets(parent);
447       Assert.fail("No exception raised");
448     } catch (InvalidArgumentException e) {
449       // Expected exception.
450     }
451   }
452 
453   @Test
listRuleSetsTest2()454   public void listRuleSetsTest2() throws Exception {
455     RuleSet responsesElement = RuleSet.newBuilder().build();
456     ListRuleSetsResponse expectedResponse =
457         ListRuleSetsResponse.newBuilder()
458             .setNextPageToken("")
459             .addAllRuleSets(Arrays.asList(responsesElement))
460             .build();
461     mockRuleSetService.addResponse(expectedResponse);
462 
463     String parent = "parent-995424086";
464 
465     ListRuleSetsPagedResponse pagedListResponse = client.listRuleSets(parent);
466 
467     List<RuleSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
468 
469     Assert.assertEquals(1, resources.size());
470     Assert.assertEquals(expectedResponse.getRuleSetsList().get(0), resources.get(0));
471 
472     List<AbstractMessage> actualRequests = mockRuleSetService.getRequests();
473     Assert.assertEquals(1, actualRequests.size());
474     ListRuleSetsRequest actualRequest = ((ListRuleSetsRequest) actualRequests.get(0));
475 
476     Assert.assertEquals(parent, actualRequest.getParent());
477     Assert.assertTrue(
478         channelProvider.isHeaderSent(
479             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
480             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
481   }
482 
483   @Test
listRuleSetsExceptionTest2()484   public void listRuleSetsExceptionTest2() throws Exception {
485     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
486     mockRuleSetService.addException(exception);
487 
488     try {
489       String parent = "parent-995424086";
490       client.listRuleSets(parent);
491       Assert.fail("No exception raised");
492     } catch (InvalidArgumentException e) {
493       // Expected exception.
494     }
495   }
496 }
497