• 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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.FirewallsClient.ListPagedResponse;
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.compute.v1.Operation.Status;
31 import com.google.cloud.compute.v1.stub.HttpJsonFirewallsStub;
32 import com.google.common.collect.Lists;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.List;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class FirewallsClientTest {
48   private static MockHttpService mockService;
49   private static FirewallsClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonFirewallsStub.getMethodDescriptors(), FirewallsSettings.getDefaultEndpoint());
56     FirewallsSettings settings =
57         FirewallsSettings.newBuilder()
58             .setTransportChannelProvider(
59                 FirewallsSettings.defaultHttpJsonTransportProviderBuilder()
60                     .setHttpTransport(mockService)
61                     .build())
62             .setCredentialsProvider(NoCredentialsProvider.create())
63             .build();
64     client = FirewallsClient.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
deleteTest()81   public void deleteTest() throws Exception {
82     Operation expectedResponse =
83         Operation.newBuilder()
84             .setClientOperationId("clientOperationId-1230366697")
85             .setCreationTimestamp("creationTimestamp-370203401")
86             .setDescription("description-1724546052")
87             .setEndTime("endTime-1607243192")
88             .setError(Error.newBuilder().build())
89             .setHttpErrorMessage("httpErrorMessage1577303431")
90             .setHttpErrorStatusCode(0)
91             .setId(3355)
92             .setInsertTime("insertTime966165798")
93             .setKind("kind3292052")
94             .setName("name3373707")
95             .setOperationGroupId("operationGroupId1716161683")
96             .setOperationType("operationType91999553")
97             .setProgress(-1001078227)
98             .setRegion("region-934795532")
99             .setSelfLink("selfLink1191800166")
100             .setStartTime("startTime-2129294769")
101             .setStatus(Status.DONE)
102             .setStatusMessage("statusMessage-958704715")
103             .setTargetId(-815576439)
104             .setTargetLink("targetLink486368555")
105             .setUser("user3599307")
106             .addAllWarnings(new ArrayList<Warnings>())
107             .setZone("zone3744684")
108             .build();
109     mockService.addResponse(expectedResponse);
110 
111     String project = "project-6911";
112     String firewall = "firewall-5366";
113 
114     Operation actualResponse = client.deleteAsync(project, firewall).get();
115     Assert.assertEquals(expectedResponse, actualResponse);
116 
117     List<String> actualRequests = mockService.getRequestPaths();
118     Assert.assertEquals(1, actualRequests.size());
119 
120     String apiClientHeaderKey =
121         mockService
122             .getRequestHeaders()
123             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
124             .iterator()
125             .next();
126     Assert.assertTrue(
127         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
128             .matcher(apiClientHeaderKey)
129             .matches());
130   }
131 
132   @Test
deleteExceptionTest()133   public void deleteExceptionTest() throws Exception {
134     ApiException exception =
135         ApiExceptionFactory.createException(
136             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
137     mockService.addException(exception);
138 
139     try {
140       String project = "project-6911";
141       String firewall = "firewall-5366";
142       client.deleteAsync(project, firewall).get();
143       Assert.fail("No exception raised");
144     } catch (ExecutionException e) {
145     }
146   }
147 
148   @Test
getTest()149   public void getTest() throws Exception {
150     Firewall expectedResponse =
151         Firewall.newBuilder()
152             .addAllAllowed(new ArrayList<Allowed>())
153             .setCreationTimestamp("creationTimestamp-370203401")
154             .addAllDenied(new ArrayList<Denied>())
155             .setDescription("description-1724546052")
156             .addAllDestinationRanges(new ArrayList<String>())
157             .setDirection("direction-962590849")
158             .setDisabled(true)
159             .setId(3355)
160             .setKind("kind3292052")
161             .setLogConfig(FirewallLogConfig.newBuilder().build())
162             .setName("name3373707")
163             .setNetwork("network1843485230")
164             .setPriority(-1165461084)
165             .setSelfLink("selfLink1191800166")
166             .addAllSourceRanges(new ArrayList<String>())
167             .addAllSourceServiceAccounts(new ArrayList<String>())
168             .addAllSourceTags(new ArrayList<String>())
169             .addAllTargetServiceAccounts(new ArrayList<String>())
170             .addAllTargetTags(new ArrayList<String>())
171             .build();
172     mockService.addResponse(expectedResponse);
173 
174     String project = "project-6911";
175     String firewall = "firewall-5366";
176 
177     Firewall actualResponse = client.get(project, firewall);
178     Assert.assertEquals(expectedResponse, actualResponse);
179 
180     List<String> actualRequests = mockService.getRequestPaths();
181     Assert.assertEquals(1, actualRequests.size());
182 
183     String apiClientHeaderKey =
184         mockService
185             .getRequestHeaders()
186             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
187             .iterator()
188             .next();
189     Assert.assertTrue(
190         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
191             .matcher(apiClientHeaderKey)
192             .matches());
193   }
194 
195   @Test
getExceptionTest()196   public void getExceptionTest() throws Exception {
197     ApiException exception =
198         ApiExceptionFactory.createException(
199             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
200     mockService.addException(exception);
201 
202     try {
203       String project = "project-6911";
204       String firewall = "firewall-5366";
205       client.get(project, firewall);
206       Assert.fail("No exception raised");
207     } catch (InvalidArgumentException e) {
208       // Expected exception.
209     }
210   }
211 
212   @Test
insertTest()213   public void insertTest() throws Exception {
214     Operation expectedResponse =
215         Operation.newBuilder()
216             .setClientOperationId("clientOperationId-1230366697")
217             .setCreationTimestamp("creationTimestamp-370203401")
218             .setDescription("description-1724546052")
219             .setEndTime("endTime-1607243192")
220             .setError(Error.newBuilder().build())
221             .setHttpErrorMessage("httpErrorMessage1577303431")
222             .setHttpErrorStatusCode(0)
223             .setId(3355)
224             .setInsertTime("insertTime966165798")
225             .setKind("kind3292052")
226             .setName("name3373707")
227             .setOperationGroupId("operationGroupId1716161683")
228             .setOperationType("operationType91999553")
229             .setProgress(-1001078227)
230             .setRegion("region-934795532")
231             .setSelfLink("selfLink1191800166")
232             .setStartTime("startTime-2129294769")
233             .setStatus(Status.DONE)
234             .setStatusMessage("statusMessage-958704715")
235             .setTargetId(-815576439)
236             .setTargetLink("targetLink486368555")
237             .setUser("user3599307")
238             .addAllWarnings(new ArrayList<Warnings>())
239             .setZone("zone3744684")
240             .build();
241     mockService.addResponse(expectedResponse);
242 
243     String project = "project-6911";
244     Firewall firewallResource = Firewall.newBuilder().build();
245 
246     Operation actualResponse = client.insertAsync(project, firewallResource).get();
247     Assert.assertEquals(expectedResponse, actualResponse);
248 
249     List<String> actualRequests = mockService.getRequestPaths();
250     Assert.assertEquals(1, actualRequests.size());
251 
252     String apiClientHeaderKey =
253         mockService
254             .getRequestHeaders()
255             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
256             .iterator()
257             .next();
258     Assert.assertTrue(
259         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
260             .matcher(apiClientHeaderKey)
261             .matches());
262   }
263 
264   @Test
insertExceptionTest()265   public void insertExceptionTest() throws Exception {
266     ApiException exception =
267         ApiExceptionFactory.createException(
268             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
269     mockService.addException(exception);
270 
271     try {
272       String project = "project-6911";
273       Firewall firewallResource = Firewall.newBuilder().build();
274       client.insertAsync(project, firewallResource).get();
275       Assert.fail("No exception raised");
276     } catch (ExecutionException e) {
277     }
278   }
279 
280   @Test
listTest()281   public void listTest() throws Exception {
282     Firewall responsesElement = Firewall.newBuilder().build();
283     FirewallList expectedResponse =
284         FirewallList.newBuilder()
285             .setNextPageToken("")
286             .addAllItems(Arrays.asList(responsesElement))
287             .build();
288     mockService.addResponse(expectedResponse);
289 
290     String project = "project-6911";
291 
292     ListPagedResponse pagedListResponse = client.list(project);
293 
294     List<Firewall> resources = Lists.newArrayList(pagedListResponse.iterateAll());
295 
296     Assert.assertEquals(1, resources.size());
297     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
298 
299     List<String> actualRequests = mockService.getRequestPaths();
300     Assert.assertEquals(1, actualRequests.size());
301 
302     String apiClientHeaderKey =
303         mockService
304             .getRequestHeaders()
305             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
306             .iterator()
307             .next();
308     Assert.assertTrue(
309         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
310             .matcher(apiClientHeaderKey)
311             .matches());
312   }
313 
314   @Test
listExceptionTest()315   public void listExceptionTest() throws Exception {
316     ApiException exception =
317         ApiExceptionFactory.createException(
318             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
319     mockService.addException(exception);
320 
321     try {
322       String project = "project-6911";
323       client.list(project);
324       Assert.fail("No exception raised");
325     } catch (InvalidArgumentException e) {
326       // Expected exception.
327     }
328   }
329 
330   @Test
patchTest()331   public void patchTest() throws Exception {
332     Operation expectedResponse =
333         Operation.newBuilder()
334             .setClientOperationId("clientOperationId-1230366697")
335             .setCreationTimestamp("creationTimestamp-370203401")
336             .setDescription("description-1724546052")
337             .setEndTime("endTime-1607243192")
338             .setError(Error.newBuilder().build())
339             .setHttpErrorMessage("httpErrorMessage1577303431")
340             .setHttpErrorStatusCode(0)
341             .setId(3355)
342             .setInsertTime("insertTime966165798")
343             .setKind("kind3292052")
344             .setName("name3373707")
345             .setOperationGroupId("operationGroupId1716161683")
346             .setOperationType("operationType91999553")
347             .setProgress(-1001078227)
348             .setRegion("region-934795532")
349             .setSelfLink("selfLink1191800166")
350             .setStartTime("startTime-2129294769")
351             .setStatus(Status.DONE)
352             .setStatusMessage("statusMessage-958704715")
353             .setTargetId(-815576439)
354             .setTargetLink("targetLink486368555")
355             .setUser("user3599307")
356             .addAllWarnings(new ArrayList<Warnings>())
357             .setZone("zone3744684")
358             .build();
359     mockService.addResponse(expectedResponse);
360 
361     String project = "project-6911";
362     String firewall = "firewall-5366";
363     Firewall firewallResource = Firewall.newBuilder().build();
364 
365     Operation actualResponse = client.patchAsync(project, firewall, firewallResource).get();
366     Assert.assertEquals(expectedResponse, actualResponse);
367 
368     List<String> actualRequests = mockService.getRequestPaths();
369     Assert.assertEquals(1, actualRequests.size());
370 
371     String apiClientHeaderKey =
372         mockService
373             .getRequestHeaders()
374             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
375             .iterator()
376             .next();
377     Assert.assertTrue(
378         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
379             .matcher(apiClientHeaderKey)
380             .matches());
381   }
382 
383   @Test
patchExceptionTest()384   public void patchExceptionTest() throws Exception {
385     ApiException exception =
386         ApiExceptionFactory.createException(
387             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
388     mockService.addException(exception);
389 
390     try {
391       String project = "project-6911";
392       String firewall = "firewall-5366";
393       Firewall firewallResource = Firewall.newBuilder().build();
394       client.patchAsync(project, firewall, firewallResource).get();
395       Assert.fail("No exception raised");
396     } catch (ExecutionException e) {
397     }
398   }
399 
400   @Test
updateTest()401   public void updateTest() throws Exception {
402     Operation expectedResponse =
403         Operation.newBuilder()
404             .setClientOperationId("clientOperationId-1230366697")
405             .setCreationTimestamp("creationTimestamp-370203401")
406             .setDescription("description-1724546052")
407             .setEndTime("endTime-1607243192")
408             .setError(Error.newBuilder().build())
409             .setHttpErrorMessage("httpErrorMessage1577303431")
410             .setHttpErrorStatusCode(0)
411             .setId(3355)
412             .setInsertTime("insertTime966165798")
413             .setKind("kind3292052")
414             .setName("name3373707")
415             .setOperationGroupId("operationGroupId1716161683")
416             .setOperationType("operationType91999553")
417             .setProgress(-1001078227)
418             .setRegion("region-934795532")
419             .setSelfLink("selfLink1191800166")
420             .setStartTime("startTime-2129294769")
421             .setStatus(Status.DONE)
422             .setStatusMessage("statusMessage-958704715")
423             .setTargetId(-815576439)
424             .setTargetLink("targetLink486368555")
425             .setUser("user3599307")
426             .addAllWarnings(new ArrayList<Warnings>())
427             .setZone("zone3744684")
428             .build();
429     mockService.addResponse(expectedResponse);
430 
431     String project = "project-6911";
432     String firewall = "firewall-5366";
433     Firewall firewallResource = Firewall.newBuilder().build();
434 
435     Operation actualResponse = client.updateAsync(project, firewall, firewallResource).get();
436     Assert.assertEquals(expectedResponse, actualResponse);
437 
438     List<String> actualRequests = mockService.getRequestPaths();
439     Assert.assertEquals(1, actualRequests.size());
440 
441     String apiClientHeaderKey =
442         mockService
443             .getRequestHeaders()
444             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
445             .iterator()
446             .next();
447     Assert.assertTrue(
448         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
449             .matcher(apiClientHeaderKey)
450             .matches());
451   }
452 
453   @Test
updateExceptionTest()454   public void updateExceptionTest() throws Exception {
455     ApiException exception =
456         ApiExceptionFactory.createException(
457             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
458     mockService.addException(exception);
459 
460     try {
461       String project = "project-6911";
462       String firewall = "firewall-5366";
463       Firewall firewallResource = Firewall.newBuilder().build();
464       client.updateAsync(project, firewall, firewallResource).get();
465       Assert.fail("No exception raised");
466     } catch (ExecutionException e) {
467     }
468   }
469 }
470