• 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.devtools.containeranalysis.v1;
18 
19 import com.google.api.gax.core.NoCredentialsProvider;
20 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
21 import com.google.api.gax.httpjson.testing.MockHttpService;
22 import com.google.api.gax.rpc.ApiClientHeaderProvider;
23 import com.google.api.gax.rpc.ApiException;
24 import com.google.api.gax.rpc.ApiExceptionFactory;
25 import com.google.api.gax.rpc.InvalidArgumentException;
26 import com.google.api.gax.rpc.StatusCode;
27 import com.google.api.gax.rpc.testing.FakeStatusCode;
28 import com.google.api.resourcenames.ResourceName;
29 import com.google.cloud.devtools.containeranalysis.v1.stub.HttpJsonContainerAnalysisStub;
30 import com.google.containeranalysis.v1.ProjectName;
31 import com.google.containeranalysis.v1.VulnerabilityOccurrencesSummary;
32 import com.google.iam.v1.AuditConfig;
33 import com.google.iam.v1.Binding;
34 import com.google.iam.v1.Policy;
35 import com.google.iam.v1.TestIamPermissionsResponse;
36 import com.google.protobuf.ByteString;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42 import javax.annotation.Generated;
43 import org.junit.After;
44 import org.junit.AfterClass;
45 import org.junit.Assert;
46 import org.junit.Before;
47 import org.junit.BeforeClass;
48 import org.junit.Test;
49 
50 @Generated("by gapic-generator-java")
51 public class ContainerAnalysisClientHttpJsonTest {
52   private static MockHttpService mockService;
53   private static ContainerAnalysisClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonContainerAnalysisStub.getMethodDescriptors(),
60             ContainerAnalysisSettings.getDefaultEndpoint());
61     ContainerAnalysisSettings settings =
62         ContainerAnalysisSettings.newHttpJsonBuilder()
63             .setTransportChannelProvider(
64                 ContainerAnalysisSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = ContainerAnalysisClient.create(settings);
70   }
71 
72   @AfterClass
stopServer()73   public static void stopServer() {
74     client.close();
75   }
76 
77   @Before
setUp()78   public void setUp() {}
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     mockService.reset();
83   }
84 
85   @Test
setIamPolicyTest()86   public void setIamPolicyTest() throws Exception {
87     Policy expectedResponse =
88         Policy.newBuilder()
89             .setVersion(351608024)
90             .addAllBindings(new ArrayList<Binding>())
91             .addAllAuditConfigs(new ArrayList<AuditConfig>())
92             .setEtag(ByteString.EMPTY)
93             .build();
94     mockService.addResponse(expectedResponse);
95 
96     ResourceName resource =
97         new ResourceName() {
98           @Override
99           public Map<String, String> getFieldValuesMap() {
100             Map<String, String> fieldValuesMap = new HashMap<>();
101             fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
102             return fieldValuesMap;
103           }
104 
105           @Override
106           public String getFieldValue(String fieldName) {
107             return getFieldValuesMap().get(fieldName);
108           }
109 
110           @Override
111           public String toString() {
112             return "projects/project-8432/notes/note-8432";
113           }
114         };
115     Policy policy = Policy.newBuilder().build();
116 
117     Policy actualResponse = client.setIamPolicy(resource, policy);
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
setIamPolicyExceptionTest()136   public void setIamPolicyExceptionTest() 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       ResourceName resource =
144           new ResourceName() {
145             @Override
146             public Map<String, String> getFieldValuesMap() {
147               Map<String, String> fieldValuesMap = new HashMap<>();
148               fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
149               return fieldValuesMap;
150             }
151 
152             @Override
153             public String getFieldValue(String fieldName) {
154               return getFieldValuesMap().get(fieldName);
155             }
156 
157             @Override
158             public String toString() {
159               return "projects/project-8432/notes/note-8432";
160             }
161           };
162       Policy policy = Policy.newBuilder().build();
163       client.setIamPolicy(resource, policy);
164       Assert.fail("No exception raised");
165     } catch (InvalidArgumentException e) {
166       // Expected exception.
167     }
168   }
169 
170   @Test
setIamPolicyTest2()171   public void setIamPolicyTest2() throws Exception {
172     Policy expectedResponse =
173         Policy.newBuilder()
174             .setVersion(351608024)
175             .addAllBindings(new ArrayList<Binding>())
176             .addAllAuditConfigs(new ArrayList<AuditConfig>())
177             .setEtag(ByteString.EMPTY)
178             .build();
179     mockService.addResponse(expectedResponse);
180 
181     String resource = "projects/project-8432/notes/note-8432";
182     Policy policy = Policy.newBuilder().build();
183 
184     Policy actualResponse = client.setIamPolicy(resource, policy);
185     Assert.assertEquals(expectedResponse, actualResponse);
186 
187     List<String> actualRequests = mockService.getRequestPaths();
188     Assert.assertEquals(1, actualRequests.size());
189 
190     String apiClientHeaderKey =
191         mockService
192             .getRequestHeaders()
193             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
194             .iterator()
195             .next();
196     Assert.assertTrue(
197         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
198             .matcher(apiClientHeaderKey)
199             .matches());
200   }
201 
202   @Test
setIamPolicyExceptionTest2()203   public void setIamPolicyExceptionTest2() throws Exception {
204     ApiException exception =
205         ApiExceptionFactory.createException(
206             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
207     mockService.addException(exception);
208 
209     try {
210       String resource = "projects/project-8432/notes/note-8432";
211       Policy policy = Policy.newBuilder().build();
212       client.setIamPolicy(resource, policy);
213       Assert.fail("No exception raised");
214     } catch (InvalidArgumentException e) {
215       // Expected exception.
216     }
217   }
218 
219   @Test
getIamPolicyTest()220   public void getIamPolicyTest() throws Exception {
221     Policy expectedResponse =
222         Policy.newBuilder()
223             .setVersion(351608024)
224             .addAllBindings(new ArrayList<Binding>())
225             .addAllAuditConfigs(new ArrayList<AuditConfig>())
226             .setEtag(ByteString.EMPTY)
227             .build();
228     mockService.addResponse(expectedResponse);
229 
230     ResourceName resource =
231         new ResourceName() {
232           @Override
233           public Map<String, String> getFieldValuesMap() {
234             Map<String, String> fieldValuesMap = new HashMap<>();
235             fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
236             return fieldValuesMap;
237           }
238 
239           @Override
240           public String getFieldValue(String fieldName) {
241             return getFieldValuesMap().get(fieldName);
242           }
243 
244           @Override
245           public String toString() {
246             return "projects/project-8432/notes/note-8432";
247           }
248         };
249 
250     Policy actualResponse = client.getIamPolicy(resource);
251     Assert.assertEquals(expectedResponse, actualResponse);
252 
253     List<String> actualRequests = mockService.getRequestPaths();
254     Assert.assertEquals(1, actualRequests.size());
255 
256     String apiClientHeaderKey =
257         mockService
258             .getRequestHeaders()
259             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
260             .iterator()
261             .next();
262     Assert.assertTrue(
263         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
264             .matcher(apiClientHeaderKey)
265             .matches());
266   }
267 
268   @Test
getIamPolicyExceptionTest()269   public void getIamPolicyExceptionTest() throws Exception {
270     ApiException exception =
271         ApiExceptionFactory.createException(
272             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
273     mockService.addException(exception);
274 
275     try {
276       ResourceName resource =
277           new ResourceName() {
278             @Override
279             public Map<String, String> getFieldValuesMap() {
280               Map<String, String> fieldValuesMap = new HashMap<>();
281               fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
282               return fieldValuesMap;
283             }
284 
285             @Override
286             public String getFieldValue(String fieldName) {
287               return getFieldValuesMap().get(fieldName);
288             }
289 
290             @Override
291             public String toString() {
292               return "projects/project-8432/notes/note-8432";
293             }
294           };
295       client.getIamPolicy(resource);
296       Assert.fail("No exception raised");
297     } catch (InvalidArgumentException e) {
298       // Expected exception.
299     }
300   }
301 
302   @Test
getIamPolicyTest2()303   public void getIamPolicyTest2() throws Exception {
304     Policy expectedResponse =
305         Policy.newBuilder()
306             .setVersion(351608024)
307             .addAllBindings(new ArrayList<Binding>())
308             .addAllAuditConfigs(new ArrayList<AuditConfig>())
309             .setEtag(ByteString.EMPTY)
310             .build();
311     mockService.addResponse(expectedResponse);
312 
313     String resource = "projects/project-8432/notes/note-8432";
314 
315     Policy actualResponse = client.getIamPolicy(resource);
316     Assert.assertEquals(expectedResponse, actualResponse);
317 
318     List<String> actualRequests = mockService.getRequestPaths();
319     Assert.assertEquals(1, actualRequests.size());
320 
321     String apiClientHeaderKey =
322         mockService
323             .getRequestHeaders()
324             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
325             .iterator()
326             .next();
327     Assert.assertTrue(
328         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
329             .matcher(apiClientHeaderKey)
330             .matches());
331   }
332 
333   @Test
getIamPolicyExceptionTest2()334   public void getIamPolicyExceptionTest2() throws Exception {
335     ApiException exception =
336         ApiExceptionFactory.createException(
337             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
338     mockService.addException(exception);
339 
340     try {
341       String resource = "projects/project-8432/notes/note-8432";
342       client.getIamPolicy(resource);
343       Assert.fail("No exception raised");
344     } catch (InvalidArgumentException e) {
345       // Expected exception.
346     }
347   }
348 
349   @Test
testIamPermissionsTest()350   public void testIamPermissionsTest() throws Exception {
351     TestIamPermissionsResponse expectedResponse =
352         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
353     mockService.addResponse(expectedResponse);
354 
355     ResourceName resource =
356         new ResourceName() {
357           @Override
358           public Map<String, String> getFieldValuesMap() {
359             Map<String, String> fieldValuesMap = new HashMap<>();
360             fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
361             return fieldValuesMap;
362           }
363 
364           @Override
365           public String getFieldValue(String fieldName) {
366             return getFieldValuesMap().get(fieldName);
367           }
368 
369           @Override
370           public String toString() {
371             return "projects/project-8432/notes/note-8432";
372           }
373         };
374     List<String> permissions = new ArrayList<>();
375 
376     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
377     Assert.assertEquals(expectedResponse, actualResponse);
378 
379     List<String> actualRequests = mockService.getRequestPaths();
380     Assert.assertEquals(1, actualRequests.size());
381 
382     String apiClientHeaderKey =
383         mockService
384             .getRequestHeaders()
385             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
386             .iterator()
387             .next();
388     Assert.assertTrue(
389         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
390             .matcher(apiClientHeaderKey)
391             .matches());
392   }
393 
394   @Test
testIamPermissionsExceptionTest()395   public void testIamPermissionsExceptionTest() throws Exception {
396     ApiException exception =
397         ApiExceptionFactory.createException(
398             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
399     mockService.addException(exception);
400 
401     try {
402       ResourceName resource =
403           new ResourceName() {
404             @Override
405             public Map<String, String> getFieldValuesMap() {
406               Map<String, String> fieldValuesMap = new HashMap<>();
407               fieldValuesMap.put("resource", "projects/project-8432/notes/note-8432");
408               return fieldValuesMap;
409             }
410 
411             @Override
412             public String getFieldValue(String fieldName) {
413               return getFieldValuesMap().get(fieldName);
414             }
415 
416             @Override
417             public String toString() {
418               return "projects/project-8432/notes/note-8432";
419             }
420           };
421       List<String> permissions = new ArrayList<>();
422       client.testIamPermissions(resource, permissions);
423       Assert.fail("No exception raised");
424     } catch (InvalidArgumentException e) {
425       // Expected exception.
426     }
427   }
428 
429   @Test
testIamPermissionsTest2()430   public void testIamPermissionsTest2() throws Exception {
431     TestIamPermissionsResponse expectedResponse =
432         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
433     mockService.addResponse(expectedResponse);
434 
435     String resource = "projects/project-8432/notes/note-8432";
436     List<String> permissions = new ArrayList<>();
437 
438     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
439     Assert.assertEquals(expectedResponse, actualResponse);
440 
441     List<String> actualRequests = mockService.getRequestPaths();
442     Assert.assertEquals(1, actualRequests.size());
443 
444     String apiClientHeaderKey =
445         mockService
446             .getRequestHeaders()
447             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
448             .iterator()
449             .next();
450     Assert.assertTrue(
451         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
452             .matcher(apiClientHeaderKey)
453             .matches());
454   }
455 
456   @Test
testIamPermissionsExceptionTest2()457   public void testIamPermissionsExceptionTest2() throws Exception {
458     ApiException exception =
459         ApiExceptionFactory.createException(
460             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
461     mockService.addException(exception);
462 
463     try {
464       String resource = "projects/project-8432/notes/note-8432";
465       List<String> permissions = new ArrayList<>();
466       client.testIamPermissions(resource, permissions);
467       Assert.fail("No exception raised");
468     } catch (InvalidArgumentException e) {
469       // Expected exception.
470     }
471   }
472 
473   @Test
getVulnerabilityOccurrencesSummaryTest()474   public void getVulnerabilityOccurrencesSummaryTest() throws Exception {
475     VulnerabilityOccurrencesSummary expectedResponse =
476         VulnerabilityOccurrencesSummary.newBuilder()
477             .addAllCounts(new ArrayList<VulnerabilityOccurrencesSummary.FixableTotalByDigest>())
478             .build();
479     mockService.addResponse(expectedResponse);
480 
481     ProjectName parent = ProjectName.of("[PROJECT]");
482     String filter = "filter-1274492040";
483 
484     VulnerabilityOccurrencesSummary actualResponse =
485         client.getVulnerabilityOccurrencesSummary(parent, filter);
486     Assert.assertEquals(expectedResponse, actualResponse);
487 
488     List<String> actualRequests = mockService.getRequestPaths();
489     Assert.assertEquals(1, actualRequests.size());
490 
491     String apiClientHeaderKey =
492         mockService
493             .getRequestHeaders()
494             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
495             .iterator()
496             .next();
497     Assert.assertTrue(
498         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
499             .matcher(apiClientHeaderKey)
500             .matches());
501   }
502 
503   @Test
getVulnerabilityOccurrencesSummaryExceptionTest()504   public void getVulnerabilityOccurrencesSummaryExceptionTest() throws Exception {
505     ApiException exception =
506         ApiExceptionFactory.createException(
507             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
508     mockService.addException(exception);
509 
510     try {
511       ProjectName parent = ProjectName.of("[PROJECT]");
512       String filter = "filter-1274492040";
513       client.getVulnerabilityOccurrencesSummary(parent, filter);
514       Assert.fail("No exception raised");
515     } catch (InvalidArgumentException e) {
516       // Expected exception.
517     }
518   }
519 
520   @Test
getVulnerabilityOccurrencesSummaryTest2()521   public void getVulnerabilityOccurrencesSummaryTest2() throws Exception {
522     VulnerabilityOccurrencesSummary expectedResponse =
523         VulnerabilityOccurrencesSummary.newBuilder()
524             .addAllCounts(new ArrayList<VulnerabilityOccurrencesSummary.FixableTotalByDigest>())
525             .build();
526     mockService.addResponse(expectedResponse);
527 
528     String parent = "projects/project-2353";
529     String filter = "filter-1274492040";
530 
531     VulnerabilityOccurrencesSummary actualResponse =
532         client.getVulnerabilityOccurrencesSummary(parent, filter);
533     Assert.assertEquals(expectedResponse, actualResponse);
534 
535     List<String> actualRequests = mockService.getRequestPaths();
536     Assert.assertEquals(1, actualRequests.size());
537 
538     String apiClientHeaderKey =
539         mockService
540             .getRequestHeaders()
541             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
542             .iterator()
543             .next();
544     Assert.assertTrue(
545         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
546             .matcher(apiClientHeaderKey)
547             .matches());
548   }
549 
550   @Test
getVulnerabilityOccurrencesSummaryExceptionTest2()551   public void getVulnerabilityOccurrencesSummaryExceptionTest2() throws Exception {
552     ApiException exception =
553         ApiExceptionFactory.createException(
554             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
555     mockService.addException(exception);
556 
557     try {
558       String parent = "projects/project-2353";
559       String filter = "filter-1274492040";
560       client.getVulnerabilityOccurrencesSummary(parent, filter);
561       Assert.fail("No exception raised");
562     } catch (InvalidArgumentException e) {
563       // Expected exception.
564     }
565   }
566 }
567