• 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.FirewallPoliciesClient.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.HttpJsonFirewallPoliciesStub;
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 FirewallPoliciesClientTest {
48   private static MockHttpService mockService;
49   private static FirewallPoliciesClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonFirewallPoliciesStub.getMethodDescriptors(),
56             FirewallPoliciesSettings.getDefaultEndpoint());
57     FirewallPoliciesSettings settings =
58         FirewallPoliciesSettings.newBuilder()
59             .setTransportChannelProvider(
60                 FirewallPoliciesSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = FirewallPoliciesClient.create(settings);
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     client.close();
71   }
72 
73   @Before
setUp()74   public void setUp() {}
75 
76   @After
tearDown()77   public void tearDown() throws Exception {
78     mockService.reset();
79   }
80 
81   @Test
addAssociationTest()82   public void addAssociationTest() throws Exception {
83     Operation expectedResponse =
84         Operation.newBuilder()
85             .setClientOperationId("clientOperationId-1230366697")
86             .setCreationTimestamp("creationTimestamp-370203401")
87             .setDescription("description-1724546052")
88             .setEndTime("endTime-1607243192")
89             .setError(Error.newBuilder().build())
90             .setHttpErrorMessage("httpErrorMessage1577303431")
91             .setHttpErrorStatusCode(0)
92             .setId(3355)
93             .setInsertTime("insertTime966165798")
94             .setKind("kind3292052")
95             .setName("name3373707")
96             .setOperationGroupId("operationGroupId1716161683")
97             .setOperationType("operationType91999553")
98             .setProgress(-1001078227)
99             .setRegion("region-934795532")
100             .setSelfLink("selfLink1191800166")
101             .setStartTime("startTime-2129294769")
102             .setStatus(Status.DONE)
103             .setStatusMessage("statusMessage-958704715")
104             .setTargetId(-815576439)
105             .setTargetLink("targetLink486368555")
106             .setUser("user3599307")
107             .addAllWarnings(new ArrayList<Warnings>())
108             .setZone("zone3744684")
109             .build();
110     mockService.addResponse(expectedResponse);
111 
112     String firewallPolicy = "firewallPolicy-6600";
113     FirewallPolicyAssociation firewallPolicyAssociationResource =
114         FirewallPolicyAssociation.newBuilder().build();
115 
116     Operation actualResponse =
117         client.addAssociationAsync(firewallPolicy, firewallPolicyAssociationResource).get();
118     Assert.assertEquals(expectedResponse, actualResponse);
119 
120     List<String> actualRequests = mockService.getRequestPaths();
121     Assert.assertEquals(1, actualRequests.size());
122 
123     String apiClientHeaderKey =
124         mockService
125             .getRequestHeaders()
126             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
127             .iterator()
128             .next();
129     Assert.assertTrue(
130         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
131             .matcher(apiClientHeaderKey)
132             .matches());
133   }
134 
135   @Test
addAssociationExceptionTest()136   public void addAssociationExceptionTest() throws Exception {
137     ApiException exception =
138         ApiExceptionFactory.createException(
139             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
140     mockService.addException(exception);
141 
142     try {
143       String firewallPolicy = "firewallPolicy-6600";
144       FirewallPolicyAssociation firewallPolicyAssociationResource =
145           FirewallPolicyAssociation.newBuilder().build();
146       client.addAssociationAsync(firewallPolicy, firewallPolicyAssociationResource).get();
147       Assert.fail("No exception raised");
148     } catch (ExecutionException e) {
149     }
150   }
151 
152   @Test
addRuleTest()153   public void addRuleTest() throws Exception {
154     Operation expectedResponse =
155         Operation.newBuilder()
156             .setClientOperationId("clientOperationId-1230366697")
157             .setCreationTimestamp("creationTimestamp-370203401")
158             .setDescription("description-1724546052")
159             .setEndTime("endTime-1607243192")
160             .setError(Error.newBuilder().build())
161             .setHttpErrorMessage("httpErrorMessage1577303431")
162             .setHttpErrorStatusCode(0)
163             .setId(3355)
164             .setInsertTime("insertTime966165798")
165             .setKind("kind3292052")
166             .setName("name3373707")
167             .setOperationGroupId("operationGroupId1716161683")
168             .setOperationType("operationType91999553")
169             .setProgress(-1001078227)
170             .setRegion("region-934795532")
171             .setSelfLink("selfLink1191800166")
172             .setStartTime("startTime-2129294769")
173             .setStatus(Status.DONE)
174             .setStatusMessage("statusMessage-958704715")
175             .setTargetId(-815576439)
176             .setTargetLink("targetLink486368555")
177             .setUser("user3599307")
178             .addAllWarnings(new ArrayList<Warnings>())
179             .setZone("zone3744684")
180             .build();
181     mockService.addResponse(expectedResponse);
182 
183     String firewallPolicy = "firewallPolicy-6600";
184     FirewallPolicyRule firewallPolicyRuleResource = FirewallPolicyRule.newBuilder().build();
185 
186     Operation actualResponse =
187         client.addRuleAsync(firewallPolicy, firewallPolicyRuleResource).get();
188     Assert.assertEquals(expectedResponse, actualResponse);
189 
190     List<String> actualRequests = mockService.getRequestPaths();
191     Assert.assertEquals(1, actualRequests.size());
192 
193     String apiClientHeaderKey =
194         mockService
195             .getRequestHeaders()
196             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
197             .iterator()
198             .next();
199     Assert.assertTrue(
200         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
201             .matcher(apiClientHeaderKey)
202             .matches());
203   }
204 
205   @Test
addRuleExceptionTest()206   public void addRuleExceptionTest() throws Exception {
207     ApiException exception =
208         ApiExceptionFactory.createException(
209             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
210     mockService.addException(exception);
211 
212     try {
213       String firewallPolicy = "firewallPolicy-6600";
214       FirewallPolicyRule firewallPolicyRuleResource = FirewallPolicyRule.newBuilder().build();
215       client.addRuleAsync(firewallPolicy, firewallPolicyRuleResource).get();
216       Assert.fail("No exception raised");
217     } catch (ExecutionException e) {
218     }
219   }
220 
221   @Test
cloneRulesTest()222   public void cloneRulesTest() throws Exception {
223     Operation expectedResponse =
224         Operation.newBuilder()
225             .setClientOperationId("clientOperationId-1230366697")
226             .setCreationTimestamp("creationTimestamp-370203401")
227             .setDescription("description-1724546052")
228             .setEndTime("endTime-1607243192")
229             .setError(Error.newBuilder().build())
230             .setHttpErrorMessage("httpErrorMessage1577303431")
231             .setHttpErrorStatusCode(0)
232             .setId(3355)
233             .setInsertTime("insertTime966165798")
234             .setKind("kind3292052")
235             .setName("name3373707")
236             .setOperationGroupId("operationGroupId1716161683")
237             .setOperationType("operationType91999553")
238             .setProgress(-1001078227)
239             .setRegion("region-934795532")
240             .setSelfLink("selfLink1191800166")
241             .setStartTime("startTime-2129294769")
242             .setStatus(Status.DONE)
243             .setStatusMessage("statusMessage-958704715")
244             .setTargetId(-815576439)
245             .setTargetLink("targetLink486368555")
246             .setUser("user3599307")
247             .addAllWarnings(new ArrayList<Warnings>())
248             .setZone("zone3744684")
249             .build();
250     mockService.addResponse(expectedResponse);
251 
252     String firewallPolicy = "firewallPolicy-6600";
253 
254     Operation actualResponse = client.cloneRulesAsync(firewallPolicy).get();
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<String> actualRequests = mockService.getRequestPaths();
258     Assert.assertEquals(1, actualRequests.size());
259 
260     String apiClientHeaderKey =
261         mockService
262             .getRequestHeaders()
263             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
264             .iterator()
265             .next();
266     Assert.assertTrue(
267         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
268             .matcher(apiClientHeaderKey)
269             .matches());
270   }
271 
272   @Test
cloneRulesExceptionTest()273   public void cloneRulesExceptionTest() throws Exception {
274     ApiException exception =
275         ApiExceptionFactory.createException(
276             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
277     mockService.addException(exception);
278 
279     try {
280       String firewallPolicy = "firewallPolicy-6600";
281       client.cloneRulesAsync(firewallPolicy).get();
282       Assert.fail("No exception raised");
283     } catch (ExecutionException e) {
284     }
285   }
286 
287   @Test
deleteTest()288   public void deleteTest() throws Exception {
289     Operation expectedResponse =
290         Operation.newBuilder()
291             .setClientOperationId("clientOperationId-1230366697")
292             .setCreationTimestamp("creationTimestamp-370203401")
293             .setDescription("description-1724546052")
294             .setEndTime("endTime-1607243192")
295             .setError(Error.newBuilder().build())
296             .setHttpErrorMessage("httpErrorMessage1577303431")
297             .setHttpErrorStatusCode(0)
298             .setId(3355)
299             .setInsertTime("insertTime966165798")
300             .setKind("kind3292052")
301             .setName("name3373707")
302             .setOperationGroupId("operationGroupId1716161683")
303             .setOperationType("operationType91999553")
304             .setProgress(-1001078227)
305             .setRegion("region-934795532")
306             .setSelfLink("selfLink1191800166")
307             .setStartTime("startTime-2129294769")
308             .setStatus(Status.DONE)
309             .setStatusMessage("statusMessage-958704715")
310             .setTargetId(-815576439)
311             .setTargetLink("targetLink486368555")
312             .setUser("user3599307")
313             .addAllWarnings(new ArrayList<Warnings>())
314             .setZone("zone3744684")
315             .build();
316     mockService.addResponse(expectedResponse);
317 
318     String firewallPolicy = "firewallPolicy-6600";
319 
320     Operation actualResponse = client.deleteAsync(firewallPolicy).get();
321     Assert.assertEquals(expectedResponse, actualResponse);
322 
323     List<String> actualRequests = mockService.getRequestPaths();
324     Assert.assertEquals(1, actualRequests.size());
325 
326     String apiClientHeaderKey =
327         mockService
328             .getRequestHeaders()
329             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
330             .iterator()
331             .next();
332     Assert.assertTrue(
333         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
334             .matcher(apiClientHeaderKey)
335             .matches());
336   }
337 
338   @Test
deleteExceptionTest()339   public void deleteExceptionTest() throws Exception {
340     ApiException exception =
341         ApiExceptionFactory.createException(
342             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
343     mockService.addException(exception);
344 
345     try {
346       String firewallPolicy = "firewallPolicy-6600";
347       client.deleteAsync(firewallPolicy).get();
348       Assert.fail("No exception raised");
349     } catch (ExecutionException e) {
350     }
351   }
352 
353   @Test
getTest()354   public void getTest() throws Exception {
355     FirewallPolicy expectedResponse =
356         FirewallPolicy.newBuilder()
357             .addAllAssociations(new ArrayList<FirewallPolicyAssociation>())
358             .setCreationTimestamp("creationTimestamp-370203401")
359             .setDescription("description-1724546052")
360             .setDisplayName("displayName1714148973")
361             .setFingerprint("fingerprint-1375934236")
362             .setId(3355)
363             .setKind("kind3292052")
364             .setName("name3373707")
365             .setParent("parent-995424086")
366             .setRegion("region-934795532")
367             .setRuleTupleCount(388342037)
368             .addAllRules(new ArrayList<FirewallPolicyRule>())
369             .setSelfLink("selfLink1191800166")
370             .setSelfLinkWithId("selfLinkWithId-776809081")
371             .setShortName("shortName-2028219097")
372             .build();
373     mockService.addResponse(expectedResponse);
374 
375     String firewallPolicy = "firewallPolicy-6600";
376 
377     FirewallPolicy actualResponse = client.get(firewallPolicy);
378     Assert.assertEquals(expectedResponse, actualResponse);
379 
380     List<String> actualRequests = mockService.getRequestPaths();
381     Assert.assertEquals(1, actualRequests.size());
382 
383     String apiClientHeaderKey =
384         mockService
385             .getRequestHeaders()
386             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
387             .iterator()
388             .next();
389     Assert.assertTrue(
390         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
391             .matcher(apiClientHeaderKey)
392             .matches());
393   }
394 
395   @Test
getExceptionTest()396   public void getExceptionTest() throws Exception {
397     ApiException exception =
398         ApiExceptionFactory.createException(
399             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
400     mockService.addException(exception);
401 
402     try {
403       String firewallPolicy = "firewallPolicy-6600";
404       client.get(firewallPolicy);
405       Assert.fail("No exception raised");
406     } catch (InvalidArgumentException e) {
407       // Expected exception.
408     }
409   }
410 
411   @Test
getAssociationTest()412   public void getAssociationTest() throws Exception {
413     FirewallPolicyAssociation expectedResponse =
414         FirewallPolicyAssociation.newBuilder()
415             .setAttachmentTarget("attachmentTarget279842964")
416             .setDisplayName("displayName1714148973")
417             .setFirewallPolicyId("firewallPolicyId672926477")
418             .setName("name3373707")
419             .setShortName("shortName-2028219097")
420             .build();
421     mockService.addResponse(expectedResponse);
422 
423     String firewallPolicy = "firewallPolicy-6600";
424 
425     FirewallPolicyAssociation actualResponse = client.getAssociation(firewallPolicy);
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<String> actualRequests = mockService.getRequestPaths();
429     Assert.assertEquals(1, actualRequests.size());
430 
431     String apiClientHeaderKey =
432         mockService
433             .getRequestHeaders()
434             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
435             .iterator()
436             .next();
437     Assert.assertTrue(
438         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
439             .matcher(apiClientHeaderKey)
440             .matches());
441   }
442 
443   @Test
getAssociationExceptionTest()444   public void getAssociationExceptionTest() throws Exception {
445     ApiException exception =
446         ApiExceptionFactory.createException(
447             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
448     mockService.addException(exception);
449 
450     try {
451       String firewallPolicy = "firewallPolicy-6600";
452       client.getAssociation(firewallPolicy);
453       Assert.fail("No exception raised");
454     } catch (InvalidArgumentException e) {
455       // Expected exception.
456     }
457   }
458 
459   @Test
getIamPolicyTest()460   public void getIamPolicyTest() throws Exception {
461     Policy expectedResponse =
462         Policy.newBuilder()
463             .addAllAuditConfigs(new ArrayList<AuditConfig>())
464             .addAllBindings(new ArrayList<Binding>())
465             .setEtag("etag3123477")
466             .setIamOwned(true)
467             .addAllRules(new ArrayList<Rule>())
468             .setVersion(351608024)
469             .build();
470     mockService.addResponse(expectedResponse);
471 
472     String resource = "resource-756";
473 
474     Policy actualResponse = client.getIamPolicy(resource);
475     Assert.assertEquals(expectedResponse, actualResponse);
476 
477     List<String> actualRequests = mockService.getRequestPaths();
478     Assert.assertEquals(1, actualRequests.size());
479 
480     String apiClientHeaderKey =
481         mockService
482             .getRequestHeaders()
483             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
484             .iterator()
485             .next();
486     Assert.assertTrue(
487         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
488             .matcher(apiClientHeaderKey)
489             .matches());
490   }
491 
492   @Test
getIamPolicyExceptionTest()493   public void getIamPolicyExceptionTest() throws Exception {
494     ApiException exception =
495         ApiExceptionFactory.createException(
496             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
497     mockService.addException(exception);
498 
499     try {
500       String resource = "resource-756";
501       client.getIamPolicy(resource);
502       Assert.fail("No exception raised");
503     } catch (InvalidArgumentException e) {
504       // Expected exception.
505     }
506   }
507 
508   @Test
getRuleTest()509   public void getRuleTest() throws Exception {
510     FirewallPolicyRule expectedResponse =
511         FirewallPolicyRule.newBuilder()
512             .setAction("action-1422950858")
513             .setDescription("description-1724546052")
514             .setDirection("direction-962590849")
515             .setDisabled(true)
516             .setEnableLogging(true)
517             .setKind("kind3292052")
518             .setMatch(FirewallPolicyRuleMatcher.newBuilder().build())
519             .setPriority(-1165461084)
520             .setRuleName("ruleName763275175")
521             .setRuleTupleCount(388342037)
522             .addAllTargetResources(new ArrayList<String>())
523             .addAllTargetSecureTags(new ArrayList<FirewallPolicyRuleSecureTag>())
524             .addAllTargetServiceAccounts(new ArrayList<String>())
525             .build();
526     mockService.addResponse(expectedResponse);
527 
528     String firewallPolicy = "firewallPolicy-6600";
529 
530     FirewallPolicyRule actualResponse = client.getRule(firewallPolicy);
531     Assert.assertEquals(expectedResponse, actualResponse);
532 
533     List<String> actualRequests = mockService.getRequestPaths();
534     Assert.assertEquals(1, actualRequests.size());
535 
536     String apiClientHeaderKey =
537         mockService
538             .getRequestHeaders()
539             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
540             .iterator()
541             .next();
542     Assert.assertTrue(
543         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
544             .matcher(apiClientHeaderKey)
545             .matches());
546   }
547 
548   @Test
getRuleExceptionTest()549   public void getRuleExceptionTest() throws Exception {
550     ApiException exception =
551         ApiExceptionFactory.createException(
552             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
553     mockService.addException(exception);
554 
555     try {
556       String firewallPolicy = "firewallPolicy-6600";
557       client.getRule(firewallPolicy);
558       Assert.fail("No exception raised");
559     } catch (InvalidArgumentException e) {
560       // Expected exception.
561     }
562   }
563 
564   @Test
insertTest()565   public void insertTest() throws Exception {
566     Operation expectedResponse =
567         Operation.newBuilder()
568             .setClientOperationId("clientOperationId-1230366697")
569             .setCreationTimestamp("creationTimestamp-370203401")
570             .setDescription("description-1724546052")
571             .setEndTime("endTime-1607243192")
572             .setError(Error.newBuilder().build())
573             .setHttpErrorMessage("httpErrorMessage1577303431")
574             .setHttpErrorStatusCode(0)
575             .setId(3355)
576             .setInsertTime("insertTime966165798")
577             .setKind("kind3292052")
578             .setName("name3373707")
579             .setOperationGroupId("operationGroupId1716161683")
580             .setOperationType("operationType91999553")
581             .setProgress(-1001078227)
582             .setRegion("region-934795532")
583             .setSelfLink("selfLink1191800166")
584             .setStartTime("startTime-2129294769")
585             .setStatus(Status.DONE)
586             .setStatusMessage("statusMessage-958704715")
587             .setTargetId(-815576439)
588             .setTargetLink("targetLink486368555")
589             .setUser("user3599307")
590             .addAllWarnings(new ArrayList<Warnings>())
591             .setZone("zone3744684")
592             .build();
593     mockService.addResponse(expectedResponse);
594 
595     String parentId = "parentId1175162725";
596     FirewallPolicy firewallPolicyResource = FirewallPolicy.newBuilder().build();
597 
598     Operation actualResponse = client.insertAsync(parentId, firewallPolicyResource).get();
599     Assert.assertEquals(expectedResponse, actualResponse);
600 
601     List<String> actualRequests = mockService.getRequestPaths();
602     Assert.assertEquals(1, actualRequests.size());
603 
604     String apiClientHeaderKey =
605         mockService
606             .getRequestHeaders()
607             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
608             .iterator()
609             .next();
610     Assert.assertTrue(
611         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
612             .matcher(apiClientHeaderKey)
613             .matches());
614   }
615 
616   @Test
insertExceptionTest()617   public void insertExceptionTest() throws Exception {
618     ApiException exception =
619         ApiExceptionFactory.createException(
620             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
621     mockService.addException(exception);
622 
623     try {
624       String parentId = "parentId1175162725";
625       FirewallPolicy firewallPolicyResource = FirewallPolicy.newBuilder().build();
626       client.insertAsync(parentId, firewallPolicyResource).get();
627       Assert.fail("No exception raised");
628     } catch (ExecutionException e) {
629     }
630   }
631 
632   @Test
listTest()633   public void listTest() throws Exception {
634     FirewallPolicy responsesElement = FirewallPolicy.newBuilder().build();
635     FirewallPolicyList expectedResponse =
636         FirewallPolicyList.newBuilder()
637             .setNextPageToken("")
638             .addAllItems(Arrays.asList(responsesElement))
639             .build();
640     mockService.addResponse(expectedResponse);
641 
642     ListPagedResponse pagedListResponse = client.list();
643 
644     List<FirewallPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
645 
646     Assert.assertEquals(1, resources.size());
647     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
648 
649     List<String> actualRequests = mockService.getRequestPaths();
650     Assert.assertEquals(1, actualRequests.size());
651 
652     String apiClientHeaderKey =
653         mockService
654             .getRequestHeaders()
655             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
656             .iterator()
657             .next();
658     Assert.assertTrue(
659         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
660             .matcher(apiClientHeaderKey)
661             .matches());
662   }
663 
664   @Test
listExceptionTest()665   public void listExceptionTest() throws Exception {
666     ApiException exception =
667         ApiExceptionFactory.createException(
668             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
669     mockService.addException(exception);
670 
671     try {
672       ListFirewallPoliciesRequest request =
673           ListFirewallPoliciesRequest.newBuilder()
674               .setFilter("filter-1274492040")
675               .setMaxResults(1128457243)
676               .setOrderBy("orderBy-1207110587")
677               .setPageToken("pageToken873572522")
678               .setParentId("parentId1175162725")
679               .setReturnPartialSuccess(true)
680               .build();
681       client.list(request);
682       Assert.fail("No exception raised");
683     } catch (InvalidArgumentException e) {
684       // Expected exception.
685     }
686   }
687 
688   @Test
listAssociationsTest()689   public void listAssociationsTest() throws Exception {
690     FirewallPoliciesListAssociationsResponse expectedResponse =
691         FirewallPoliciesListAssociationsResponse.newBuilder()
692             .addAllAssociations(new ArrayList<FirewallPolicyAssociation>())
693             .setKind("kind3292052")
694             .build();
695     mockService.addResponse(expectedResponse);
696 
697     FirewallPoliciesListAssociationsResponse actualResponse = client.listAssociations();
698     Assert.assertEquals(expectedResponse, actualResponse);
699 
700     List<String> actualRequests = mockService.getRequestPaths();
701     Assert.assertEquals(1, actualRequests.size());
702 
703     String apiClientHeaderKey =
704         mockService
705             .getRequestHeaders()
706             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
707             .iterator()
708             .next();
709     Assert.assertTrue(
710         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
711             .matcher(apiClientHeaderKey)
712             .matches());
713   }
714 
715   @Test
listAssociationsExceptionTest()716   public void listAssociationsExceptionTest() throws Exception {
717     ApiException exception =
718         ApiExceptionFactory.createException(
719             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
720     mockService.addException(exception);
721 
722     try {
723       ListAssociationsFirewallPolicyRequest request =
724           ListAssociationsFirewallPolicyRequest.newBuilder()
725               .setTargetResource("targetResource-1933150017")
726               .build();
727       client.listAssociations(request);
728       Assert.fail("No exception raised");
729     } catch (InvalidArgumentException e) {
730       // Expected exception.
731     }
732   }
733 
734   @Test
moveTest()735   public void moveTest() throws Exception {
736     Operation expectedResponse =
737         Operation.newBuilder()
738             .setClientOperationId("clientOperationId-1230366697")
739             .setCreationTimestamp("creationTimestamp-370203401")
740             .setDescription("description-1724546052")
741             .setEndTime("endTime-1607243192")
742             .setError(Error.newBuilder().build())
743             .setHttpErrorMessage("httpErrorMessage1577303431")
744             .setHttpErrorStatusCode(0)
745             .setId(3355)
746             .setInsertTime("insertTime966165798")
747             .setKind("kind3292052")
748             .setName("name3373707")
749             .setOperationGroupId("operationGroupId1716161683")
750             .setOperationType("operationType91999553")
751             .setProgress(-1001078227)
752             .setRegion("region-934795532")
753             .setSelfLink("selfLink1191800166")
754             .setStartTime("startTime-2129294769")
755             .setStatus(Status.DONE)
756             .setStatusMessage("statusMessage-958704715")
757             .setTargetId(-815576439)
758             .setTargetLink("targetLink486368555")
759             .setUser("user3599307")
760             .addAllWarnings(new ArrayList<Warnings>())
761             .setZone("zone3744684")
762             .build();
763     mockService.addResponse(expectedResponse);
764 
765     String firewallPolicy = "firewallPolicy-6600";
766     String parentId = "parentId1175162725";
767 
768     Operation actualResponse = client.moveAsync(firewallPolicy, parentId).get();
769     Assert.assertEquals(expectedResponse, actualResponse);
770 
771     List<String> actualRequests = mockService.getRequestPaths();
772     Assert.assertEquals(1, actualRequests.size());
773 
774     String apiClientHeaderKey =
775         mockService
776             .getRequestHeaders()
777             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
778             .iterator()
779             .next();
780     Assert.assertTrue(
781         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
782             .matcher(apiClientHeaderKey)
783             .matches());
784   }
785 
786   @Test
moveExceptionTest()787   public void moveExceptionTest() throws Exception {
788     ApiException exception =
789         ApiExceptionFactory.createException(
790             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
791     mockService.addException(exception);
792 
793     try {
794       String firewallPolicy = "firewallPolicy-6600";
795       String parentId = "parentId1175162725";
796       client.moveAsync(firewallPolicy, parentId).get();
797       Assert.fail("No exception raised");
798     } catch (ExecutionException e) {
799     }
800   }
801 
802   @Test
patchTest()803   public void patchTest() throws Exception {
804     Operation expectedResponse =
805         Operation.newBuilder()
806             .setClientOperationId("clientOperationId-1230366697")
807             .setCreationTimestamp("creationTimestamp-370203401")
808             .setDescription("description-1724546052")
809             .setEndTime("endTime-1607243192")
810             .setError(Error.newBuilder().build())
811             .setHttpErrorMessage("httpErrorMessage1577303431")
812             .setHttpErrorStatusCode(0)
813             .setId(3355)
814             .setInsertTime("insertTime966165798")
815             .setKind("kind3292052")
816             .setName("name3373707")
817             .setOperationGroupId("operationGroupId1716161683")
818             .setOperationType("operationType91999553")
819             .setProgress(-1001078227)
820             .setRegion("region-934795532")
821             .setSelfLink("selfLink1191800166")
822             .setStartTime("startTime-2129294769")
823             .setStatus(Status.DONE)
824             .setStatusMessage("statusMessage-958704715")
825             .setTargetId(-815576439)
826             .setTargetLink("targetLink486368555")
827             .setUser("user3599307")
828             .addAllWarnings(new ArrayList<Warnings>())
829             .setZone("zone3744684")
830             .build();
831     mockService.addResponse(expectedResponse);
832 
833     String firewallPolicy = "firewallPolicy-6600";
834     FirewallPolicy firewallPolicyResource = FirewallPolicy.newBuilder().build();
835 
836     Operation actualResponse = client.patchAsync(firewallPolicy, firewallPolicyResource).get();
837     Assert.assertEquals(expectedResponse, actualResponse);
838 
839     List<String> actualRequests = mockService.getRequestPaths();
840     Assert.assertEquals(1, actualRequests.size());
841 
842     String apiClientHeaderKey =
843         mockService
844             .getRequestHeaders()
845             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
846             .iterator()
847             .next();
848     Assert.assertTrue(
849         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
850             .matcher(apiClientHeaderKey)
851             .matches());
852   }
853 
854   @Test
patchExceptionTest()855   public void patchExceptionTest() throws Exception {
856     ApiException exception =
857         ApiExceptionFactory.createException(
858             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
859     mockService.addException(exception);
860 
861     try {
862       String firewallPolicy = "firewallPolicy-6600";
863       FirewallPolicy firewallPolicyResource = FirewallPolicy.newBuilder().build();
864       client.patchAsync(firewallPolicy, firewallPolicyResource).get();
865       Assert.fail("No exception raised");
866     } catch (ExecutionException e) {
867     }
868   }
869 
870   @Test
patchRuleTest()871   public void patchRuleTest() throws Exception {
872     Operation expectedResponse =
873         Operation.newBuilder()
874             .setClientOperationId("clientOperationId-1230366697")
875             .setCreationTimestamp("creationTimestamp-370203401")
876             .setDescription("description-1724546052")
877             .setEndTime("endTime-1607243192")
878             .setError(Error.newBuilder().build())
879             .setHttpErrorMessage("httpErrorMessage1577303431")
880             .setHttpErrorStatusCode(0)
881             .setId(3355)
882             .setInsertTime("insertTime966165798")
883             .setKind("kind3292052")
884             .setName("name3373707")
885             .setOperationGroupId("operationGroupId1716161683")
886             .setOperationType("operationType91999553")
887             .setProgress(-1001078227)
888             .setRegion("region-934795532")
889             .setSelfLink("selfLink1191800166")
890             .setStartTime("startTime-2129294769")
891             .setStatus(Status.DONE)
892             .setStatusMessage("statusMessage-958704715")
893             .setTargetId(-815576439)
894             .setTargetLink("targetLink486368555")
895             .setUser("user3599307")
896             .addAllWarnings(new ArrayList<Warnings>())
897             .setZone("zone3744684")
898             .build();
899     mockService.addResponse(expectedResponse);
900 
901     String firewallPolicy = "firewallPolicy-6600";
902     FirewallPolicyRule firewallPolicyRuleResource = FirewallPolicyRule.newBuilder().build();
903 
904     Operation actualResponse =
905         client.patchRuleAsync(firewallPolicy, firewallPolicyRuleResource).get();
906     Assert.assertEquals(expectedResponse, actualResponse);
907 
908     List<String> actualRequests = mockService.getRequestPaths();
909     Assert.assertEquals(1, actualRequests.size());
910 
911     String apiClientHeaderKey =
912         mockService
913             .getRequestHeaders()
914             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
915             .iterator()
916             .next();
917     Assert.assertTrue(
918         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
919             .matcher(apiClientHeaderKey)
920             .matches());
921   }
922 
923   @Test
patchRuleExceptionTest()924   public void patchRuleExceptionTest() throws Exception {
925     ApiException exception =
926         ApiExceptionFactory.createException(
927             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
928     mockService.addException(exception);
929 
930     try {
931       String firewallPolicy = "firewallPolicy-6600";
932       FirewallPolicyRule firewallPolicyRuleResource = FirewallPolicyRule.newBuilder().build();
933       client.patchRuleAsync(firewallPolicy, firewallPolicyRuleResource).get();
934       Assert.fail("No exception raised");
935     } catch (ExecutionException e) {
936     }
937   }
938 
939   @Test
removeAssociationTest()940   public void removeAssociationTest() throws Exception {
941     Operation expectedResponse =
942         Operation.newBuilder()
943             .setClientOperationId("clientOperationId-1230366697")
944             .setCreationTimestamp("creationTimestamp-370203401")
945             .setDescription("description-1724546052")
946             .setEndTime("endTime-1607243192")
947             .setError(Error.newBuilder().build())
948             .setHttpErrorMessage("httpErrorMessage1577303431")
949             .setHttpErrorStatusCode(0)
950             .setId(3355)
951             .setInsertTime("insertTime966165798")
952             .setKind("kind3292052")
953             .setName("name3373707")
954             .setOperationGroupId("operationGroupId1716161683")
955             .setOperationType("operationType91999553")
956             .setProgress(-1001078227)
957             .setRegion("region-934795532")
958             .setSelfLink("selfLink1191800166")
959             .setStartTime("startTime-2129294769")
960             .setStatus(Status.DONE)
961             .setStatusMessage("statusMessage-958704715")
962             .setTargetId(-815576439)
963             .setTargetLink("targetLink486368555")
964             .setUser("user3599307")
965             .addAllWarnings(new ArrayList<Warnings>())
966             .setZone("zone3744684")
967             .build();
968     mockService.addResponse(expectedResponse);
969 
970     String firewallPolicy = "firewallPolicy-6600";
971 
972     Operation actualResponse = client.removeAssociationAsync(firewallPolicy).get();
973     Assert.assertEquals(expectedResponse, actualResponse);
974 
975     List<String> actualRequests = mockService.getRequestPaths();
976     Assert.assertEquals(1, actualRequests.size());
977 
978     String apiClientHeaderKey =
979         mockService
980             .getRequestHeaders()
981             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
982             .iterator()
983             .next();
984     Assert.assertTrue(
985         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
986             .matcher(apiClientHeaderKey)
987             .matches());
988   }
989 
990   @Test
removeAssociationExceptionTest()991   public void removeAssociationExceptionTest() throws Exception {
992     ApiException exception =
993         ApiExceptionFactory.createException(
994             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
995     mockService.addException(exception);
996 
997     try {
998       String firewallPolicy = "firewallPolicy-6600";
999       client.removeAssociationAsync(firewallPolicy).get();
1000       Assert.fail("No exception raised");
1001     } catch (ExecutionException e) {
1002     }
1003   }
1004 
1005   @Test
removeRuleTest()1006   public void removeRuleTest() throws Exception {
1007     Operation expectedResponse =
1008         Operation.newBuilder()
1009             .setClientOperationId("clientOperationId-1230366697")
1010             .setCreationTimestamp("creationTimestamp-370203401")
1011             .setDescription("description-1724546052")
1012             .setEndTime("endTime-1607243192")
1013             .setError(Error.newBuilder().build())
1014             .setHttpErrorMessage("httpErrorMessage1577303431")
1015             .setHttpErrorStatusCode(0)
1016             .setId(3355)
1017             .setInsertTime("insertTime966165798")
1018             .setKind("kind3292052")
1019             .setName("name3373707")
1020             .setOperationGroupId("operationGroupId1716161683")
1021             .setOperationType("operationType91999553")
1022             .setProgress(-1001078227)
1023             .setRegion("region-934795532")
1024             .setSelfLink("selfLink1191800166")
1025             .setStartTime("startTime-2129294769")
1026             .setStatus(Status.DONE)
1027             .setStatusMessage("statusMessage-958704715")
1028             .setTargetId(-815576439)
1029             .setTargetLink("targetLink486368555")
1030             .setUser("user3599307")
1031             .addAllWarnings(new ArrayList<Warnings>())
1032             .setZone("zone3744684")
1033             .build();
1034     mockService.addResponse(expectedResponse);
1035 
1036     String firewallPolicy = "firewallPolicy-6600";
1037 
1038     Operation actualResponse = client.removeRuleAsync(firewallPolicy).get();
1039     Assert.assertEquals(expectedResponse, actualResponse);
1040 
1041     List<String> actualRequests = mockService.getRequestPaths();
1042     Assert.assertEquals(1, actualRequests.size());
1043 
1044     String apiClientHeaderKey =
1045         mockService
1046             .getRequestHeaders()
1047             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1048             .iterator()
1049             .next();
1050     Assert.assertTrue(
1051         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1052             .matcher(apiClientHeaderKey)
1053             .matches());
1054   }
1055 
1056   @Test
removeRuleExceptionTest()1057   public void removeRuleExceptionTest() throws Exception {
1058     ApiException exception =
1059         ApiExceptionFactory.createException(
1060             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1061     mockService.addException(exception);
1062 
1063     try {
1064       String firewallPolicy = "firewallPolicy-6600";
1065       client.removeRuleAsync(firewallPolicy).get();
1066       Assert.fail("No exception raised");
1067     } catch (ExecutionException e) {
1068     }
1069   }
1070 
1071   @Test
setIamPolicyTest()1072   public void setIamPolicyTest() throws Exception {
1073     Policy expectedResponse =
1074         Policy.newBuilder()
1075             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1076             .addAllBindings(new ArrayList<Binding>())
1077             .setEtag("etag3123477")
1078             .setIamOwned(true)
1079             .addAllRules(new ArrayList<Rule>())
1080             .setVersion(351608024)
1081             .build();
1082     mockService.addResponse(expectedResponse);
1083 
1084     String resource = "resource-756";
1085     GlobalOrganizationSetPolicyRequest globalOrganizationSetPolicyRequestResource =
1086         GlobalOrganizationSetPolicyRequest.newBuilder().build();
1087 
1088     Policy actualResponse =
1089         client.setIamPolicy(resource, globalOrganizationSetPolicyRequestResource);
1090     Assert.assertEquals(expectedResponse, actualResponse);
1091 
1092     List<String> actualRequests = mockService.getRequestPaths();
1093     Assert.assertEquals(1, actualRequests.size());
1094 
1095     String apiClientHeaderKey =
1096         mockService
1097             .getRequestHeaders()
1098             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1099             .iterator()
1100             .next();
1101     Assert.assertTrue(
1102         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1103             .matcher(apiClientHeaderKey)
1104             .matches());
1105   }
1106 
1107   @Test
setIamPolicyExceptionTest()1108   public void setIamPolicyExceptionTest() throws Exception {
1109     ApiException exception =
1110         ApiExceptionFactory.createException(
1111             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1112     mockService.addException(exception);
1113 
1114     try {
1115       String resource = "resource-756";
1116       GlobalOrganizationSetPolicyRequest globalOrganizationSetPolicyRequestResource =
1117           GlobalOrganizationSetPolicyRequest.newBuilder().build();
1118       client.setIamPolicy(resource, globalOrganizationSetPolicyRequestResource);
1119       Assert.fail("No exception raised");
1120     } catch (InvalidArgumentException e) {
1121       // Expected exception.
1122     }
1123   }
1124 
1125   @Test
testIamPermissionsTest()1126   public void testIamPermissionsTest() throws Exception {
1127     TestPermissionsResponse expectedResponse =
1128         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1129     mockService.addResponse(expectedResponse);
1130 
1131     String resource = "resource-756";
1132     TestPermissionsRequest testPermissionsRequestResource =
1133         TestPermissionsRequest.newBuilder().build();
1134 
1135     TestPermissionsResponse actualResponse =
1136         client.testIamPermissions(resource, testPermissionsRequestResource);
1137     Assert.assertEquals(expectedResponse, actualResponse);
1138 
1139     List<String> actualRequests = mockService.getRequestPaths();
1140     Assert.assertEquals(1, actualRequests.size());
1141 
1142     String apiClientHeaderKey =
1143         mockService
1144             .getRequestHeaders()
1145             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1146             .iterator()
1147             .next();
1148     Assert.assertTrue(
1149         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1150             .matcher(apiClientHeaderKey)
1151             .matches());
1152   }
1153 
1154   @Test
testIamPermissionsExceptionTest()1155   public void testIamPermissionsExceptionTest() throws Exception {
1156     ApiException exception =
1157         ApiExceptionFactory.createException(
1158             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1159     mockService.addException(exception);
1160 
1161     try {
1162       String resource = "resource-756";
1163       TestPermissionsRequest testPermissionsRequestResource =
1164           TestPermissionsRequest.newBuilder().build();
1165       client.testIamPermissions(resource, testPermissionsRequestResource);
1166       Assert.fail("No exception raised");
1167     } catch (InvalidArgumentException e) {
1168       // Expected exception.
1169     }
1170   }
1171 }
1172