• 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.SecurityPoliciesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.SecurityPoliciesClient.ListPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.cloud.compute.v1.Operation.Status;
32 import com.google.cloud.compute.v1.stub.HttpJsonSecurityPoliciesStub;
33 import com.google.common.collect.Lists;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.Collections;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.concurrent.ExecutionException;
41 import javax.annotation.Generated;
42 import org.junit.After;
43 import org.junit.AfterClass;
44 import org.junit.Assert;
45 import org.junit.Before;
46 import org.junit.BeforeClass;
47 import org.junit.Test;
48 
49 @Generated("by gapic-generator-java")
50 public class SecurityPoliciesClientTest {
51   private static MockHttpService mockService;
52   private static SecurityPoliciesClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonSecurityPoliciesStub.getMethodDescriptors(),
59             SecurityPoliciesSettings.getDefaultEndpoint());
60     SecurityPoliciesSettings settings =
61         SecurityPoliciesSettings.newBuilder()
62             .setTransportChannelProvider(
63                 SecurityPoliciesSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = SecurityPoliciesClient.create(settings);
69   }
70 
71   @AfterClass
stopServer()72   public static void stopServer() {
73     client.close();
74   }
75 
76   @Before
setUp()77   public void setUp() {}
78 
79   @After
tearDown()80   public void tearDown() throws Exception {
81     mockService.reset();
82   }
83 
84   @Test
addRuleTest()85   public void addRuleTest() throws Exception {
86     Operation expectedResponse =
87         Operation.newBuilder()
88             .setClientOperationId("clientOperationId-1230366697")
89             .setCreationTimestamp("creationTimestamp-370203401")
90             .setDescription("description-1724546052")
91             .setEndTime("endTime-1607243192")
92             .setError(Error.newBuilder().build())
93             .setHttpErrorMessage("httpErrorMessage1577303431")
94             .setHttpErrorStatusCode(0)
95             .setId(3355)
96             .setInsertTime("insertTime966165798")
97             .setKind("kind3292052")
98             .setName("name3373707")
99             .setOperationGroupId("operationGroupId1716161683")
100             .setOperationType("operationType91999553")
101             .setProgress(-1001078227)
102             .setRegion("region-934795532")
103             .setSelfLink("selfLink1191800166")
104             .setStartTime("startTime-2129294769")
105             .setStatus(Status.DONE)
106             .setStatusMessage("statusMessage-958704715")
107             .setTargetId(-815576439)
108             .setTargetLink("targetLink486368555")
109             .setUser("user3599307")
110             .addAllWarnings(new ArrayList<Warnings>())
111             .setZone("zone3744684")
112             .build();
113     mockService.addResponse(expectedResponse);
114 
115     String project = "project-6911";
116     String securityPolicy = "securityPolicy-7672";
117     SecurityPolicyRule securityPolicyRuleResource = SecurityPolicyRule.newBuilder().build();
118 
119     Operation actualResponse =
120         client.addRuleAsync(project, securityPolicy, securityPolicyRuleResource).get();
121     Assert.assertEquals(expectedResponse, actualResponse);
122 
123     List<String> actualRequests = mockService.getRequestPaths();
124     Assert.assertEquals(1, actualRequests.size());
125 
126     String apiClientHeaderKey =
127         mockService
128             .getRequestHeaders()
129             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
130             .iterator()
131             .next();
132     Assert.assertTrue(
133         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
134             .matcher(apiClientHeaderKey)
135             .matches());
136   }
137 
138   @Test
addRuleExceptionTest()139   public void addRuleExceptionTest() throws Exception {
140     ApiException exception =
141         ApiExceptionFactory.createException(
142             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
143     mockService.addException(exception);
144 
145     try {
146       String project = "project-6911";
147       String securityPolicy = "securityPolicy-7672";
148       SecurityPolicyRule securityPolicyRuleResource = SecurityPolicyRule.newBuilder().build();
149       client.addRuleAsync(project, securityPolicy, securityPolicyRuleResource).get();
150       Assert.fail("No exception raised");
151     } catch (ExecutionException e) {
152     }
153   }
154 
155   @Test
aggregatedListTest()156   public void aggregatedListTest() throws Exception {
157     SecurityPoliciesScopedList responsesElement = SecurityPoliciesScopedList.newBuilder().build();
158     SecurityPoliciesAggregatedList expectedResponse =
159         SecurityPoliciesAggregatedList.newBuilder()
160             .setNextPageToken("")
161             .putAllItems(Collections.singletonMap("items", responsesElement))
162             .build();
163     mockService.addResponse(expectedResponse);
164 
165     String project = "project-6911";
166 
167     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
168 
169     List<Map.Entry<String, SecurityPoliciesScopedList>> resources =
170         Lists.newArrayList(pagedListResponse.iterateAll());
171 
172     Assert.assertEquals(1, resources.size());
173     Assert.assertEquals(
174         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
175 
176     List<String> actualRequests = mockService.getRequestPaths();
177     Assert.assertEquals(1, actualRequests.size());
178 
179     String apiClientHeaderKey =
180         mockService
181             .getRequestHeaders()
182             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
183             .iterator()
184             .next();
185     Assert.assertTrue(
186         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
187             .matcher(apiClientHeaderKey)
188             .matches());
189   }
190 
191   @Test
aggregatedListExceptionTest()192   public void aggregatedListExceptionTest() throws Exception {
193     ApiException exception =
194         ApiExceptionFactory.createException(
195             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
196     mockService.addException(exception);
197 
198     try {
199       String project = "project-6911";
200       client.aggregatedList(project);
201       Assert.fail("No exception raised");
202     } catch (InvalidArgumentException e) {
203       // Expected exception.
204     }
205   }
206 
207   @Test
deleteTest()208   public void deleteTest() throws Exception {
209     Operation expectedResponse =
210         Operation.newBuilder()
211             .setClientOperationId("clientOperationId-1230366697")
212             .setCreationTimestamp("creationTimestamp-370203401")
213             .setDescription("description-1724546052")
214             .setEndTime("endTime-1607243192")
215             .setError(Error.newBuilder().build())
216             .setHttpErrorMessage("httpErrorMessage1577303431")
217             .setHttpErrorStatusCode(0)
218             .setId(3355)
219             .setInsertTime("insertTime966165798")
220             .setKind("kind3292052")
221             .setName("name3373707")
222             .setOperationGroupId("operationGroupId1716161683")
223             .setOperationType("operationType91999553")
224             .setProgress(-1001078227)
225             .setRegion("region-934795532")
226             .setSelfLink("selfLink1191800166")
227             .setStartTime("startTime-2129294769")
228             .setStatus(Status.DONE)
229             .setStatusMessage("statusMessage-958704715")
230             .setTargetId(-815576439)
231             .setTargetLink("targetLink486368555")
232             .setUser("user3599307")
233             .addAllWarnings(new ArrayList<Warnings>())
234             .setZone("zone3744684")
235             .build();
236     mockService.addResponse(expectedResponse);
237 
238     String project = "project-6911";
239     String securityPolicy = "securityPolicy-7672";
240 
241     Operation actualResponse = client.deleteAsync(project, securityPolicy).get();
242     Assert.assertEquals(expectedResponse, actualResponse);
243 
244     List<String> actualRequests = mockService.getRequestPaths();
245     Assert.assertEquals(1, actualRequests.size());
246 
247     String apiClientHeaderKey =
248         mockService
249             .getRequestHeaders()
250             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
251             .iterator()
252             .next();
253     Assert.assertTrue(
254         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
255             .matcher(apiClientHeaderKey)
256             .matches());
257   }
258 
259   @Test
deleteExceptionTest()260   public void deleteExceptionTest() throws Exception {
261     ApiException exception =
262         ApiExceptionFactory.createException(
263             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
264     mockService.addException(exception);
265 
266     try {
267       String project = "project-6911";
268       String securityPolicy = "securityPolicy-7672";
269       client.deleteAsync(project, securityPolicy).get();
270       Assert.fail("No exception raised");
271     } catch (ExecutionException e) {
272     }
273   }
274 
275   @Test
getTest()276   public void getTest() throws Exception {
277     SecurityPolicy expectedResponse =
278         SecurityPolicy.newBuilder()
279             .setAdaptiveProtectionConfig(
280                 SecurityPolicyAdaptiveProtectionConfig.newBuilder().build())
281             .setAdvancedOptionsConfig(SecurityPolicyAdvancedOptionsConfig.newBuilder().build())
282             .setCreationTimestamp("creationTimestamp-370203401")
283             .setDdosProtectionConfig(SecurityPolicyDdosProtectionConfig.newBuilder().build())
284             .setDescription("description-1724546052")
285             .setFingerprint("fingerprint-1375934236")
286             .setId(3355)
287             .setKind("kind3292052")
288             .setName("name3373707")
289             .setRecaptchaOptionsConfig(SecurityPolicyRecaptchaOptionsConfig.newBuilder().build())
290             .setRegion("region-934795532")
291             .addAllRules(new ArrayList<SecurityPolicyRule>())
292             .setSelfLink("selfLink1191800166")
293             .setType("type3575610")
294             .build();
295     mockService.addResponse(expectedResponse);
296 
297     String project = "project-6911";
298     String securityPolicy = "securityPolicy-7672";
299 
300     SecurityPolicy actualResponse = client.get(project, securityPolicy);
301     Assert.assertEquals(expectedResponse, actualResponse);
302 
303     List<String> actualRequests = mockService.getRequestPaths();
304     Assert.assertEquals(1, actualRequests.size());
305 
306     String apiClientHeaderKey =
307         mockService
308             .getRequestHeaders()
309             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
310             .iterator()
311             .next();
312     Assert.assertTrue(
313         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
314             .matcher(apiClientHeaderKey)
315             .matches());
316   }
317 
318   @Test
getExceptionTest()319   public void getExceptionTest() throws Exception {
320     ApiException exception =
321         ApiExceptionFactory.createException(
322             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
323     mockService.addException(exception);
324 
325     try {
326       String project = "project-6911";
327       String securityPolicy = "securityPolicy-7672";
328       client.get(project, securityPolicy);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
getRuleTest()336   public void getRuleTest() throws Exception {
337     SecurityPolicyRule expectedResponse =
338         SecurityPolicyRule.newBuilder()
339             .setAction("action-1422950858")
340             .setDescription("description-1724546052")
341             .setHeaderAction(SecurityPolicyRuleHttpHeaderAction.newBuilder().build())
342             .setKind("kind3292052")
343             .setMatch(SecurityPolicyRuleMatcher.newBuilder().build())
344             .setPreconfiguredWafConfig(
345                 SecurityPolicyRulePreconfiguredWafConfig.newBuilder().build())
346             .setPreview(true)
347             .setPriority(-1165461084)
348             .setRateLimitOptions(SecurityPolicyRuleRateLimitOptions.newBuilder().build())
349             .setRedirectOptions(SecurityPolicyRuleRedirectOptions.newBuilder().build())
350             .build();
351     mockService.addResponse(expectedResponse);
352 
353     String project = "project-6911";
354     String securityPolicy = "securityPolicy-7672";
355 
356     SecurityPolicyRule actualResponse = client.getRule(project, securityPolicy);
357     Assert.assertEquals(expectedResponse, actualResponse);
358 
359     List<String> actualRequests = mockService.getRequestPaths();
360     Assert.assertEquals(1, actualRequests.size());
361 
362     String apiClientHeaderKey =
363         mockService
364             .getRequestHeaders()
365             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
366             .iterator()
367             .next();
368     Assert.assertTrue(
369         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
370             .matcher(apiClientHeaderKey)
371             .matches());
372   }
373 
374   @Test
getRuleExceptionTest()375   public void getRuleExceptionTest() throws Exception {
376     ApiException exception =
377         ApiExceptionFactory.createException(
378             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
379     mockService.addException(exception);
380 
381     try {
382       String project = "project-6911";
383       String securityPolicy = "securityPolicy-7672";
384       client.getRule(project, securityPolicy);
385       Assert.fail("No exception raised");
386     } catch (InvalidArgumentException e) {
387       // Expected exception.
388     }
389   }
390 
391   @Test
insertTest()392   public void insertTest() throws Exception {
393     Operation expectedResponse =
394         Operation.newBuilder()
395             .setClientOperationId("clientOperationId-1230366697")
396             .setCreationTimestamp("creationTimestamp-370203401")
397             .setDescription("description-1724546052")
398             .setEndTime("endTime-1607243192")
399             .setError(Error.newBuilder().build())
400             .setHttpErrorMessage("httpErrorMessage1577303431")
401             .setHttpErrorStatusCode(0)
402             .setId(3355)
403             .setInsertTime("insertTime966165798")
404             .setKind("kind3292052")
405             .setName("name3373707")
406             .setOperationGroupId("operationGroupId1716161683")
407             .setOperationType("operationType91999553")
408             .setProgress(-1001078227)
409             .setRegion("region-934795532")
410             .setSelfLink("selfLink1191800166")
411             .setStartTime("startTime-2129294769")
412             .setStatus(Status.DONE)
413             .setStatusMessage("statusMessage-958704715")
414             .setTargetId(-815576439)
415             .setTargetLink("targetLink486368555")
416             .setUser("user3599307")
417             .addAllWarnings(new ArrayList<Warnings>())
418             .setZone("zone3744684")
419             .build();
420     mockService.addResponse(expectedResponse);
421 
422     String project = "project-6911";
423     SecurityPolicy securityPolicyResource = SecurityPolicy.newBuilder().build();
424 
425     Operation actualResponse = client.insertAsync(project, securityPolicyResource).get();
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
insertExceptionTest()444   public void insertExceptionTest() 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 project = "project-6911";
452       SecurityPolicy securityPolicyResource = SecurityPolicy.newBuilder().build();
453       client.insertAsync(project, securityPolicyResource).get();
454       Assert.fail("No exception raised");
455     } catch (ExecutionException e) {
456     }
457   }
458 
459   @Test
listTest()460   public void listTest() throws Exception {
461     SecurityPolicy responsesElement = SecurityPolicy.newBuilder().build();
462     SecurityPolicyList expectedResponse =
463         SecurityPolicyList.newBuilder()
464             .setNextPageToken("")
465             .addAllItems(Arrays.asList(responsesElement))
466             .build();
467     mockService.addResponse(expectedResponse);
468 
469     String project = "project-6911";
470 
471     ListPagedResponse pagedListResponse = client.list(project);
472 
473     List<SecurityPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
474 
475     Assert.assertEquals(1, resources.size());
476     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
477 
478     List<String> actualRequests = mockService.getRequestPaths();
479     Assert.assertEquals(1, actualRequests.size());
480 
481     String apiClientHeaderKey =
482         mockService
483             .getRequestHeaders()
484             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
485             .iterator()
486             .next();
487     Assert.assertTrue(
488         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
489             .matcher(apiClientHeaderKey)
490             .matches());
491   }
492 
493   @Test
listExceptionTest()494   public void listExceptionTest() throws Exception {
495     ApiException exception =
496         ApiExceptionFactory.createException(
497             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
498     mockService.addException(exception);
499 
500     try {
501       String project = "project-6911";
502       client.list(project);
503       Assert.fail("No exception raised");
504     } catch (InvalidArgumentException e) {
505       // Expected exception.
506     }
507   }
508 
509   @Test
listPreconfiguredExpressionSetsTest()510   public void listPreconfiguredExpressionSetsTest() throws Exception {
511     SecurityPoliciesListPreconfiguredExpressionSetsResponse expectedResponse =
512         SecurityPoliciesListPreconfiguredExpressionSetsResponse.newBuilder()
513             .setPreconfiguredExpressionSets(SecurityPoliciesWafConfig.newBuilder().build())
514             .build();
515     mockService.addResponse(expectedResponse);
516 
517     String project = "project-6911";
518 
519     SecurityPoliciesListPreconfiguredExpressionSetsResponse actualResponse =
520         client.listPreconfiguredExpressionSets(project);
521     Assert.assertEquals(expectedResponse, actualResponse);
522 
523     List<String> actualRequests = mockService.getRequestPaths();
524     Assert.assertEquals(1, actualRequests.size());
525 
526     String apiClientHeaderKey =
527         mockService
528             .getRequestHeaders()
529             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
530             .iterator()
531             .next();
532     Assert.assertTrue(
533         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
534             .matcher(apiClientHeaderKey)
535             .matches());
536   }
537 
538   @Test
listPreconfiguredExpressionSetsExceptionTest()539   public void listPreconfiguredExpressionSetsExceptionTest() throws Exception {
540     ApiException exception =
541         ApiExceptionFactory.createException(
542             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
543     mockService.addException(exception);
544 
545     try {
546       String project = "project-6911";
547       client.listPreconfiguredExpressionSets(project);
548       Assert.fail("No exception raised");
549     } catch (InvalidArgumentException e) {
550       // Expected exception.
551     }
552   }
553 
554   @Test
patchTest()555   public void patchTest() throws Exception {
556     Operation expectedResponse =
557         Operation.newBuilder()
558             .setClientOperationId("clientOperationId-1230366697")
559             .setCreationTimestamp("creationTimestamp-370203401")
560             .setDescription("description-1724546052")
561             .setEndTime("endTime-1607243192")
562             .setError(Error.newBuilder().build())
563             .setHttpErrorMessage("httpErrorMessage1577303431")
564             .setHttpErrorStatusCode(0)
565             .setId(3355)
566             .setInsertTime("insertTime966165798")
567             .setKind("kind3292052")
568             .setName("name3373707")
569             .setOperationGroupId("operationGroupId1716161683")
570             .setOperationType("operationType91999553")
571             .setProgress(-1001078227)
572             .setRegion("region-934795532")
573             .setSelfLink("selfLink1191800166")
574             .setStartTime("startTime-2129294769")
575             .setStatus(Status.DONE)
576             .setStatusMessage("statusMessage-958704715")
577             .setTargetId(-815576439)
578             .setTargetLink("targetLink486368555")
579             .setUser("user3599307")
580             .addAllWarnings(new ArrayList<Warnings>())
581             .setZone("zone3744684")
582             .build();
583     mockService.addResponse(expectedResponse);
584 
585     String project = "project-6911";
586     String securityPolicy = "securityPolicy-7672";
587     SecurityPolicy securityPolicyResource = SecurityPolicy.newBuilder().build();
588 
589     Operation actualResponse =
590         client.patchAsync(project, securityPolicy, securityPolicyResource).get();
591     Assert.assertEquals(expectedResponse, actualResponse);
592 
593     List<String> actualRequests = mockService.getRequestPaths();
594     Assert.assertEquals(1, actualRequests.size());
595 
596     String apiClientHeaderKey =
597         mockService
598             .getRequestHeaders()
599             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
600             .iterator()
601             .next();
602     Assert.assertTrue(
603         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
604             .matcher(apiClientHeaderKey)
605             .matches());
606   }
607 
608   @Test
patchExceptionTest()609   public void patchExceptionTest() throws Exception {
610     ApiException exception =
611         ApiExceptionFactory.createException(
612             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
613     mockService.addException(exception);
614 
615     try {
616       String project = "project-6911";
617       String securityPolicy = "securityPolicy-7672";
618       SecurityPolicy securityPolicyResource = SecurityPolicy.newBuilder().build();
619       client.patchAsync(project, securityPolicy, securityPolicyResource).get();
620       Assert.fail("No exception raised");
621     } catch (ExecutionException e) {
622     }
623   }
624 
625   @Test
patchRuleTest()626   public void patchRuleTest() throws Exception {
627     Operation expectedResponse =
628         Operation.newBuilder()
629             .setClientOperationId("clientOperationId-1230366697")
630             .setCreationTimestamp("creationTimestamp-370203401")
631             .setDescription("description-1724546052")
632             .setEndTime("endTime-1607243192")
633             .setError(Error.newBuilder().build())
634             .setHttpErrorMessage("httpErrorMessage1577303431")
635             .setHttpErrorStatusCode(0)
636             .setId(3355)
637             .setInsertTime("insertTime966165798")
638             .setKind("kind3292052")
639             .setName("name3373707")
640             .setOperationGroupId("operationGroupId1716161683")
641             .setOperationType("operationType91999553")
642             .setProgress(-1001078227)
643             .setRegion("region-934795532")
644             .setSelfLink("selfLink1191800166")
645             .setStartTime("startTime-2129294769")
646             .setStatus(Status.DONE)
647             .setStatusMessage("statusMessage-958704715")
648             .setTargetId(-815576439)
649             .setTargetLink("targetLink486368555")
650             .setUser("user3599307")
651             .addAllWarnings(new ArrayList<Warnings>())
652             .setZone("zone3744684")
653             .build();
654     mockService.addResponse(expectedResponse);
655 
656     String project = "project-6911";
657     String securityPolicy = "securityPolicy-7672";
658     SecurityPolicyRule securityPolicyRuleResource = SecurityPolicyRule.newBuilder().build();
659 
660     Operation actualResponse =
661         client.patchRuleAsync(project, securityPolicy, securityPolicyRuleResource).get();
662     Assert.assertEquals(expectedResponse, actualResponse);
663 
664     List<String> actualRequests = mockService.getRequestPaths();
665     Assert.assertEquals(1, actualRequests.size());
666 
667     String apiClientHeaderKey =
668         mockService
669             .getRequestHeaders()
670             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
671             .iterator()
672             .next();
673     Assert.assertTrue(
674         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
675             .matcher(apiClientHeaderKey)
676             .matches());
677   }
678 
679   @Test
patchRuleExceptionTest()680   public void patchRuleExceptionTest() throws Exception {
681     ApiException exception =
682         ApiExceptionFactory.createException(
683             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
684     mockService.addException(exception);
685 
686     try {
687       String project = "project-6911";
688       String securityPolicy = "securityPolicy-7672";
689       SecurityPolicyRule securityPolicyRuleResource = SecurityPolicyRule.newBuilder().build();
690       client.patchRuleAsync(project, securityPolicy, securityPolicyRuleResource).get();
691       Assert.fail("No exception raised");
692     } catch (ExecutionException e) {
693     }
694   }
695 
696   @Test
removeRuleTest()697   public void removeRuleTest() throws Exception {
698     Operation expectedResponse =
699         Operation.newBuilder()
700             .setClientOperationId("clientOperationId-1230366697")
701             .setCreationTimestamp("creationTimestamp-370203401")
702             .setDescription("description-1724546052")
703             .setEndTime("endTime-1607243192")
704             .setError(Error.newBuilder().build())
705             .setHttpErrorMessage("httpErrorMessage1577303431")
706             .setHttpErrorStatusCode(0)
707             .setId(3355)
708             .setInsertTime("insertTime966165798")
709             .setKind("kind3292052")
710             .setName("name3373707")
711             .setOperationGroupId("operationGroupId1716161683")
712             .setOperationType("operationType91999553")
713             .setProgress(-1001078227)
714             .setRegion("region-934795532")
715             .setSelfLink("selfLink1191800166")
716             .setStartTime("startTime-2129294769")
717             .setStatus(Status.DONE)
718             .setStatusMessage("statusMessage-958704715")
719             .setTargetId(-815576439)
720             .setTargetLink("targetLink486368555")
721             .setUser("user3599307")
722             .addAllWarnings(new ArrayList<Warnings>())
723             .setZone("zone3744684")
724             .build();
725     mockService.addResponse(expectedResponse);
726 
727     String project = "project-6911";
728     String securityPolicy = "securityPolicy-7672";
729 
730     Operation actualResponse = client.removeRuleAsync(project, securityPolicy).get();
731     Assert.assertEquals(expectedResponse, actualResponse);
732 
733     List<String> actualRequests = mockService.getRequestPaths();
734     Assert.assertEquals(1, actualRequests.size());
735 
736     String apiClientHeaderKey =
737         mockService
738             .getRequestHeaders()
739             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
740             .iterator()
741             .next();
742     Assert.assertTrue(
743         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
744             .matcher(apiClientHeaderKey)
745             .matches());
746   }
747 
748   @Test
removeRuleExceptionTest()749   public void removeRuleExceptionTest() throws Exception {
750     ApiException exception =
751         ApiExceptionFactory.createException(
752             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
753     mockService.addException(exception);
754 
755     try {
756       String project = "project-6911";
757       String securityPolicy = "securityPolicy-7672";
758       client.removeRuleAsync(project, securityPolicy).get();
759       Assert.fail("No exception raised");
760     } catch (ExecutionException e) {
761     }
762   }
763 
764   @Test
setLabelsTest()765   public void setLabelsTest() throws Exception {
766     Operation expectedResponse =
767         Operation.newBuilder()
768             .setClientOperationId("clientOperationId-1230366697")
769             .setCreationTimestamp("creationTimestamp-370203401")
770             .setDescription("description-1724546052")
771             .setEndTime("endTime-1607243192")
772             .setError(Error.newBuilder().build())
773             .setHttpErrorMessage("httpErrorMessage1577303431")
774             .setHttpErrorStatusCode(0)
775             .setId(3355)
776             .setInsertTime("insertTime966165798")
777             .setKind("kind3292052")
778             .setName("name3373707")
779             .setOperationGroupId("operationGroupId1716161683")
780             .setOperationType("operationType91999553")
781             .setProgress(-1001078227)
782             .setRegion("region-934795532")
783             .setSelfLink("selfLink1191800166")
784             .setStartTime("startTime-2129294769")
785             .setStatus(Status.DONE)
786             .setStatusMessage("statusMessage-958704715")
787             .setTargetId(-815576439)
788             .setTargetLink("targetLink486368555")
789             .setUser("user3599307")
790             .addAllWarnings(new ArrayList<Warnings>())
791             .setZone("zone3744684")
792             .build();
793     mockService.addResponse(expectedResponse);
794 
795     String project = "project-6911";
796     String resource = "resource-756";
797     GlobalSetLabelsRequest globalSetLabelsRequestResource =
798         GlobalSetLabelsRequest.newBuilder().build();
799 
800     Operation actualResponse =
801         client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
802     Assert.assertEquals(expectedResponse, actualResponse);
803 
804     List<String> actualRequests = mockService.getRequestPaths();
805     Assert.assertEquals(1, actualRequests.size());
806 
807     String apiClientHeaderKey =
808         mockService
809             .getRequestHeaders()
810             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
811             .iterator()
812             .next();
813     Assert.assertTrue(
814         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
815             .matcher(apiClientHeaderKey)
816             .matches());
817   }
818 
819   @Test
setLabelsExceptionTest()820   public void setLabelsExceptionTest() throws Exception {
821     ApiException exception =
822         ApiExceptionFactory.createException(
823             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
824     mockService.addException(exception);
825 
826     try {
827       String project = "project-6911";
828       String resource = "resource-756";
829       GlobalSetLabelsRequest globalSetLabelsRequestResource =
830           GlobalSetLabelsRequest.newBuilder().build();
831       client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
832       Assert.fail("No exception raised");
833     } catch (ExecutionException e) {
834     }
835   }
836 }
837