• 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.securitycenter.v1beta1;
18 
19 import static com.google.cloud.securitycenter.v1beta1.SecurityCenterClient.GroupAssetsPagedResponse;
20 import static com.google.cloud.securitycenter.v1beta1.SecurityCenterClient.GroupFindingsPagedResponse;
21 import static com.google.cloud.securitycenter.v1beta1.SecurityCenterClient.ListAssetsPagedResponse;
22 import static com.google.cloud.securitycenter.v1beta1.SecurityCenterClient.ListFindingsPagedResponse;
23 import static com.google.cloud.securitycenter.v1beta1.SecurityCenterClient.ListSourcesPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
27 import com.google.api.gax.httpjson.testing.MockHttpService;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.ApiException;
30 import com.google.api.gax.rpc.ApiExceptionFactory;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.api.gax.rpc.StatusCode;
33 import com.google.api.gax.rpc.testing.FakeStatusCode;
34 import com.google.api.resourcenames.ResourceName;
35 import com.google.cloud.securitycenter.v1beta1.stub.HttpJsonSecurityCenterStub;
36 import com.google.common.collect.Lists;
37 import com.google.iam.v1.AuditConfig;
38 import com.google.iam.v1.Binding;
39 import com.google.iam.v1.Policy;
40 import com.google.iam.v1.TestIamPermissionsResponse;
41 import com.google.longrunning.Operation;
42 import com.google.protobuf.Any;
43 import com.google.protobuf.ByteString;
44 import com.google.protobuf.Duration;
45 import com.google.protobuf.Empty;
46 import com.google.protobuf.FieldMask;
47 import com.google.protobuf.Timestamp;
48 import com.google.protobuf.Value;
49 import java.io.IOException;
50 import java.util.ArrayList;
51 import java.util.Arrays;
52 import java.util.HashMap;
53 import java.util.List;
54 import java.util.concurrent.ExecutionException;
55 import javax.annotation.Generated;
56 import org.junit.After;
57 import org.junit.AfterClass;
58 import org.junit.Assert;
59 import org.junit.Before;
60 import org.junit.BeforeClass;
61 import org.junit.Test;
62 
63 @Generated("by gapic-generator-java")
64 public class SecurityCenterClientHttpJsonTest {
65   private static MockHttpService mockService;
66   private static SecurityCenterClient client;
67 
68   @BeforeClass
startStaticServer()69   public static void startStaticServer() throws IOException {
70     mockService =
71         new MockHttpService(
72             HttpJsonSecurityCenterStub.getMethodDescriptors(),
73             SecurityCenterSettings.getDefaultEndpoint());
74     SecurityCenterSettings settings =
75         SecurityCenterSettings.newHttpJsonBuilder()
76             .setTransportChannelProvider(
77                 SecurityCenterSettings.defaultHttpJsonTransportProviderBuilder()
78                     .setHttpTransport(mockService)
79                     .build())
80             .setCredentialsProvider(NoCredentialsProvider.create())
81             .build();
82     client = SecurityCenterClient.create(settings);
83   }
84 
85   @AfterClass
stopServer()86   public static void stopServer() {
87     client.close();
88   }
89 
90   @Before
setUp()91   public void setUp() {}
92 
93   @After
tearDown()94   public void tearDown() throws Exception {
95     mockService.reset();
96   }
97 
98   @Test
createSourceTest()99   public void createSourceTest() throws Exception {
100     Source expectedResponse =
101         Source.newBuilder()
102             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
103             .setDisplayName("displayName1714148973")
104             .setDescription("description-1724546052")
105             .build();
106     mockService.addResponse(expectedResponse);
107 
108     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
109     Source source = Source.newBuilder().build();
110 
111     Source actualResponse = client.createSource(parent, source);
112     Assert.assertEquals(expectedResponse, actualResponse);
113 
114     List<String> actualRequests = mockService.getRequestPaths();
115     Assert.assertEquals(1, actualRequests.size());
116 
117     String apiClientHeaderKey =
118         mockService
119             .getRequestHeaders()
120             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
121             .iterator()
122             .next();
123     Assert.assertTrue(
124         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
125             .matcher(apiClientHeaderKey)
126             .matches());
127   }
128 
129   @Test
createSourceExceptionTest()130   public void createSourceExceptionTest() throws Exception {
131     ApiException exception =
132         ApiExceptionFactory.createException(
133             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
134     mockService.addException(exception);
135 
136     try {
137       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
138       Source source = Source.newBuilder().build();
139       client.createSource(parent, source);
140       Assert.fail("No exception raised");
141     } catch (InvalidArgumentException e) {
142       // Expected exception.
143     }
144   }
145 
146   @Test
createSourceTest2()147   public void createSourceTest2() throws Exception {
148     Source expectedResponse =
149         Source.newBuilder()
150             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
151             .setDisplayName("displayName1714148973")
152             .setDescription("description-1724546052")
153             .build();
154     mockService.addResponse(expectedResponse);
155 
156     String parent = "organizations/organization-8287";
157     Source source = Source.newBuilder().build();
158 
159     Source actualResponse = client.createSource(parent, source);
160     Assert.assertEquals(expectedResponse, actualResponse);
161 
162     List<String> actualRequests = mockService.getRequestPaths();
163     Assert.assertEquals(1, actualRequests.size());
164 
165     String apiClientHeaderKey =
166         mockService
167             .getRequestHeaders()
168             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
169             .iterator()
170             .next();
171     Assert.assertTrue(
172         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
173             .matcher(apiClientHeaderKey)
174             .matches());
175   }
176 
177   @Test
createSourceExceptionTest2()178   public void createSourceExceptionTest2() throws Exception {
179     ApiException exception =
180         ApiExceptionFactory.createException(
181             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
182     mockService.addException(exception);
183 
184     try {
185       String parent = "organizations/organization-8287";
186       Source source = Source.newBuilder().build();
187       client.createSource(parent, source);
188       Assert.fail("No exception raised");
189     } catch (InvalidArgumentException e) {
190       // Expected exception.
191     }
192   }
193 
194   @Test
createFindingTest()195   public void createFindingTest() throws Exception {
196     Finding expectedResponse =
197         Finding.newBuilder()
198             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
199             .setParent("parent-995424086")
200             .setResourceName("resourceName-384566343")
201             .setCategory("category50511102")
202             .setExternalUri("externalUri-1153085023")
203             .putAllSourceProperties(new HashMap<String, Value>())
204             .setSecurityMarks(SecurityMarks.newBuilder().build())
205             .setEventTime(Timestamp.newBuilder().build())
206             .setCreateTime(Timestamp.newBuilder().build())
207             .build();
208     mockService.addResponse(expectedResponse);
209 
210     SourceName parent = SourceName.of("[ORGANIZATION]", "[SOURCE]");
211     String findingId = "findingId439150212";
212     Finding finding = Finding.newBuilder().build();
213 
214     Finding actualResponse = client.createFinding(parent, findingId, finding);
215     Assert.assertEquals(expectedResponse, actualResponse);
216 
217     List<String> actualRequests = mockService.getRequestPaths();
218     Assert.assertEquals(1, actualRequests.size());
219 
220     String apiClientHeaderKey =
221         mockService
222             .getRequestHeaders()
223             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
224             .iterator()
225             .next();
226     Assert.assertTrue(
227         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
228             .matcher(apiClientHeaderKey)
229             .matches());
230   }
231 
232   @Test
createFindingExceptionTest()233   public void createFindingExceptionTest() throws Exception {
234     ApiException exception =
235         ApiExceptionFactory.createException(
236             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
237     mockService.addException(exception);
238 
239     try {
240       SourceName parent = SourceName.of("[ORGANIZATION]", "[SOURCE]");
241       String findingId = "findingId439150212";
242       Finding finding = Finding.newBuilder().build();
243       client.createFinding(parent, findingId, finding);
244       Assert.fail("No exception raised");
245     } catch (InvalidArgumentException e) {
246       // Expected exception.
247     }
248   }
249 
250   @Test
createFindingTest2()251   public void createFindingTest2() throws Exception {
252     Finding expectedResponse =
253         Finding.newBuilder()
254             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
255             .setParent("parent-995424086")
256             .setResourceName("resourceName-384566343")
257             .setCategory("category50511102")
258             .setExternalUri("externalUri-1153085023")
259             .putAllSourceProperties(new HashMap<String, Value>())
260             .setSecurityMarks(SecurityMarks.newBuilder().build())
261             .setEventTime(Timestamp.newBuilder().build())
262             .setCreateTime(Timestamp.newBuilder().build())
263             .build();
264     mockService.addResponse(expectedResponse);
265 
266     String parent = "organizations/organization-8741/sources/source-8741";
267     String findingId = "findingId439150212";
268     Finding finding = Finding.newBuilder().build();
269 
270     Finding actualResponse = client.createFinding(parent, findingId, finding);
271     Assert.assertEquals(expectedResponse, actualResponse);
272 
273     List<String> actualRequests = mockService.getRequestPaths();
274     Assert.assertEquals(1, actualRequests.size());
275 
276     String apiClientHeaderKey =
277         mockService
278             .getRequestHeaders()
279             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
280             .iterator()
281             .next();
282     Assert.assertTrue(
283         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
284             .matcher(apiClientHeaderKey)
285             .matches());
286   }
287 
288   @Test
createFindingExceptionTest2()289   public void createFindingExceptionTest2() throws Exception {
290     ApiException exception =
291         ApiExceptionFactory.createException(
292             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
293     mockService.addException(exception);
294 
295     try {
296       String parent = "organizations/organization-8741/sources/source-8741";
297       String findingId = "findingId439150212";
298       Finding finding = Finding.newBuilder().build();
299       client.createFinding(parent, findingId, finding);
300       Assert.fail("No exception raised");
301     } catch (InvalidArgumentException e) {
302       // Expected exception.
303     }
304   }
305 
306   @Test
getIamPolicyTest()307   public void getIamPolicyTest() throws Exception {
308     Policy expectedResponse =
309         Policy.newBuilder()
310             .setVersion(351608024)
311             .addAllBindings(new ArrayList<Binding>())
312             .addAllAuditConfigs(new ArrayList<AuditConfig>())
313             .setEtag(ByteString.EMPTY)
314             .build();
315     mockService.addResponse(expectedResponse);
316 
317     ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
318 
319     Policy actualResponse = client.getIamPolicy(resource);
320     Assert.assertEquals(expectedResponse, actualResponse);
321 
322     List<String> actualRequests = mockService.getRequestPaths();
323     Assert.assertEquals(1, actualRequests.size());
324 
325     String apiClientHeaderKey =
326         mockService
327             .getRequestHeaders()
328             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
329             .iterator()
330             .next();
331     Assert.assertTrue(
332         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
333             .matcher(apiClientHeaderKey)
334             .matches());
335   }
336 
337   @Test
getIamPolicyExceptionTest()338   public void getIamPolicyExceptionTest() throws Exception {
339     ApiException exception =
340         ApiExceptionFactory.createException(
341             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
342     mockService.addException(exception);
343 
344     try {
345       ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
346       client.getIamPolicy(resource);
347       Assert.fail("No exception raised");
348     } catch (InvalidArgumentException e) {
349       // Expected exception.
350     }
351   }
352 
353   @Test
getIamPolicyTest2()354   public void getIamPolicyTest2() throws Exception {
355     Policy expectedResponse =
356         Policy.newBuilder()
357             .setVersion(351608024)
358             .addAllBindings(new ArrayList<Binding>())
359             .addAllAuditConfigs(new ArrayList<AuditConfig>())
360             .setEtag(ByteString.EMPTY)
361             .build();
362     mockService.addResponse(expectedResponse);
363 
364     String resource = "organizations/organization-3393/sources/source-3393";
365 
366     Policy actualResponse = client.getIamPolicy(resource);
367     Assert.assertEquals(expectedResponse, actualResponse);
368 
369     List<String> actualRequests = mockService.getRequestPaths();
370     Assert.assertEquals(1, actualRequests.size());
371 
372     String apiClientHeaderKey =
373         mockService
374             .getRequestHeaders()
375             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
376             .iterator()
377             .next();
378     Assert.assertTrue(
379         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
380             .matcher(apiClientHeaderKey)
381             .matches());
382   }
383 
384   @Test
getIamPolicyExceptionTest2()385   public void getIamPolicyExceptionTest2() throws Exception {
386     ApiException exception =
387         ApiExceptionFactory.createException(
388             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
389     mockService.addException(exception);
390 
391     try {
392       String resource = "organizations/organization-3393/sources/source-3393";
393       client.getIamPolicy(resource);
394       Assert.fail("No exception raised");
395     } catch (InvalidArgumentException e) {
396       // Expected exception.
397     }
398   }
399 
400   @Test
getOrganizationSettingsTest()401   public void getOrganizationSettingsTest() throws Exception {
402     OrganizationSettings expectedResponse =
403         OrganizationSettings.newBuilder()
404             .setName(OrganizationSettingsName.of("[ORGANIZATION]").toString())
405             .setEnableAssetDiscovery(true)
406             .setAssetDiscoveryConfig(OrganizationSettings.AssetDiscoveryConfig.newBuilder().build())
407             .build();
408     mockService.addResponse(expectedResponse);
409 
410     OrganizationSettingsName name = OrganizationSettingsName.of("[ORGANIZATION]");
411 
412     OrganizationSettings actualResponse = client.getOrganizationSettings(name);
413     Assert.assertEquals(expectedResponse, actualResponse);
414 
415     List<String> actualRequests = mockService.getRequestPaths();
416     Assert.assertEquals(1, actualRequests.size());
417 
418     String apiClientHeaderKey =
419         mockService
420             .getRequestHeaders()
421             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
422             .iterator()
423             .next();
424     Assert.assertTrue(
425         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
426             .matcher(apiClientHeaderKey)
427             .matches());
428   }
429 
430   @Test
getOrganizationSettingsExceptionTest()431   public void getOrganizationSettingsExceptionTest() throws Exception {
432     ApiException exception =
433         ApiExceptionFactory.createException(
434             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
435     mockService.addException(exception);
436 
437     try {
438       OrganizationSettingsName name = OrganizationSettingsName.of("[ORGANIZATION]");
439       client.getOrganizationSettings(name);
440       Assert.fail("No exception raised");
441     } catch (InvalidArgumentException e) {
442       // Expected exception.
443     }
444   }
445 
446   @Test
getOrganizationSettingsTest2()447   public void getOrganizationSettingsTest2() throws Exception {
448     OrganizationSettings expectedResponse =
449         OrganizationSettings.newBuilder()
450             .setName(OrganizationSettingsName.of("[ORGANIZATION]").toString())
451             .setEnableAssetDiscovery(true)
452             .setAssetDiscoveryConfig(OrganizationSettings.AssetDiscoveryConfig.newBuilder().build())
453             .build();
454     mockService.addResponse(expectedResponse);
455 
456     String name = "organizations/organization-9995/organizationSettings";
457 
458     OrganizationSettings actualResponse = client.getOrganizationSettings(name);
459     Assert.assertEquals(expectedResponse, actualResponse);
460 
461     List<String> actualRequests = mockService.getRequestPaths();
462     Assert.assertEquals(1, actualRequests.size());
463 
464     String apiClientHeaderKey =
465         mockService
466             .getRequestHeaders()
467             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
468             .iterator()
469             .next();
470     Assert.assertTrue(
471         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
472             .matcher(apiClientHeaderKey)
473             .matches());
474   }
475 
476   @Test
getOrganizationSettingsExceptionTest2()477   public void getOrganizationSettingsExceptionTest2() throws Exception {
478     ApiException exception =
479         ApiExceptionFactory.createException(
480             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
481     mockService.addException(exception);
482 
483     try {
484       String name = "organizations/organization-9995/organizationSettings";
485       client.getOrganizationSettings(name);
486       Assert.fail("No exception raised");
487     } catch (InvalidArgumentException e) {
488       // Expected exception.
489     }
490   }
491 
492   @Test
getSourceTest()493   public void getSourceTest() throws Exception {
494     Source expectedResponse =
495         Source.newBuilder()
496             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
497             .setDisplayName("displayName1714148973")
498             .setDescription("description-1724546052")
499             .build();
500     mockService.addResponse(expectedResponse);
501 
502     SourceName name = SourceName.of("[ORGANIZATION]", "[SOURCE]");
503 
504     Source actualResponse = client.getSource(name);
505     Assert.assertEquals(expectedResponse, actualResponse);
506 
507     List<String> actualRequests = mockService.getRequestPaths();
508     Assert.assertEquals(1, actualRequests.size());
509 
510     String apiClientHeaderKey =
511         mockService
512             .getRequestHeaders()
513             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
514             .iterator()
515             .next();
516     Assert.assertTrue(
517         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
518             .matcher(apiClientHeaderKey)
519             .matches());
520   }
521 
522   @Test
getSourceExceptionTest()523   public void getSourceExceptionTest() throws Exception {
524     ApiException exception =
525         ApiExceptionFactory.createException(
526             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
527     mockService.addException(exception);
528 
529     try {
530       SourceName name = SourceName.of("[ORGANIZATION]", "[SOURCE]");
531       client.getSource(name);
532       Assert.fail("No exception raised");
533     } catch (InvalidArgumentException e) {
534       // Expected exception.
535     }
536   }
537 
538   @Test
getSourceTest2()539   public void getSourceTest2() throws Exception {
540     Source expectedResponse =
541         Source.newBuilder()
542             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
543             .setDisplayName("displayName1714148973")
544             .setDescription("description-1724546052")
545             .build();
546     mockService.addResponse(expectedResponse);
547 
548     String name = "organizations/organization-7292/sources/source-7292";
549 
550     Source actualResponse = client.getSource(name);
551     Assert.assertEquals(expectedResponse, actualResponse);
552 
553     List<String> actualRequests = mockService.getRequestPaths();
554     Assert.assertEquals(1, actualRequests.size());
555 
556     String apiClientHeaderKey =
557         mockService
558             .getRequestHeaders()
559             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
560             .iterator()
561             .next();
562     Assert.assertTrue(
563         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
564             .matcher(apiClientHeaderKey)
565             .matches());
566   }
567 
568   @Test
getSourceExceptionTest2()569   public void getSourceExceptionTest2() throws Exception {
570     ApiException exception =
571         ApiExceptionFactory.createException(
572             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
573     mockService.addException(exception);
574 
575     try {
576       String name = "organizations/organization-7292/sources/source-7292";
577       client.getSource(name);
578       Assert.fail("No exception raised");
579     } catch (InvalidArgumentException e) {
580       // Expected exception.
581     }
582   }
583 
584   @Test
groupAssetsTest()585   public void groupAssetsTest() throws Exception {
586     GroupResult responsesElement = GroupResult.newBuilder().build();
587     GroupAssetsResponse expectedResponse =
588         GroupAssetsResponse.newBuilder()
589             .setNextPageToken("")
590             .addAllGroupByResults(Arrays.asList(responsesElement))
591             .build();
592     mockService.addResponse(expectedResponse);
593 
594     GroupAssetsRequest request =
595         GroupAssetsRequest.newBuilder()
596             .setParent(OrganizationName.of("[ORGANIZATION]").toString())
597             .setFilter("filter-1274492040")
598             .setGroupBy("groupBy293428022")
599             .setCompareDuration(Duration.newBuilder().build())
600             .setReadTime(Timestamp.newBuilder().build())
601             .setPageToken("pageToken873572522")
602             .setPageSize(883849137)
603             .build();
604 
605     GroupAssetsPagedResponse pagedListResponse = client.groupAssets(request);
606 
607     List<GroupResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
608 
609     Assert.assertEquals(1, resources.size());
610     Assert.assertEquals(expectedResponse.getGroupByResultsList().get(0), resources.get(0));
611 
612     List<String> actualRequests = mockService.getRequestPaths();
613     Assert.assertEquals(1, actualRequests.size());
614 
615     String apiClientHeaderKey =
616         mockService
617             .getRequestHeaders()
618             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
619             .iterator()
620             .next();
621     Assert.assertTrue(
622         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
623             .matcher(apiClientHeaderKey)
624             .matches());
625   }
626 
627   @Test
groupAssetsExceptionTest()628   public void groupAssetsExceptionTest() throws Exception {
629     ApiException exception =
630         ApiExceptionFactory.createException(
631             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
632     mockService.addException(exception);
633 
634     try {
635       GroupAssetsRequest request =
636           GroupAssetsRequest.newBuilder()
637               .setParent(OrganizationName.of("[ORGANIZATION]").toString())
638               .setFilter("filter-1274492040")
639               .setGroupBy("groupBy293428022")
640               .setCompareDuration(Duration.newBuilder().build())
641               .setReadTime(Timestamp.newBuilder().build())
642               .setPageToken("pageToken873572522")
643               .setPageSize(883849137)
644               .build();
645       client.groupAssets(request);
646       Assert.fail("No exception raised");
647     } catch (InvalidArgumentException e) {
648       // Expected exception.
649     }
650   }
651 
652   @Test
groupFindingsTest()653   public void groupFindingsTest() throws Exception {
654     GroupResult responsesElement = GroupResult.newBuilder().build();
655     GroupFindingsResponse expectedResponse =
656         GroupFindingsResponse.newBuilder()
657             .setNextPageToken("")
658             .addAllGroupByResults(Arrays.asList(responsesElement))
659             .build();
660     mockService.addResponse(expectedResponse);
661 
662     SourceName parent = SourceName.of("[ORGANIZATION]", "[SOURCE]");
663     String groupBy = "groupBy293428022";
664 
665     GroupFindingsPagedResponse pagedListResponse = client.groupFindings(parent, groupBy);
666 
667     List<GroupResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
668 
669     Assert.assertEquals(1, resources.size());
670     Assert.assertEquals(expectedResponse.getGroupByResultsList().get(0), resources.get(0));
671 
672     List<String> actualRequests = mockService.getRequestPaths();
673     Assert.assertEquals(1, actualRequests.size());
674 
675     String apiClientHeaderKey =
676         mockService
677             .getRequestHeaders()
678             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
679             .iterator()
680             .next();
681     Assert.assertTrue(
682         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
683             .matcher(apiClientHeaderKey)
684             .matches());
685   }
686 
687   @Test
groupFindingsExceptionTest()688   public void groupFindingsExceptionTest() throws Exception {
689     ApiException exception =
690         ApiExceptionFactory.createException(
691             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
692     mockService.addException(exception);
693 
694     try {
695       SourceName parent = SourceName.of("[ORGANIZATION]", "[SOURCE]");
696       String groupBy = "groupBy293428022";
697       client.groupFindings(parent, groupBy);
698       Assert.fail("No exception raised");
699     } catch (InvalidArgumentException e) {
700       // Expected exception.
701     }
702   }
703 
704   @Test
groupFindingsTest2()705   public void groupFindingsTest2() throws Exception {
706     GroupResult responsesElement = GroupResult.newBuilder().build();
707     GroupFindingsResponse expectedResponse =
708         GroupFindingsResponse.newBuilder()
709             .setNextPageToken("")
710             .addAllGroupByResults(Arrays.asList(responsesElement))
711             .build();
712     mockService.addResponse(expectedResponse);
713 
714     String parent = "organizations/organization-8741/sources/source-8741";
715     String groupBy = "groupBy293428022";
716 
717     GroupFindingsPagedResponse pagedListResponse = client.groupFindings(parent, groupBy);
718 
719     List<GroupResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
720 
721     Assert.assertEquals(1, resources.size());
722     Assert.assertEquals(expectedResponse.getGroupByResultsList().get(0), resources.get(0));
723 
724     List<String> actualRequests = mockService.getRequestPaths();
725     Assert.assertEquals(1, actualRequests.size());
726 
727     String apiClientHeaderKey =
728         mockService
729             .getRequestHeaders()
730             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
731             .iterator()
732             .next();
733     Assert.assertTrue(
734         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
735             .matcher(apiClientHeaderKey)
736             .matches());
737   }
738 
739   @Test
groupFindingsExceptionTest2()740   public void groupFindingsExceptionTest2() throws Exception {
741     ApiException exception =
742         ApiExceptionFactory.createException(
743             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
744     mockService.addException(exception);
745 
746     try {
747       String parent = "organizations/organization-8741/sources/source-8741";
748       String groupBy = "groupBy293428022";
749       client.groupFindings(parent, groupBy);
750       Assert.fail("No exception raised");
751     } catch (InvalidArgumentException e) {
752       // Expected exception.
753     }
754   }
755 
756   @Test
listAssetsTest()757   public void listAssetsTest() throws Exception {
758     ListAssetsResponse.ListAssetsResult responsesElement =
759         ListAssetsResponse.ListAssetsResult.newBuilder().build();
760     ListAssetsResponse expectedResponse =
761         ListAssetsResponse.newBuilder()
762             .setNextPageToken("")
763             .addAllListAssetsResults(Arrays.asList(responsesElement))
764             .build();
765     mockService.addResponse(expectedResponse);
766 
767     ListAssetsRequest request =
768         ListAssetsRequest.newBuilder()
769             .setParent(OrganizationName.of("[ORGANIZATION]").toString())
770             .setFilter("filter-1274492040")
771             .setOrderBy("orderBy-1207110587")
772             .setReadTime(Timestamp.newBuilder().build())
773             .setCompareDuration(Duration.newBuilder().build())
774             .setFieldMask(FieldMask.newBuilder().build())
775             .setPageToken("pageToken873572522")
776             .setPageSize(883849137)
777             .build();
778 
779     ListAssetsPagedResponse pagedListResponse = client.listAssets(request);
780 
781     List<ListAssetsResponse.ListAssetsResult> resources =
782         Lists.newArrayList(pagedListResponse.iterateAll());
783 
784     Assert.assertEquals(1, resources.size());
785     Assert.assertEquals(expectedResponse.getListAssetsResultsList().get(0), resources.get(0));
786 
787     List<String> actualRequests = mockService.getRequestPaths();
788     Assert.assertEquals(1, actualRequests.size());
789 
790     String apiClientHeaderKey =
791         mockService
792             .getRequestHeaders()
793             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
794             .iterator()
795             .next();
796     Assert.assertTrue(
797         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
798             .matcher(apiClientHeaderKey)
799             .matches());
800   }
801 
802   @Test
listAssetsExceptionTest()803   public void listAssetsExceptionTest() throws Exception {
804     ApiException exception =
805         ApiExceptionFactory.createException(
806             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
807     mockService.addException(exception);
808 
809     try {
810       ListAssetsRequest request =
811           ListAssetsRequest.newBuilder()
812               .setParent(OrganizationName.of("[ORGANIZATION]").toString())
813               .setFilter("filter-1274492040")
814               .setOrderBy("orderBy-1207110587")
815               .setReadTime(Timestamp.newBuilder().build())
816               .setCompareDuration(Duration.newBuilder().build())
817               .setFieldMask(FieldMask.newBuilder().build())
818               .setPageToken("pageToken873572522")
819               .setPageSize(883849137)
820               .build();
821       client.listAssets(request);
822       Assert.fail("No exception raised");
823     } catch (InvalidArgumentException e) {
824       // Expected exception.
825     }
826   }
827 
828   @Test
listFindingsTest()829   public void listFindingsTest() throws Exception {
830     Finding responsesElement = Finding.newBuilder().build();
831     ListFindingsResponse expectedResponse =
832         ListFindingsResponse.newBuilder()
833             .setNextPageToken("")
834             .addAllFindings(Arrays.asList(responsesElement))
835             .build();
836     mockService.addResponse(expectedResponse);
837 
838     ListFindingsRequest request =
839         ListFindingsRequest.newBuilder()
840             .setParent(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
841             .setFilter("filter-1274492040")
842             .setOrderBy("orderBy-1207110587")
843             .setReadTime(Timestamp.newBuilder().build())
844             .setFieldMask(FieldMask.newBuilder().build())
845             .setPageToken("pageToken873572522")
846             .setPageSize(883849137)
847             .build();
848 
849     ListFindingsPagedResponse pagedListResponse = client.listFindings(request);
850 
851     List<Finding> resources = Lists.newArrayList(pagedListResponse.iterateAll());
852 
853     Assert.assertEquals(1, resources.size());
854     Assert.assertEquals(expectedResponse.getFindingsList().get(0), resources.get(0));
855 
856     List<String> actualRequests = mockService.getRequestPaths();
857     Assert.assertEquals(1, actualRequests.size());
858 
859     String apiClientHeaderKey =
860         mockService
861             .getRequestHeaders()
862             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
863             .iterator()
864             .next();
865     Assert.assertTrue(
866         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
867             .matcher(apiClientHeaderKey)
868             .matches());
869   }
870 
871   @Test
listFindingsExceptionTest()872   public void listFindingsExceptionTest() throws Exception {
873     ApiException exception =
874         ApiExceptionFactory.createException(
875             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
876     mockService.addException(exception);
877 
878     try {
879       ListFindingsRequest request =
880           ListFindingsRequest.newBuilder()
881               .setParent(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
882               .setFilter("filter-1274492040")
883               .setOrderBy("orderBy-1207110587")
884               .setReadTime(Timestamp.newBuilder().build())
885               .setFieldMask(FieldMask.newBuilder().build())
886               .setPageToken("pageToken873572522")
887               .setPageSize(883849137)
888               .build();
889       client.listFindings(request);
890       Assert.fail("No exception raised");
891     } catch (InvalidArgumentException e) {
892       // Expected exception.
893     }
894   }
895 
896   @Test
listSourcesTest()897   public void listSourcesTest() throws Exception {
898     Source responsesElement = Source.newBuilder().build();
899     ListSourcesResponse expectedResponse =
900         ListSourcesResponse.newBuilder()
901             .setNextPageToken("")
902             .addAllSources(Arrays.asList(responsesElement))
903             .build();
904     mockService.addResponse(expectedResponse);
905 
906     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
907 
908     ListSourcesPagedResponse pagedListResponse = client.listSources(parent);
909 
910     List<Source> resources = Lists.newArrayList(pagedListResponse.iterateAll());
911 
912     Assert.assertEquals(1, resources.size());
913     Assert.assertEquals(expectedResponse.getSourcesList().get(0), resources.get(0));
914 
915     List<String> actualRequests = mockService.getRequestPaths();
916     Assert.assertEquals(1, actualRequests.size());
917 
918     String apiClientHeaderKey =
919         mockService
920             .getRequestHeaders()
921             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
922             .iterator()
923             .next();
924     Assert.assertTrue(
925         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
926             .matcher(apiClientHeaderKey)
927             .matches());
928   }
929 
930   @Test
listSourcesExceptionTest()931   public void listSourcesExceptionTest() throws Exception {
932     ApiException exception =
933         ApiExceptionFactory.createException(
934             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
935     mockService.addException(exception);
936 
937     try {
938       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
939       client.listSources(parent);
940       Assert.fail("No exception raised");
941     } catch (InvalidArgumentException e) {
942       // Expected exception.
943     }
944   }
945 
946   @Test
listSourcesTest2()947   public void listSourcesTest2() throws Exception {
948     Source responsesElement = Source.newBuilder().build();
949     ListSourcesResponse expectedResponse =
950         ListSourcesResponse.newBuilder()
951             .setNextPageToken("")
952             .addAllSources(Arrays.asList(responsesElement))
953             .build();
954     mockService.addResponse(expectedResponse);
955 
956     String parent = "organizations/organization-8287";
957 
958     ListSourcesPagedResponse pagedListResponse = client.listSources(parent);
959 
960     List<Source> resources = Lists.newArrayList(pagedListResponse.iterateAll());
961 
962     Assert.assertEquals(1, resources.size());
963     Assert.assertEquals(expectedResponse.getSourcesList().get(0), resources.get(0));
964 
965     List<String> actualRequests = mockService.getRequestPaths();
966     Assert.assertEquals(1, actualRequests.size());
967 
968     String apiClientHeaderKey =
969         mockService
970             .getRequestHeaders()
971             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
972             .iterator()
973             .next();
974     Assert.assertTrue(
975         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
976             .matcher(apiClientHeaderKey)
977             .matches());
978   }
979 
980   @Test
listSourcesExceptionTest2()981   public void listSourcesExceptionTest2() throws Exception {
982     ApiException exception =
983         ApiExceptionFactory.createException(
984             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
985     mockService.addException(exception);
986 
987     try {
988       String parent = "organizations/organization-8287";
989       client.listSources(parent);
990       Assert.fail("No exception raised");
991     } catch (InvalidArgumentException e) {
992       // Expected exception.
993     }
994   }
995 
996   @Test
runAssetDiscoveryTest()997   public void runAssetDiscoveryTest() throws Exception {
998     Empty expectedResponse = Empty.newBuilder().build();
999     Operation resultOperation =
1000         Operation.newBuilder()
1001             .setName("runAssetDiscoveryTest")
1002             .setDone(true)
1003             .setResponse(Any.pack(expectedResponse))
1004             .build();
1005     mockService.addResponse(resultOperation);
1006 
1007     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1008 
1009     client.runAssetDiscoveryAsync(parent).get();
1010 
1011     List<String> actualRequests = mockService.getRequestPaths();
1012     Assert.assertEquals(1, actualRequests.size());
1013 
1014     String apiClientHeaderKey =
1015         mockService
1016             .getRequestHeaders()
1017             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1018             .iterator()
1019             .next();
1020     Assert.assertTrue(
1021         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1022             .matcher(apiClientHeaderKey)
1023             .matches());
1024   }
1025 
1026   @Test
runAssetDiscoveryExceptionTest()1027   public void runAssetDiscoveryExceptionTest() throws Exception {
1028     ApiException exception =
1029         ApiExceptionFactory.createException(
1030             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1031     mockService.addException(exception);
1032 
1033     try {
1034       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1035       client.runAssetDiscoveryAsync(parent).get();
1036       Assert.fail("No exception raised");
1037     } catch (ExecutionException e) {
1038     }
1039   }
1040 
1041   @Test
runAssetDiscoveryTest2()1042   public void runAssetDiscoveryTest2() throws Exception {
1043     Empty expectedResponse = Empty.newBuilder().build();
1044     Operation resultOperation =
1045         Operation.newBuilder()
1046             .setName("runAssetDiscoveryTest")
1047             .setDone(true)
1048             .setResponse(Any.pack(expectedResponse))
1049             .build();
1050     mockService.addResponse(resultOperation);
1051 
1052     String parent = "organizations/organization-8287";
1053 
1054     client.runAssetDiscoveryAsync(parent).get();
1055 
1056     List<String> actualRequests = mockService.getRequestPaths();
1057     Assert.assertEquals(1, actualRequests.size());
1058 
1059     String apiClientHeaderKey =
1060         mockService
1061             .getRequestHeaders()
1062             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1063             .iterator()
1064             .next();
1065     Assert.assertTrue(
1066         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1067             .matcher(apiClientHeaderKey)
1068             .matches());
1069   }
1070 
1071   @Test
runAssetDiscoveryExceptionTest2()1072   public void runAssetDiscoveryExceptionTest2() throws Exception {
1073     ApiException exception =
1074         ApiExceptionFactory.createException(
1075             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1076     mockService.addException(exception);
1077 
1078     try {
1079       String parent = "organizations/organization-8287";
1080       client.runAssetDiscoveryAsync(parent).get();
1081       Assert.fail("No exception raised");
1082     } catch (ExecutionException e) {
1083     }
1084   }
1085 
1086   @Test
setFindingStateTest()1087   public void setFindingStateTest() throws Exception {
1088     Finding expectedResponse =
1089         Finding.newBuilder()
1090             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
1091             .setParent("parent-995424086")
1092             .setResourceName("resourceName-384566343")
1093             .setCategory("category50511102")
1094             .setExternalUri("externalUri-1153085023")
1095             .putAllSourceProperties(new HashMap<String, Value>())
1096             .setSecurityMarks(SecurityMarks.newBuilder().build())
1097             .setEventTime(Timestamp.newBuilder().build())
1098             .setCreateTime(Timestamp.newBuilder().build())
1099             .build();
1100     mockService.addResponse(expectedResponse);
1101 
1102     FindingName name = FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]");
1103     Finding.State state = Finding.State.forNumber(0);
1104     Timestamp startTime = Timestamp.newBuilder().build();
1105 
1106     Finding actualResponse = client.setFindingState(name, state, startTime);
1107     Assert.assertEquals(expectedResponse, actualResponse);
1108 
1109     List<String> actualRequests = mockService.getRequestPaths();
1110     Assert.assertEquals(1, actualRequests.size());
1111 
1112     String apiClientHeaderKey =
1113         mockService
1114             .getRequestHeaders()
1115             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1116             .iterator()
1117             .next();
1118     Assert.assertTrue(
1119         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1120             .matcher(apiClientHeaderKey)
1121             .matches());
1122   }
1123 
1124   @Test
setFindingStateExceptionTest()1125   public void setFindingStateExceptionTest() throws Exception {
1126     ApiException exception =
1127         ApiExceptionFactory.createException(
1128             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1129     mockService.addException(exception);
1130 
1131     try {
1132       FindingName name = FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]");
1133       Finding.State state = Finding.State.forNumber(0);
1134       Timestamp startTime = Timestamp.newBuilder().build();
1135       client.setFindingState(name, state, startTime);
1136       Assert.fail("No exception raised");
1137     } catch (InvalidArgumentException e) {
1138       // Expected exception.
1139     }
1140   }
1141 
1142   @Test
setFindingStateTest2()1143   public void setFindingStateTest2() throws Exception {
1144     Finding expectedResponse =
1145         Finding.newBuilder()
1146             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
1147             .setParent("parent-995424086")
1148             .setResourceName("resourceName-384566343")
1149             .setCategory("category50511102")
1150             .setExternalUri("externalUri-1153085023")
1151             .putAllSourceProperties(new HashMap<String, Value>())
1152             .setSecurityMarks(SecurityMarks.newBuilder().build())
1153             .setEventTime(Timestamp.newBuilder().build())
1154             .setCreateTime(Timestamp.newBuilder().build())
1155             .build();
1156     mockService.addResponse(expectedResponse);
1157 
1158     String name = "organizations/organization-9392/sources/source-9392/findings/finding-9392";
1159     Finding.State state = Finding.State.forNumber(0);
1160     Timestamp startTime = Timestamp.newBuilder().build();
1161 
1162     Finding actualResponse = client.setFindingState(name, state, startTime);
1163     Assert.assertEquals(expectedResponse, actualResponse);
1164 
1165     List<String> actualRequests = mockService.getRequestPaths();
1166     Assert.assertEquals(1, actualRequests.size());
1167 
1168     String apiClientHeaderKey =
1169         mockService
1170             .getRequestHeaders()
1171             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1172             .iterator()
1173             .next();
1174     Assert.assertTrue(
1175         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1176             .matcher(apiClientHeaderKey)
1177             .matches());
1178   }
1179 
1180   @Test
setFindingStateExceptionTest2()1181   public void setFindingStateExceptionTest2() throws Exception {
1182     ApiException exception =
1183         ApiExceptionFactory.createException(
1184             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1185     mockService.addException(exception);
1186 
1187     try {
1188       String name = "organizations/organization-9392/sources/source-9392/findings/finding-9392";
1189       Finding.State state = Finding.State.forNumber(0);
1190       Timestamp startTime = Timestamp.newBuilder().build();
1191       client.setFindingState(name, state, startTime);
1192       Assert.fail("No exception raised");
1193     } catch (InvalidArgumentException e) {
1194       // Expected exception.
1195     }
1196   }
1197 
1198   @Test
setIamPolicyTest()1199   public void setIamPolicyTest() throws Exception {
1200     Policy expectedResponse =
1201         Policy.newBuilder()
1202             .setVersion(351608024)
1203             .addAllBindings(new ArrayList<Binding>())
1204             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1205             .setEtag(ByteString.EMPTY)
1206             .build();
1207     mockService.addResponse(expectedResponse);
1208 
1209     ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
1210     Policy policy = Policy.newBuilder().build();
1211 
1212     Policy actualResponse = client.setIamPolicy(resource, policy);
1213     Assert.assertEquals(expectedResponse, actualResponse);
1214 
1215     List<String> actualRequests = mockService.getRequestPaths();
1216     Assert.assertEquals(1, actualRequests.size());
1217 
1218     String apiClientHeaderKey =
1219         mockService
1220             .getRequestHeaders()
1221             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1222             .iterator()
1223             .next();
1224     Assert.assertTrue(
1225         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1226             .matcher(apiClientHeaderKey)
1227             .matches());
1228   }
1229 
1230   @Test
setIamPolicyExceptionTest()1231   public void setIamPolicyExceptionTest() throws Exception {
1232     ApiException exception =
1233         ApiExceptionFactory.createException(
1234             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1235     mockService.addException(exception);
1236 
1237     try {
1238       ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
1239       Policy policy = Policy.newBuilder().build();
1240       client.setIamPolicy(resource, policy);
1241       Assert.fail("No exception raised");
1242     } catch (InvalidArgumentException e) {
1243       // Expected exception.
1244     }
1245   }
1246 
1247   @Test
setIamPolicyTest2()1248   public void setIamPolicyTest2() throws Exception {
1249     Policy expectedResponse =
1250         Policy.newBuilder()
1251             .setVersion(351608024)
1252             .addAllBindings(new ArrayList<Binding>())
1253             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1254             .setEtag(ByteString.EMPTY)
1255             .build();
1256     mockService.addResponse(expectedResponse);
1257 
1258     String resource = "organizations/organization-3393/sources/source-3393";
1259     Policy policy = Policy.newBuilder().build();
1260 
1261     Policy actualResponse = client.setIamPolicy(resource, policy);
1262     Assert.assertEquals(expectedResponse, actualResponse);
1263 
1264     List<String> actualRequests = mockService.getRequestPaths();
1265     Assert.assertEquals(1, actualRequests.size());
1266 
1267     String apiClientHeaderKey =
1268         mockService
1269             .getRequestHeaders()
1270             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1271             .iterator()
1272             .next();
1273     Assert.assertTrue(
1274         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1275             .matcher(apiClientHeaderKey)
1276             .matches());
1277   }
1278 
1279   @Test
setIamPolicyExceptionTest2()1280   public void setIamPolicyExceptionTest2() throws Exception {
1281     ApiException exception =
1282         ApiExceptionFactory.createException(
1283             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1284     mockService.addException(exception);
1285 
1286     try {
1287       String resource = "organizations/organization-3393/sources/source-3393";
1288       Policy policy = Policy.newBuilder().build();
1289       client.setIamPolicy(resource, policy);
1290       Assert.fail("No exception raised");
1291     } catch (InvalidArgumentException e) {
1292       // Expected exception.
1293     }
1294   }
1295 
1296   @Test
testIamPermissionsTest()1297   public void testIamPermissionsTest() throws Exception {
1298     TestIamPermissionsResponse expectedResponse =
1299         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1300     mockService.addResponse(expectedResponse);
1301 
1302     ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
1303     List<String> permissions = new ArrayList<>();
1304 
1305     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
1306     Assert.assertEquals(expectedResponse, actualResponse);
1307 
1308     List<String> actualRequests = mockService.getRequestPaths();
1309     Assert.assertEquals(1, actualRequests.size());
1310 
1311     String apiClientHeaderKey =
1312         mockService
1313             .getRequestHeaders()
1314             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1315             .iterator()
1316             .next();
1317     Assert.assertTrue(
1318         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1319             .matcher(apiClientHeaderKey)
1320             .matches());
1321   }
1322 
1323   @Test
testIamPermissionsExceptionTest()1324   public void testIamPermissionsExceptionTest() throws Exception {
1325     ApiException exception =
1326         ApiExceptionFactory.createException(
1327             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1328     mockService.addException(exception);
1329 
1330     try {
1331       ResourceName resource = SourceName.of("[ORGANIZATION]", "[SOURCE]");
1332       List<String> permissions = new ArrayList<>();
1333       client.testIamPermissions(resource, permissions);
1334       Assert.fail("No exception raised");
1335     } catch (InvalidArgumentException e) {
1336       // Expected exception.
1337     }
1338   }
1339 
1340   @Test
testIamPermissionsTest2()1341   public void testIamPermissionsTest2() throws Exception {
1342     TestIamPermissionsResponse expectedResponse =
1343         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1344     mockService.addResponse(expectedResponse);
1345 
1346     String resource = "organizations/organization-3393/sources/source-3393";
1347     List<String> permissions = new ArrayList<>();
1348 
1349     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
1350     Assert.assertEquals(expectedResponse, actualResponse);
1351 
1352     List<String> actualRequests = mockService.getRequestPaths();
1353     Assert.assertEquals(1, actualRequests.size());
1354 
1355     String apiClientHeaderKey =
1356         mockService
1357             .getRequestHeaders()
1358             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1359             .iterator()
1360             .next();
1361     Assert.assertTrue(
1362         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1363             .matcher(apiClientHeaderKey)
1364             .matches());
1365   }
1366 
1367   @Test
testIamPermissionsExceptionTest2()1368   public void testIamPermissionsExceptionTest2() throws Exception {
1369     ApiException exception =
1370         ApiExceptionFactory.createException(
1371             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1372     mockService.addException(exception);
1373 
1374     try {
1375       String resource = "organizations/organization-3393/sources/source-3393";
1376       List<String> permissions = new ArrayList<>();
1377       client.testIamPermissions(resource, permissions);
1378       Assert.fail("No exception raised");
1379     } catch (InvalidArgumentException e) {
1380       // Expected exception.
1381     }
1382   }
1383 
1384   @Test
updateFindingTest()1385   public void updateFindingTest() throws Exception {
1386     Finding expectedResponse =
1387         Finding.newBuilder()
1388             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
1389             .setParent("parent-995424086")
1390             .setResourceName("resourceName-384566343")
1391             .setCategory("category50511102")
1392             .setExternalUri("externalUri-1153085023")
1393             .putAllSourceProperties(new HashMap<String, Value>())
1394             .setSecurityMarks(SecurityMarks.newBuilder().build())
1395             .setEventTime(Timestamp.newBuilder().build())
1396             .setCreateTime(Timestamp.newBuilder().build())
1397             .build();
1398     mockService.addResponse(expectedResponse);
1399 
1400     Finding finding =
1401         Finding.newBuilder()
1402             .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
1403             .setParent("parent-995424086")
1404             .setResourceName("resourceName-384566343")
1405             .setCategory("category50511102")
1406             .setExternalUri("externalUri-1153085023")
1407             .putAllSourceProperties(new HashMap<String, Value>())
1408             .setSecurityMarks(SecurityMarks.newBuilder().build())
1409             .setEventTime(Timestamp.newBuilder().build())
1410             .setCreateTime(Timestamp.newBuilder().build())
1411             .build();
1412 
1413     Finding actualResponse = client.updateFinding(finding);
1414     Assert.assertEquals(expectedResponse, actualResponse);
1415 
1416     List<String> actualRequests = mockService.getRequestPaths();
1417     Assert.assertEquals(1, actualRequests.size());
1418 
1419     String apiClientHeaderKey =
1420         mockService
1421             .getRequestHeaders()
1422             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1423             .iterator()
1424             .next();
1425     Assert.assertTrue(
1426         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1427             .matcher(apiClientHeaderKey)
1428             .matches());
1429   }
1430 
1431   @Test
updateFindingExceptionTest()1432   public void updateFindingExceptionTest() throws Exception {
1433     ApiException exception =
1434         ApiExceptionFactory.createException(
1435             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1436     mockService.addException(exception);
1437 
1438     try {
1439       Finding finding =
1440           Finding.newBuilder()
1441               .setName(FindingName.of("[ORGANIZATION]", "[SOURCE]", "[FINDING]").toString())
1442               .setParent("parent-995424086")
1443               .setResourceName("resourceName-384566343")
1444               .setCategory("category50511102")
1445               .setExternalUri("externalUri-1153085023")
1446               .putAllSourceProperties(new HashMap<String, Value>())
1447               .setSecurityMarks(SecurityMarks.newBuilder().build())
1448               .setEventTime(Timestamp.newBuilder().build())
1449               .setCreateTime(Timestamp.newBuilder().build())
1450               .build();
1451       client.updateFinding(finding);
1452       Assert.fail("No exception raised");
1453     } catch (InvalidArgumentException e) {
1454       // Expected exception.
1455     }
1456   }
1457 
1458   @Test
updateOrganizationSettingsTest()1459   public void updateOrganizationSettingsTest() throws Exception {
1460     OrganizationSettings expectedResponse =
1461         OrganizationSettings.newBuilder()
1462             .setName(OrganizationSettingsName.of("[ORGANIZATION]").toString())
1463             .setEnableAssetDiscovery(true)
1464             .setAssetDiscoveryConfig(OrganizationSettings.AssetDiscoveryConfig.newBuilder().build())
1465             .build();
1466     mockService.addResponse(expectedResponse);
1467 
1468     OrganizationSettings organizationSettings =
1469         OrganizationSettings.newBuilder()
1470             .setName(OrganizationSettingsName.of("[ORGANIZATION]").toString())
1471             .setEnableAssetDiscovery(true)
1472             .setAssetDiscoveryConfig(OrganizationSettings.AssetDiscoveryConfig.newBuilder().build())
1473             .build();
1474 
1475     OrganizationSettings actualResponse = client.updateOrganizationSettings(organizationSettings);
1476     Assert.assertEquals(expectedResponse, actualResponse);
1477 
1478     List<String> actualRequests = mockService.getRequestPaths();
1479     Assert.assertEquals(1, actualRequests.size());
1480 
1481     String apiClientHeaderKey =
1482         mockService
1483             .getRequestHeaders()
1484             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1485             .iterator()
1486             .next();
1487     Assert.assertTrue(
1488         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1489             .matcher(apiClientHeaderKey)
1490             .matches());
1491   }
1492 
1493   @Test
updateOrganizationSettingsExceptionTest()1494   public void updateOrganizationSettingsExceptionTest() throws Exception {
1495     ApiException exception =
1496         ApiExceptionFactory.createException(
1497             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1498     mockService.addException(exception);
1499 
1500     try {
1501       OrganizationSettings organizationSettings =
1502           OrganizationSettings.newBuilder()
1503               .setName(OrganizationSettingsName.of("[ORGANIZATION]").toString())
1504               .setEnableAssetDiscovery(true)
1505               .setAssetDiscoveryConfig(
1506                   OrganizationSettings.AssetDiscoveryConfig.newBuilder().build())
1507               .build();
1508       client.updateOrganizationSettings(organizationSettings);
1509       Assert.fail("No exception raised");
1510     } catch (InvalidArgumentException e) {
1511       // Expected exception.
1512     }
1513   }
1514 
1515   @Test
updateSourceTest()1516   public void updateSourceTest() throws Exception {
1517     Source expectedResponse =
1518         Source.newBuilder()
1519             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
1520             .setDisplayName("displayName1714148973")
1521             .setDescription("description-1724546052")
1522             .build();
1523     mockService.addResponse(expectedResponse);
1524 
1525     Source source =
1526         Source.newBuilder()
1527             .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
1528             .setDisplayName("displayName1714148973")
1529             .setDescription("description-1724546052")
1530             .build();
1531 
1532     Source actualResponse = client.updateSource(source);
1533     Assert.assertEquals(expectedResponse, actualResponse);
1534 
1535     List<String> actualRequests = mockService.getRequestPaths();
1536     Assert.assertEquals(1, actualRequests.size());
1537 
1538     String apiClientHeaderKey =
1539         mockService
1540             .getRequestHeaders()
1541             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1542             .iterator()
1543             .next();
1544     Assert.assertTrue(
1545         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1546             .matcher(apiClientHeaderKey)
1547             .matches());
1548   }
1549 
1550   @Test
updateSourceExceptionTest()1551   public void updateSourceExceptionTest() throws Exception {
1552     ApiException exception =
1553         ApiExceptionFactory.createException(
1554             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1555     mockService.addException(exception);
1556 
1557     try {
1558       Source source =
1559           Source.newBuilder()
1560               .setName(SourceName.of("[ORGANIZATION]", "[SOURCE]").toString())
1561               .setDisplayName("displayName1714148973")
1562               .setDescription("description-1724546052")
1563               .build();
1564       client.updateSource(source);
1565       Assert.fail("No exception raised");
1566     } catch (InvalidArgumentException e) {
1567       // Expected exception.
1568     }
1569   }
1570 
1571   @Test
updateSecurityMarksTest()1572   public void updateSecurityMarksTest() throws Exception {
1573     SecurityMarks expectedResponse =
1574         SecurityMarks.newBuilder()
1575             .setName("name3373707")
1576             .putAllMarks(new HashMap<String, String>())
1577             .build();
1578     mockService.addResponse(expectedResponse);
1579 
1580     SecurityMarks securityMarks =
1581         SecurityMarks.newBuilder()
1582             .setName("organizations/organization-5924/assets/asset-5924/securityMarks")
1583             .putAllMarks(new HashMap<String, String>())
1584             .build();
1585 
1586     SecurityMarks actualResponse = client.updateSecurityMarks(securityMarks);
1587     Assert.assertEquals(expectedResponse, actualResponse);
1588 
1589     List<String> actualRequests = mockService.getRequestPaths();
1590     Assert.assertEquals(1, actualRequests.size());
1591 
1592     String apiClientHeaderKey =
1593         mockService
1594             .getRequestHeaders()
1595             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1596             .iterator()
1597             .next();
1598     Assert.assertTrue(
1599         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1600             .matcher(apiClientHeaderKey)
1601             .matches());
1602   }
1603 
1604   @Test
updateSecurityMarksExceptionTest()1605   public void updateSecurityMarksExceptionTest() throws Exception {
1606     ApiException exception =
1607         ApiExceptionFactory.createException(
1608             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1609     mockService.addException(exception);
1610 
1611     try {
1612       SecurityMarks securityMarks =
1613           SecurityMarks.newBuilder()
1614               .setName("organizations/organization-5924/assets/asset-5924/securityMarks")
1615               .putAllMarks(new HashMap<String, String>())
1616               .build();
1617       client.updateSecurityMarks(securityMarks);
1618       Assert.fail("No exception raised");
1619     } catch (InvalidArgumentException e) {
1620       // Expected exception.
1621     }
1622   }
1623 }
1624