• 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.orgpolicy.v2;
18 
19 import static com.google.cloud.orgpolicy.v2.OrgPolicyClient.ListConstraintsPagedResponse;
20 import static com.google.cloud.orgpolicy.v2.OrgPolicyClient.ListPoliciesPagedResponse;
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.orgpolicy.v2.stub.HttpJsonOrgPolicyStub;
32 import com.google.common.collect.Lists;
33 import com.google.protobuf.Empty;
34 import java.io.IOException;
35 import java.util.Arrays;
36 import java.util.List;
37 import javax.annotation.Generated;
38 import org.junit.After;
39 import org.junit.AfterClass;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.BeforeClass;
43 import org.junit.Test;
44 
45 @Generated("by gapic-generator-java")
46 public class OrgPolicyClientHttpJsonTest {
47   private static MockHttpService mockService;
48   private static OrgPolicyClient client;
49 
50   @BeforeClass
startStaticServer()51   public static void startStaticServer() throws IOException {
52     mockService =
53         new MockHttpService(
54             HttpJsonOrgPolicyStub.getMethodDescriptors(), OrgPolicySettings.getDefaultEndpoint());
55     OrgPolicySettings settings =
56         OrgPolicySettings.newHttpJsonBuilder()
57             .setTransportChannelProvider(
58                 OrgPolicySettings.defaultHttpJsonTransportProviderBuilder()
59                     .setHttpTransport(mockService)
60                     .build())
61             .setCredentialsProvider(NoCredentialsProvider.create())
62             .build();
63     client = OrgPolicyClient.create(settings);
64   }
65 
66   @AfterClass
stopServer()67   public static void stopServer() {
68     client.close();
69   }
70 
71   @Before
setUp()72   public void setUp() {}
73 
74   @After
tearDown()75   public void tearDown() throws Exception {
76     mockService.reset();
77   }
78 
79   @Test
listConstraintsTest()80   public void listConstraintsTest() throws Exception {
81     Constraint responsesElement = Constraint.newBuilder().build();
82     ListConstraintsResponse expectedResponse =
83         ListConstraintsResponse.newBuilder()
84             .setNextPageToken("")
85             .addAllConstraints(Arrays.asList(responsesElement))
86             .build();
87     mockService.addResponse(expectedResponse);
88 
89     FolderName parent = FolderName.of("[FOLDER]");
90 
91     ListConstraintsPagedResponse pagedListResponse = client.listConstraints(parent);
92 
93     List<Constraint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
94 
95     Assert.assertEquals(1, resources.size());
96     Assert.assertEquals(expectedResponse.getConstraintsList().get(0), resources.get(0));
97 
98     List<String> actualRequests = mockService.getRequestPaths();
99     Assert.assertEquals(1, actualRequests.size());
100 
101     String apiClientHeaderKey =
102         mockService
103             .getRequestHeaders()
104             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
105             .iterator()
106             .next();
107     Assert.assertTrue(
108         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
109             .matcher(apiClientHeaderKey)
110             .matches());
111   }
112 
113   @Test
listConstraintsExceptionTest()114   public void listConstraintsExceptionTest() throws Exception {
115     ApiException exception =
116         ApiExceptionFactory.createException(
117             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
118     mockService.addException(exception);
119 
120     try {
121       FolderName parent = FolderName.of("[FOLDER]");
122       client.listConstraints(parent);
123       Assert.fail("No exception raised");
124     } catch (InvalidArgumentException e) {
125       // Expected exception.
126     }
127   }
128 
129   @Test
listConstraintsTest2()130   public void listConstraintsTest2() throws Exception {
131     Constraint responsesElement = Constraint.newBuilder().build();
132     ListConstraintsResponse expectedResponse =
133         ListConstraintsResponse.newBuilder()
134             .setNextPageToken("")
135             .addAllConstraints(Arrays.asList(responsesElement))
136             .build();
137     mockService.addResponse(expectedResponse);
138 
139     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
140 
141     ListConstraintsPagedResponse pagedListResponse = client.listConstraints(parent);
142 
143     List<Constraint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
144 
145     Assert.assertEquals(1, resources.size());
146     Assert.assertEquals(expectedResponse.getConstraintsList().get(0), resources.get(0));
147 
148     List<String> actualRequests = mockService.getRequestPaths();
149     Assert.assertEquals(1, actualRequests.size());
150 
151     String apiClientHeaderKey =
152         mockService
153             .getRequestHeaders()
154             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
155             .iterator()
156             .next();
157     Assert.assertTrue(
158         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
159             .matcher(apiClientHeaderKey)
160             .matches());
161   }
162 
163   @Test
listConstraintsExceptionTest2()164   public void listConstraintsExceptionTest2() throws Exception {
165     ApiException exception =
166         ApiExceptionFactory.createException(
167             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
168     mockService.addException(exception);
169 
170     try {
171       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
172       client.listConstraints(parent);
173       Assert.fail("No exception raised");
174     } catch (InvalidArgumentException e) {
175       // Expected exception.
176     }
177   }
178 
179   @Test
listConstraintsTest3()180   public void listConstraintsTest3() throws Exception {
181     Constraint responsesElement = Constraint.newBuilder().build();
182     ListConstraintsResponse expectedResponse =
183         ListConstraintsResponse.newBuilder()
184             .setNextPageToken("")
185             .addAllConstraints(Arrays.asList(responsesElement))
186             .build();
187     mockService.addResponse(expectedResponse);
188 
189     ProjectName parent = ProjectName.of("[PROJECT]");
190 
191     ListConstraintsPagedResponse pagedListResponse = client.listConstraints(parent);
192 
193     List<Constraint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
194 
195     Assert.assertEquals(1, resources.size());
196     Assert.assertEquals(expectedResponse.getConstraintsList().get(0), resources.get(0));
197 
198     List<String> actualRequests = mockService.getRequestPaths();
199     Assert.assertEquals(1, actualRequests.size());
200 
201     String apiClientHeaderKey =
202         mockService
203             .getRequestHeaders()
204             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
205             .iterator()
206             .next();
207     Assert.assertTrue(
208         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
209             .matcher(apiClientHeaderKey)
210             .matches());
211   }
212 
213   @Test
listConstraintsExceptionTest3()214   public void listConstraintsExceptionTest3() throws Exception {
215     ApiException exception =
216         ApiExceptionFactory.createException(
217             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
218     mockService.addException(exception);
219 
220     try {
221       ProjectName parent = ProjectName.of("[PROJECT]");
222       client.listConstraints(parent);
223       Assert.fail("No exception raised");
224     } catch (InvalidArgumentException e) {
225       // Expected exception.
226     }
227   }
228 
229   @Test
listConstraintsTest4()230   public void listConstraintsTest4() throws Exception {
231     Constraint responsesElement = Constraint.newBuilder().build();
232     ListConstraintsResponse expectedResponse =
233         ListConstraintsResponse.newBuilder()
234             .setNextPageToken("")
235             .addAllConstraints(Arrays.asList(responsesElement))
236             .build();
237     mockService.addResponse(expectedResponse);
238 
239     String parent = "projects/project-2353";
240 
241     ListConstraintsPagedResponse pagedListResponse = client.listConstraints(parent);
242 
243     List<Constraint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
244 
245     Assert.assertEquals(1, resources.size());
246     Assert.assertEquals(expectedResponse.getConstraintsList().get(0), resources.get(0));
247 
248     List<String> actualRequests = mockService.getRequestPaths();
249     Assert.assertEquals(1, actualRequests.size());
250 
251     String apiClientHeaderKey =
252         mockService
253             .getRequestHeaders()
254             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
255             .iterator()
256             .next();
257     Assert.assertTrue(
258         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
259             .matcher(apiClientHeaderKey)
260             .matches());
261   }
262 
263   @Test
listConstraintsExceptionTest4()264   public void listConstraintsExceptionTest4() throws Exception {
265     ApiException exception =
266         ApiExceptionFactory.createException(
267             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
268     mockService.addException(exception);
269 
270     try {
271       String parent = "projects/project-2353";
272       client.listConstraints(parent);
273       Assert.fail("No exception raised");
274     } catch (InvalidArgumentException e) {
275       // Expected exception.
276     }
277   }
278 
279   @Test
listPoliciesTest()280   public void listPoliciesTest() throws Exception {
281     Policy responsesElement = Policy.newBuilder().build();
282     ListPoliciesResponse expectedResponse =
283         ListPoliciesResponse.newBuilder()
284             .setNextPageToken("")
285             .addAllPolicies(Arrays.asList(responsesElement))
286             .build();
287     mockService.addResponse(expectedResponse);
288 
289     FolderName parent = FolderName.of("[FOLDER]");
290 
291     ListPoliciesPagedResponse pagedListResponse = client.listPolicies(parent);
292 
293     List<Policy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
294 
295     Assert.assertEquals(1, resources.size());
296     Assert.assertEquals(expectedResponse.getPoliciesList().get(0), resources.get(0));
297 
298     List<String> actualRequests = mockService.getRequestPaths();
299     Assert.assertEquals(1, actualRequests.size());
300 
301     String apiClientHeaderKey =
302         mockService
303             .getRequestHeaders()
304             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
305             .iterator()
306             .next();
307     Assert.assertTrue(
308         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
309             .matcher(apiClientHeaderKey)
310             .matches());
311   }
312 
313   @Test
listPoliciesExceptionTest()314   public void listPoliciesExceptionTest() throws Exception {
315     ApiException exception =
316         ApiExceptionFactory.createException(
317             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
318     mockService.addException(exception);
319 
320     try {
321       FolderName parent = FolderName.of("[FOLDER]");
322       client.listPolicies(parent);
323       Assert.fail("No exception raised");
324     } catch (InvalidArgumentException e) {
325       // Expected exception.
326     }
327   }
328 
329   @Test
listPoliciesTest2()330   public void listPoliciesTest2() throws Exception {
331     Policy responsesElement = Policy.newBuilder().build();
332     ListPoliciesResponse expectedResponse =
333         ListPoliciesResponse.newBuilder()
334             .setNextPageToken("")
335             .addAllPolicies(Arrays.asList(responsesElement))
336             .build();
337     mockService.addResponse(expectedResponse);
338 
339     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
340 
341     ListPoliciesPagedResponse pagedListResponse = client.listPolicies(parent);
342 
343     List<Policy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
344 
345     Assert.assertEquals(1, resources.size());
346     Assert.assertEquals(expectedResponse.getPoliciesList().get(0), resources.get(0));
347 
348     List<String> actualRequests = mockService.getRequestPaths();
349     Assert.assertEquals(1, actualRequests.size());
350 
351     String apiClientHeaderKey =
352         mockService
353             .getRequestHeaders()
354             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
355             .iterator()
356             .next();
357     Assert.assertTrue(
358         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
359             .matcher(apiClientHeaderKey)
360             .matches());
361   }
362 
363   @Test
listPoliciesExceptionTest2()364   public void listPoliciesExceptionTest2() throws Exception {
365     ApiException exception =
366         ApiExceptionFactory.createException(
367             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
368     mockService.addException(exception);
369 
370     try {
371       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
372       client.listPolicies(parent);
373       Assert.fail("No exception raised");
374     } catch (InvalidArgumentException e) {
375       // Expected exception.
376     }
377   }
378 
379   @Test
listPoliciesTest3()380   public void listPoliciesTest3() throws Exception {
381     Policy responsesElement = Policy.newBuilder().build();
382     ListPoliciesResponse expectedResponse =
383         ListPoliciesResponse.newBuilder()
384             .setNextPageToken("")
385             .addAllPolicies(Arrays.asList(responsesElement))
386             .build();
387     mockService.addResponse(expectedResponse);
388 
389     ProjectName parent = ProjectName.of("[PROJECT]");
390 
391     ListPoliciesPagedResponse pagedListResponse = client.listPolicies(parent);
392 
393     List<Policy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
394 
395     Assert.assertEquals(1, resources.size());
396     Assert.assertEquals(expectedResponse.getPoliciesList().get(0), resources.get(0));
397 
398     List<String> actualRequests = mockService.getRequestPaths();
399     Assert.assertEquals(1, actualRequests.size());
400 
401     String apiClientHeaderKey =
402         mockService
403             .getRequestHeaders()
404             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
405             .iterator()
406             .next();
407     Assert.assertTrue(
408         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
409             .matcher(apiClientHeaderKey)
410             .matches());
411   }
412 
413   @Test
listPoliciesExceptionTest3()414   public void listPoliciesExceptionTest3() throws Exception {
415     ApiException exception =
416         ApiExceptionFactory.createException(
417             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
418     mockService.addException(exception);
419 
420     try {
421       ProjectName parent = ProjectName.of("[PROJECT]");
422       client.listPolicies(parent);
423       Assert.fail("No exception raised");
424     } catch (InvalidArgumentException e) {
425       // Expected exception.
426     }
427   }
428 
429   @Test
listPoliciesTest4()430   public void listPoliciesTest4() throws Exception {
431     Policy responsesElement = Policy.newBuilder().build();
432     ListPoliciesResponse expectedResponse =
433         ListPoliciesResponse.newBuilder()
434             .setNextPageToken("")
435             .addAllPolicies(Arrays.asList(responsesElement))
436             .build();
437     mockService.addResponse(expectedResponse);
438 
439     String parent = "projects/project-2353";
440 
441     ListPoliciesPagedResponse pagedListResponse = client.listPolicies(parent);
442 
443     List<Policy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
444 
445     Assert.assertEquals(1, resources.size());
446     Assert.assertEquals(expectedResponse.getPoliciesList().get(0), resources.get(0));
447 
448     List<String> actualRequests = mockService.getRequestPaths();
449     Assert.assertEquals(1, actualRequests.size());
450 
451     String apiClientHeaderKey =
452         mockService
453             .getRequestHeaders()
454             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
455             .iterator()
456             .next();
457     Assert.assertTrue(
458         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
459             .matcher(apiClientHeaderKey)
460             .matches());
461   }
462 
463   @Test
listPoliciesExceptionTest4()464   public void listPoliciesExceptionTest4() throws Exception {
465     ApiException exception =
466         ApiExceptionFactory.createException(
467             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
468     mockService.addException(exception);
469 
470     try {
471       String parent = "projects/project-2353";
472       client.listPolicies(parent);
473       Assert.fail("No exception raised");
474     } catch (InvalidArgumentException e) {
475       // Expected exception.
476     }
477   }
478 
479   @Test
getPolicyTest()480   public void getPolicyTest() throws Exception {
481     Policy expectedResponse =
482         Policy.newBuilder()
483             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
484             .setSpec(PolicySpec.newBuilder().build())
485             .setAlternate(AlternatePolicySpec.newBuilder().build())
486             .setDryRunSpec(PolicySpec.newBuilder().build())
487             .build();
488     mockService.addResponse(expectedResponse);
489 
490     PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
491 
492     Policy actualResponse = client.getPolicy(name);
493     Assert.assertEquals(expectedResponse, actualResponse);
494 
495     List<String> actualRequests = mockService.getRequestPaths();
496     Assert.assertEquals(1, actualRequests.size());
497 
498     String apiClientHeaderKey =
499         mockService
500             .getRequestHeaders()
501             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
502             .iterator()
503             .next();
504     Assert.assertTrue(
505         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
506             .matcher(apiClientHeaderKey)
507             .matches());
508   }
509 
510   @Test
getPolicyExceptionTest()511   public void getPolicyExceptionTest() throws Exception {
512     ApiException exception =
513         ApiExceptionFactory.createException(
514             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
515     mockService.addException(exception);
516 
517     try {
518       PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
519       client.getPolicy(name);
520       Assert.fail("No exception raised");
521     } catch (InvalidArgumentException e) {
522       // Expected exception.
523     }
524   }
525 
526   @Test
getPolicyTest2()527   public void getPolicyTest2() throws Exception {
528     Policy expectedResponse =
529         Policy.newBuilder()
530             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
531             .setSpec(PolicySpec.newBuilder().build())
532             .setAlternate(AlternatePolicySpec.newBuilder().build())
533             .setDryRunSpec(PolicySpec.newBuilder().build())
534             .build();
535     mockService.addResponse(expectedResponse);
536 
537     String name = "projects/project-3674/policies/policie-3674";
538 
539     Policy actualResponse = client.getPolicy(name);
540     Assert.assertEquals(expectedResponse, actualResponse);
541 
542     List<String> actualRequests = mockService.getRequestPaths();
543     Assert.assertEquals(1, actualRequests.size());
544 
545     String apiClientHeaderKey =
546         mockService
547             .getRequestHeaders()
548             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
549             .iterator()
550             .next();
551     Assert.assertTrue(
552         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
553             .matcher(apiClientHeaderKey)
554             .matches());
555   }
556 
557   @Test
getPolicyExceptionTest2()558   public void getPolicyExceptionTest2() throws Exception {
559     ApiException exception =
560         ApiExceptionFactory.createException(
561             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
562     mockService.addException(exception);
563 
564     try {
565       String name = "projects/project-3674/policies/policie-3674";
566       client.getPolicy(name);
567       Assert.fail("No exception raised");
568     } catch (InvalidArgumentException e) {
569       // Expected exception.
570     }
571   }
572 
573   @Test
getEffectivePolicyTest()574   public void getEffectivePolicyTest() throws Exception {
575     Policy expectedResponse =
576         Policy.newBuilder()
577             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
578             .setSpec(PolicySpec.newBuilder().build())
579             .setAlternate(AlternatePolicySpec.newBuilder().build())
580             .setDryRunSpec(PolicySpec.newBuilder().build())
581             .build();
582     mockService.addResponse(expectedResponse);
583 
584     PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
585 
586     Policy actualResponse = client.getEffectivePolicy(name);
587     Assert.assertEquals(expectedResponse, actualResponse);
588 
589     List<String> actualRequests = mockService.getRequestPaths();
590     Assert.assertEquals(1, actualRequests.size());
591 
592     String apiClientHeaderKey =
593         mockService
594             .getRequestHeaders()
595             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
596             .iterator()
597             .next();
598     Assert.assertTrue(
599         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
600             .matcher(apiClientHeaderKey)
601             .matches());
602   }
603 
604   @Test
getEffectivePolicyExceptionTest()605   public void getEffectivePolicyExceptionTest() throws Exception {
606     ApiException exception =
607         ApiExceptionFactory.createException(
608             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
609     mockService.addException(exception);
610 
611     try {
612       PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
613       client.getEffectivePolicy(name);
614       Assert.fail("No exception raised");
615     } catch (InvalidArgumentException e) {
616       // Expected exception.
617     }
618   }
619 
620   @Test
getEffectivePolicyTest2()621   public void getEffectivePolicyTest2() throws Exception {
622     Policy expectedResponse =
623         Policy.newBuilder()
624             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
625             .setSpec(PolicySpec.newBuilder().build())
626             .setAlternate(AlternatePolicySpec.newBuilder().build())
627             .setDryRunSpec(PolicySpec.newBuilder().build())
628             .build();
629     mockService.addResponse(expectedResponse);
630 
631     String name = "projects/project-3674/policies/policie-3674";
632 
633     Policy actualResponse = client.getEffectivePolicy(name);
634     Assert.assertEquals(expectedResponse, actualResponse);
635 
636     List<String> actualRequests = mockService.getRequestPaths();
637     Assert.assertEquals(1, actualRequests.size());
638 
639     String apiClientHeaderKey =
640         mockService
641             .getRequestHeaders()
642             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
643             .iterator()
644             .next();
645     Assert.assertTrue(
646         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
647             .matcher(apiClientHeaderKey)
648             .matches());
649   }
650 
651   @Test
getEffectivePolicyExceptionTest2()652   public void getEffectivePolicyExceptionTest2() throws Exception {
653     ApiException exception =
654         ApiExceptionFactory.createException(
655             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
656     mockService.addException(exception);
657 
658     try {
659       String name = "projects/project-3674/policies/policie-3674";
660       client.getEffectivePolicy(name);
661       Assert.fail("No exception raised");
662     } catch (InvalidArgumentException e) {
663       // Expected exception.
664     }
665   }
666 
667   @Test
createPolicyTest()668   public void createPolicyTest() throws Exception {
669     Policy expectedResponse =
670         Policy.newBuilder()
671             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
672             .setSpec(PolicySpec.newBuilder().build())
673             .setAlternate(AlternatePolicySpec.newBuilder().build())
674             .setDryRunSpec(PolicySpec.newBuilder().build())
675             .build();
676     mockService.addResponse(expectedResponse);
677 
678     FolderName parent = FolderName.of("[FOLDER]");
679     Policy policy = Policy.newBuilder().build();
680 
681     Policy actualResponse = client.createPolicy(parent, policy);
682     Assert.assertEquals(expectedResponse, actualResponse);
683 
684     List<String> actualRequests = mockService.getRequestPaths();
685     Assert.assertEquals(1, actualRequests.size());
686 
687     String apiClientHeaderKey =
688         mockService
689             .getRequestHeaders()
690             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
691             .iterator()
692             .next();
693     Assert.assertTrue(
694         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
695             .matcher(apiClientHeaderKey)
696             .matches());
697   }
698 
699   @Test
createPolicyExceptionTest()700   public void createPolicyExceptionTest() throws Exception {
701     ApiException exception =
702         ApiExceptionFactory.createException(
703             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
704     mockService.addException(exception);
705 
706     try {
707       FolderName parent = FolderName.of("[FOLDER]");
708       Policy policy = Policy.newBuilder().build();
709       client.createPolicy(parent, policy);
710       Assert.fail("No exception raised");
711     } catch (InvalidArgumentException e) {
712       // Expected exception.
713     }
714   }
715 
716   @Test
createPolicyTest2()717   public void createPolicyTest2() throws Exception {
718     Policy expectedResponse =
719         Policy.newBuilder()
720             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
721             .setSpec(PolicySpec.newBuilder().build())
722             .setAlternate(AlternatePolicySpec.newBuilder().build())
723             .setDryRunSpec(PolicySpec.newBuilder().build())
724             .build();
725     mockService.addResponse(expectedResponse);
726 
727     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
728     Policy policy = Policy.newBuilder().build();
729 
730     Policy actualResponse = client.createPolicy(parent, policy);
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
createPolicyExceptionTest2()749   public void createPolicyExceptionTest2() 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       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
757       Policy policy = Policy.newBuilder().build();
758       client.createPolicy(parent, policy);
759       Assert.fail("No exception raised");
760     } catch (InvalidArgumentException e) {
761       // Expected exception.
762     }
763   }
764 
765   @Test
createPolicyTest3()766   public void createPolicyTest3() throws Exception {
767     Policy expectedResponse =
768         Policy.newBuilder()
769             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
770             .setSpec(PolicySpec.newBuilder().build())
771             .setAlternate(AlternatePolicySpec.newBuilder().build())
772             .setDryRunSpec(PolicySpec.newBuilder().build())
773             .build();
774     mockService.addResponse(expectedResponse);
775 
776     ProjectName parent = ProjectName.of("[PROJECT]");
777     Policy policy = Policy.newBuilder().build();
778 
779     Policy actualResponse = client.createPolicy(parent, policy);
780     Assert.assertEquals(expectedResponse, actualResponse);
781 
782     List<String> actualRequests = mockService.getRequestPaths();
783     Assert.assertEquals(1, actualRequests.size());
784 
785     String apiClientHeaderKey =
786         mockService
787             .getRequestHeaders()
788             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
789             .iterator()
790             .next();
791     Assert.assertTrue(
792         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
793             .matcher(apiClientHeaderKey)
794             .matches());
795   }
796 
797   @Test
createPolicyExceptionTest3()798   public void createPolicyExceptionTest3() throws Exception {
799     ApiException exception =
800         ApiExceptionFactory.createException(
801             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
802     mockService.addException(exception);
803 
804     try {
805       ProjectName parent = ProjectName.of("[PROJECT]");
806       Policy policy = Policy.newBuilder().build();
807       client.createPolicy(parent, policy);
808       Assert.fail("No exception raised");
809     } catch (InvalidArgumentException e) {
810       // Expected exception.
811     }
812   }
813 
814   @Test
createPolicyTest4()815   public void createPolicyTest4() throws Exception {
816     Policy expectedResponse =
817         Policy.newBuilder()
818             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
819             .setSpec(PolicySpec.newBuilder().build())
820             .setAlternate(AlternatePolicySpec.newBuilder().build())
821             .setDryRunSpec(PolicySpec.newBuilder().build())
822             .build();
823     mockService.addResponse(expectedResponse);
824 
825     String parent = "projects/project-2353";
826     Policy policy = Policy.newBuilder().build();
827 
828     Policy actualResponse = client.createPolicy(parent, policy);
829     Assert.assertEquals(expectedResponse, actualResponse);
830 
831     List<String> actualRequests = mockService.getRequestPaths();
832     Assert.assertEquals(1, actualRequests.size());
833 
834     String apiClientHeaderKey =
835         mockService
836             .getRequestHeaders()
837             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
838             .iterator()
839             .next();
840     Assert.assertTrue(
841         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
842             .matcher(apiClientHeaderKey)
843             .matches());
844   }
845 
846   @Test
createPolicyExceptionTest4()847   public void createPolicyExceptionTest4() throws Exception {
848     ApiException exception =
849         ApiExceptionFactory.createException(
850             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
851     mockService.addException(exception);
852 
853     try {
854       String parent = "projects/project-2353";
855       Policy policy = Policy.newBuilder().build();
856       client.createPolicy(parent, policy);
857       Assert.fail("No exception raised");
858     } catch (InvalidArgumentException e) {
859       // Expected exception.
860     }
861   }
862 
863   @Test
updatePolicyTest()864   public void updatePolicyTest() throws Exception {
865     Policy expectedResponse =
866         Policy.newBuilder()
867             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
868             .setSpec(PolicySpec.newBuilder().build())
869             .setAlternate(AlternatePolicySpec.newBuilder().build())
870             .setDryRunSpec(PolicySpec.newBuilder().build())
871             .build();
872     mockService.addResponse(expectedResponse);
873 
874     Policy policy =
875         Policy.newBuilder()
876             .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
877             .setSpec(PolicySpec.newBuilder().build())
878             .setAlternate(AlternatePolicySpec.newBuilder().build())
879             .setDryRunSpec(PolicySpec.newBuilder().build())
880             .build();
881 
882     Policy actualResponse = client.updatePolicy(policy);
883     Assert.assertEquals(expectedResponse, actualResponse);
884 
885     List<String> actualRequests = mockService.getRequestPaths();
886     Assert.assertEquals(1, actualRequests.size());
887 
888     String apiClientHeaderKey =
889         mockService
890             .getRequestHeaders()
891             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
892             .iterator()
893             .next();
894     Assert.assertTrue(
895         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
896             .matcher(apiClientHeaderKey)
897             .matches());
898   }
899 
900   @Test
updatePolicyExceptionTest()901   public void updatePolicyExceptionTest() throws Exception {
902     ApiException exception =
903         ApiExceptionFactory.createException(
904             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
905     mockService.addException(exception);
906 
907     try {
908       Policy policy =
909           Policy.newBuilder()
910               .setName(PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]").toString())
911               .setSpec(PolicySpec.newBuilder().build())
912               .setAlternate(AlternatePolicySpec.newBuilder().build())
913               .setDryRunSpec(PolicySpec.newBuilder().build())
914               .build();
915       client.updatePolicy(policy);
916       Assert.fail("No exception raised");
917     } catch (InvalidArgumentException e) {
918       // Expected exception.
919     }
920   }
921 
922   @Test
deletePolicyTest()923   public void deletePolicyTest() throws Exception {
924     Empty expectedResponse = Empty.newBuilder().build();
925     mockService.addResponse(expectedResponse);
926 
927     PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
928 
929     client.deletePolicy(name);
930 
931     List<String> actualRequests = mockService.getRequestPaths();
932     Assert.assertEquals(1, actualRequests.size());
933 
934     String apiClientHeaderKey =
935         mockService
936             .getRequestHeaders()
937             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
938             .iterator()
939             .next();
940     Assert.assertTrue(
941         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
942             .matcher(apiClientHeaderKey)
943             .matches());
944   }
945 
946   @Test
deletePolicyExceptionTest()947   public void deletePolicyExceptionTest() throws Exception {
948     ApiException exception =
949         ApiExceptionFactory.createException(
950             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
951     mockService.addException(exception);
952 
953     try {
954       PolicyName name = PolicyName.ofProjectPolicyName("[PROJECT]", "[POLICY]");
955       client.deletePolicy(name);
956       Assert.fail("No exception raised");
957     } catch (InvalidArgumentException e) {
958       // Expected exception.
959     }
960   }
961 
962   @Test
deletePolicyTest2()963   public void deletePolicyTest2() throws Exception {
964     Empty expectedResponse = Empty.newBuilder().build();
965     mockService.addResponse(expectedResponse);
966 
967     String name = "projects/project-3674/policies/policie-3674";
968 
969     client.deletePolicy(name);
970 
971     List<String> actualRequests = mockService.getRequestPaths();
972     Assert.assertEquals(1, actualRequests.size());
973 
974     String apiClientHeaderKey =
975         mockService
976             .getRequestHeaders()
977             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
978             .iterator()
979             .next();
980     Assert.assertTrue(
981         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
982             .matcher(apiClientHeaderKey)
983             .matches());
984   }
985 
986   @Test
deletePolicyExceptionTest2()987   public void deletePolicyExceptionTest2() throws Exception {
988     ApiException exception =
989         ApiExceptionFactory.createException(
990             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
991     mockService.addException(exception);
992 
993     try {
994       String name = "projects/project-3674/policies/policie-3674";
995       client.deletePolicy(name);
996       Assert.fail("No exception raised");
997     } catch (InvalidArgumentException e) {
998       // Expected exception.
999     }
1000   }
1001 }
1002