• 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.appengine.v1;
18 
19 import static com.google.appengine.v1.FirewallClient.ListIngressRulesPagedResponse;
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.appengine.v1.firewall.FirewallRule;
29 import com.google.common.collect.Lists;
30 import com.google.protobuf.AbstractMessage;
31 import com.google.protobuf.Empty;
32 import com.google.protobuf.FieldMask;
33 import io.grpc.StatusRuntimeException;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.List;
38 import java.util.UUID;
39 import javax.annotation.Generated;
40 import org.junit.After;
41 import org.junit.AfterClass;
42 import org.junit.Assert;
43 import org.junit.Before;
44 import org.junit.BeforeClass;
45 import org.junit.Test;
46 
47 @Generated("by gapic-generator-java")
48 public class FirewallClientTest {
49   private static MockFirewall mockFirewall;
50   private static MockServiceHelper mockServiceHelper;
51   private LocalChannelProvider channelProvider;
52   private FirewallClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() {
56     mockFirewall = new MockFirewall();
57     mockServiceHelper =
58         new MockServiceHelper(
59             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockFirewall));
60     mockServiceHelper.start();
61   }
62 
63   @AfterClass
stopServer()64   public static void stopServer() {
65     mockServiceHelper.stop();
66   }
67 
68   @Before
setUp()69   public void setUp() throws IOException {
70     mockServiceHelper.reset();
71     channelProvider = mockServiceHelper.createChannelProvider();
72     FirewallSettings settings =
73         FirewallSettings.newBuilder()
74             .setTransportChannelProvider(channelProvider)
75             .setCredentialsProvider(NoCredentialsProvider.create())
76             .build();
77     client = FirewallClient.create(settings);
78   }
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     client.close();
83   }
84 
85   @Test
listIngressRulesTest()86   public void listIngressRulesTest() throws Exception {
87     FirewallRule responsesElement = FirewallRule.newBuilder().build();
88     ListIngressRulesResponse expectedResponse =
89         ListIngressRulesResponse.newBuilder()
90             .setNextPageToken("")
91             .addAllIngressRules(Arrays.asList(responsesElement))
92             .build();
93     mockFirewall.addResponse(expectedResponse);
94 
95     ListIngressRulesRequest request =
96         ListIngressRulesRequest.newBuilder()
97             .setParent("parent-995424086")
98             .setPageSize(883849137)
99             .setPageToken("pageToken873572522")
100             .setMatchingAddress("matchingAddress861962551")
101             .build();
102 
103     ListIngressRulesPagedResponse pagedListResponse = client.listIngressRules(request);
104 
105     List<FirewallRule> resources = Lists.newArrayList(pagedListResponse.iterateAll());
106 
107     Assert.assertEquals(1, resources.size());
108     Assert.assertEquals(expectedResponse.getIngressRulesList().get(0), resources.get(0));
109 
110     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
111     Assert.assertEquals(1, actualRequests.size());
112     ListIngressRulesRequest actualRequest = ((ListIngressRulesRequest) actualRequests.get(0));
113 
114     Assert.assertEquals(request.getParent(), actualRequest.getParent());
115     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
116     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
117     Assert.assertEquals(request.getMatchingAddress(), actualRequest.getMatchingAddress());
118     Assert.assertTrue(
119         channelProvider.isHeaderSent(
120             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
121             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
122   }
123 
124   @Test
listIngressRulesExceptionTest()125   public void listIngressRulesExceptionTest() throws Exception {
126     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
127     mockFirewall.addException(exception);
128 
129     try {
130       ListIngressRulesRequest request =
131           ListIngressRulesRequest.newBuilder()
132               .setParent("parent-995424086")
133               .setPageSize(883849137)
134               .setPageToken("pageToken873572522")
135               .setMatchingAddress("matchingAddress861962551")
136               .build();
137       client.listIngressRules(request);
138       Assert.fail("No exception raised");
139     } catch (InvalidArgumentException e) {
140       // Expected exception.
141     }
142   }
143 
144   @Test
batchUpdateIngressRulesTest()145   public void batchUpdateIngressRulesTest() throws Exception {
146     BatchUpdateIngressRulesResponse expectedResponse =
147         BatchUpdateIngressRulesResponse.newBuilder()
148             .addAllIngressRules(new ArrayList<FirewallRule>())
149             .build();
150     mockFirewall.addResponse(expectedResponse);
151 
152     BatchUpdateIngressRulesRequest request =
153         BatchUpdateIngressRulesRequest.newBuilder()
154             .setName("name3373707")
155             .addAllIngressRules(new ArrayList<FirewallRule>())
156             .build();
157 
158     BatchUpdateIngressRulesResponse actualResponse = client.batchUpdateIngressRules(request);
159     Assert.assertEquals(expectedResponse, actualResponse);
160 
161     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
162     Assert.assertEquals(1, actualRequests.size());
163     BatchUpdateIngressRulesRequest actualRequest =
164         ((BatchUpdateIngressRulesRequest) actualRequests.get(0));
165 
166     Assert.assertEquals(request.getName(), actualRequest.getName());
167     Assert.assertEquals(request.getIngressRulesList(), actualRequest.getIngressRulesList());
168     Assert.assertTrue(
169         channelProvider.isHeaderSent(
170             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
171             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
172   }
173 
174   @Test
batchUpdateIngressRulesExceptionTest()175   public void batchUpdateIngressRulesExceptionTest() throws Exception {
176     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
177     mockFirewall.addException(exception);
178 
179     try {
180       BatchUpdateIngressRulesRequest request =
181           BatchUpdateIngressRulesRequest.newBuilder()
182               .setName("name3373707")
183               .addAllIngressRules(new ArrayList<FirewallRule>())
184               .build();
185       client.batchUpdateIngressRules(request);
186       Assert.fail("No exception raised");
187     } catch (InvalidArgumentException e) {
188       // Expected exception.
189     }
190   }
191 
192   @Test
createIngressRuleTest()193   public void createIngressRuleTest() throws Exception {
194     FirewallRule expectedResponse =
195         FirewallRule.newBuilder()
196             .setPriority(-1165461084)
197             .setSourceRange("sourceRange-97207838")
198             .setDescription("description-1724546052")
199             .build();
200     mockFirewall.addResponse(expectedResponse);
201 
202     CreateIngressRuleRequest request =
203         CreateIngressRuleRequest.newBuilder()
204             .setParent("parent-995424086")
205             .setRule(FirewallRule.newBuilder().build())
206             .build();
207 
208     FirewallRule actualResponse = client.createIngressRule(request);
209     Assert.assertEquals(expectedResponse, actualResponse);
210 
211     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
212     Assert.assertEquals(1, actualRequests.size());
213     CreateIngressRuleRequest actualRequest = ((CreateIngressRuleRequest) actualRequests.get(0));
214 
215     Assert.assertEquals(request.getParent(), actualRequest.getParent());
216     Assert.assertEquals(request.getRule(), actualRequest.getRule());
217     Assert.assertTrue(
218         channelProvider.isHeaderSent(
219             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
220             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
221   }
222 
223   @Test
createIngressRuleExceptionTest()224   public void createIngressRuleExceptionTest() throws Exception {
225     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
226     mockFirewall.addException(exception);
227 
228     try {
229       CreateIngressRuleRequest request =
230           CreateIngressRuleRequest.newBuilder()
231               .setParent("parent-995424086")
232               .setRule(FirewallRule.newBuilder().build())
233               .build();
234       client.createIngressRule(request);
235       Assert.fail("No exception raised");
236     } catch (InvalidArgumentException e) {
237       // Expected exception.
238     }
239   }
240 
241   @Test
getIngressRuleTest()242   public void getIngressRuleTest() throws Exception {
243     FirewallRule expectedResponse =
244         FirewallRule.newBuilder()
245             .setPriority(-1165461084)
246             .setSourceRange("sourceRange-97207838")
247             .setDescription("description-1724546052")
248             .build();
249     mockFirewall.addResponse(expectedResponse);
250 
251     GetIngressRuleRequest request =
252         GetIngressRuleRequest.newBuilder().setName("name3373707").build();
253 
254     FirewallRule actualResponse = client.getIngressRule(request);
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
258     Assert.assertEquals(1, actualRequests.size());
259     GetIngressRuleRequest actualRequest = ((GetIngressRuleRequest) actualRequests.get(0));
260 
261     Assert.assertEquals(request.getName(), actualRequest.getName());
262     Assert.assertTrue(
263         channelProvider.isHeaderSent(
264             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
265             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
266   }
267 
268   @Test
getIngressRuleExceptionTest()269   public void getIngressRuleExceptionTest() throws Exception {
270     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
271     mockFirewall.addException(exception);
272 
273     try {
274       GetIngressRuleRequest request =
275           GetIngressRuleRequest.newBuilder().setName("name3373707").build();
276       client.getIngressRule(request);
277       Assert.fail("No exception raised");
278     } catch (InvalidArgumentException e) {
279       // Expected exception.
280     }
281   }
282 
283   @Test
updateIngressRuleTest()284   public void updateIngressRuleTest() throws Exception {
285     FirewallRule expectedResponse =
286         FirewallRule.newBuilder()
287             .setPriority(-1165461084)
288             .setSourceRange("sourceRange-97207838")
289             .setDescription("description-1724546052")
290             .build();
291     mockFirewall.addResponse(expectedResponse);
292 
293     UpdateIngressRuleRequest request =
294         UpdateIngressRuleRequest.newBuilder()
295             .setName("name3373707")
296             .setRule(FirewallRule.newBuilder().build())
297             .setUpdateMask(FieldMask.newBuilder().build())
298             .build();
299 
300     FirewallRule actualResponse = client.updateIngressRule(request);
301     Assert.assertEquals(expectedResponse, actualResponse);
302 
303     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
304     Assert.assertEquals(1, actualRequests.size());
305     UpdateIngressRuleRequest actualRequest = ((UpdateIngressRuleRequest) actualRequests.get(0));
306 
307     Assert.assertEquals(request.getName(), actualRequest.getName());
308     Assert.assertEquals(request.getRule(), actualRequest.getRule());
309     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
310     Assert.assertTrue(
311         channelProvider.isHeaderSent(
312             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
313             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
314   }
315 
316   @Test
updateIngressRuleExceptionTest()317   public void updateIngressRuleExceptionTest() throws Exception {
318     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
319     mockFirewall.addException(exception);
320 
321     try {
322       UpdateIngressRuleRequest request =
323           UpdateIngressRuleRequest.newBuilder()
324               .setName("name3373707")
325               .setRule(FirewallRule.newBuilder().build())
326               .setUpdateMask(FieldMask.newBuilder().build())
327               .build();
328       client.updateIngressRule(request);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
deleteIngressRuleTest()336   public void deleteIngressRuleTest() throws Exception {
337     Empty expectedResponse = Empty.newBuilder().build();
338     mockFirewall.addResponse(expectedResponse);
339 
340     DeleteIngressRuleRequest request =
341         DeleteIngressRuleRequest.newBuilder().setName("name3373707").build();
342 
343     client.deleteIngressRule(request);
344 
345     List<AbstractMessage> actualRequests = mockFirewall.getRequests();
346     Assert.assertEquals(1, actualRequests.size());
347     DeleteIngressRuleRequest actualRequest = ((DeleteIngressRuleRequest) actualRequests.get(0));
348 
349     Assert.assertEquals(request.getName(), actualRequest.getName());
350     Assert.assertTrue(
351         channelProvider.isHeaderSent(
352             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
353             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
354   }
355 
356   @Test
deleteIngressRuleExceptionTest()357   public void deleteIngressRuleExceptionTest() throws Exception {
358     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
359     mockFirewall.addException(exception);
360 
361     try {
362       DeleteIngressRuleRequest request =
363           DeleteIngressRuleRequest.newBuilder().setName("name3373707").build();
364       client.deleteIngressRule(request);
365       Assert.fail("No exception raised");
366     } catch (InvalidArgumentException e) {
367       // Expected exception.
368     }
369   }
370 }
371