• 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.protos.google.cloud.binaryauthorization.v1;
18 
19 import static com.google.protos.google.cloud.binaryauthorization.v1.BinauthzManagementServiceV1Client.ListAttestorsPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
23 import com.google.api.gax.httpjson.testing.MockHttpService;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.ApiException;
26 import com.google.api.gax.rpc.ApiExceptionFactory;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.api.gax.rpc.testing.FakeStatusCode;
30 import com.google.common.collect.Lists;
31 import com.google.protobuf.Empty;
32 import com.google.protobuf.Timestamp;
33 import com.google.protos.google.cloud.binaryauthorization.v1.stub.HttpJsonBinauthzManagementServiceV1Stub;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.HashMap;
38 import java.util.List;
39 import javax.annotation.Generated;
40 import org.junit.After;
41 import org.junit.AfterClass;
42 import org.junit.Assert;
43 import org.junit.Before;
44 import org.junit.BeforeClass;
45 import org.junit.Test;
46 
47 @Generated("by gapic-generator-java")
48 public class BinauthzManagementServiceV1ClientHttpJsonTest {
49   private static MockHttpService mockService;
50   private static BinauthzManagementServiceV1Client client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonBinauthzManagementServiceV1Stub.getMethodDescriptors(),
57             BinauthzManagementServiceV1Settings.getDefaultEndpoint());
58     BinauthzManagementServiceV1Settings settings =
59         BinauthzManagementServiceV1Settings.newHttpJsonBuilder()
60             .setTransportChannelProvider(
61                 BinauthzManagementServiceV1Settings.defaultHttpJsonTransportProviderBuilder()
62                     .setHttpTransport(mockService)
63                     .build())
64             .setCredentialsProvider(NoCredentialsProvider.create())
65             .build();
66     client = BinauthzManagementServiceV1Client.create(settings);
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     client.close();
72   }
73 
74   @Before
setUp()75   public void setUp() {}
76 
77   @After
tearDown()78   public void tearDown() throws Exception {
79     mockService.reset();
80   }
81 
82   @Test
getPolicyTest()83   public void getPolicyTest() throws Exception {
84     Resources.Policy expectedResponse =
85         Resources.Policy.newBuilder()
86             .setName(PolicyName.ofProjectName("[PROJECT]").toString())
87             .setDescription("description-1724546052")
88             .addAllAdmissionWhitelistPatterns(new ArrayList<Resources.AdmissionWhitelistPattern>())
89             .putAllClusterAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
90             .putAllKubernetesNamespaceAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
91             .putAllKubernetesServiceAccountAdmissionRules(
92                 new HashMap<String, Resources.AdmissionRule>())
93             .putAllIstioServiceIdentityAdmissionRules(
94                 new HashMap<String, Resources.AdmissionRule>())
95             .setDefaultAdmissionRule(Resources.AdmissionRule.newBuilder().build())
96             .setUpdateTime(Timestamp.newBuilder().build())
97             .build();
98     mockService.addResponse(expectedResponse);
99 
100     PolicyName name = PolicyName.ofProjectName("[PROJECT]");
101 
102     Resources.Policy actualResponse = client.getPolicy(name);
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<String> actualRequests = mockService.getRequestPaths();
106     Assert.assertEquals(1, actualRequests.size());
107 
108     String apiClientHeaderKey =
109         mockService
110             .getRequestHeaders()
111             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
112             .iterator()
113             .next();
114     Assert.assertTrue(
115         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
116             .matcher(apiClientHeaderKey)
117             .matches());
118   }
119 
120   @Test
getPolicyExceptionTest()121   public void getPolicyExceptionTest() throws Exception {
122     ApiException exception =
123         ApiExceptionFactory.createException(
124             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
125     mockService.addException(exception);
126 
127     try {
128       PolicyName name = PolicyName.ofProjectName("[PROJECT]");
129       client.getPolicy(name);
130       Assert.fail("No exception raised");
131     } catch (InvalidArgumentException e) {
132       // Expected exception.
133     }
134   }
135 
136   @Test
getPolicyTest2()137   public void getPolicyTest2() throws Exception {
138     Resources.Policy expectedResponse =
139         Resources.Policy.newBuilder()
140             .setName(PolicyName.ofProjectName("[PROJECT]").toString())
141             .setDescription("description-1724546052")
142             .addAllAdmissionWhitelistPatterns(new ArrayList<Resources.AdmissionWhitelistPattern>())
143             .putAllClusterAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
144             .putAllKubernetesNamespaceAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
145             .putAllKubernetesServiceAccountAdmissionRules(
146                 new HashMap<String, Resources.AdmissionRule>())
147             .putAllIstioServiceIdentityAdmissionRules(
148                 new HashMap<String, Resources.AdmissionRule>())
149             .setDefaultAdmissionRule(Resources.AdmissionRule.newBuilder().build())
150             .setUpdateTime(Timestamp.newBuilder().build())
151             .build();
152     mockService.addResponse(expectedResponse);
153 
154     String name = "projects/project-415/policy";
155 
156     Resources.Policy actualResponse = client.getPolicy(name);
157     Assert.assertEquals(expectedResponse, actualResponse);
158 
159     List<String> actualRequests = mockService.getRequestPaths();
160     Assert.assertEquals(1, actualRequests.size());
161 
162     String apiClientHeaderKey =
163         mockService
164             .getRequestHeaders()
165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
166             .iterator()
167             .next();
168     Assert.assertTrue(
169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
170             .matcher(apiClientHeaderKey)
171             .matches());
172   }
173 
174   @Test
getPolicyExceptionTest2()175   public void getPolicyExceptionTest2() throws Exception {
176     ApiException exception =
177         ApiExceptionFactory.createException(
178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
179     mockService.addException(exception);
180 
181     try {
182       String name = "projects/project-415/policy";
183       client.getPolicy(name);
184       Assert.fail("No exception raised");
185     } catch (InvalidArgumentException e) {
186       // Expected exception.
187     }
188   }
189 
190   @Test
updatePolicyTest()191   public void updatePolicyTest() throws Exception {
192     Resources.Policy expectedResponse =
193         Resources.Policy.newBuilder()
194             .setName(PolicyName.ofProjectName("[PROJECT]").toString())
195             .setDescription("description-1724546052")
196             .addAllAdmissionWhitelistPatterns(new ArrayList<Resources.AdmissionWhitelistPattern>())
197             .putAllClusterAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
198             .putAllKubernetesNamespaceAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
199             .putAllKubernetesServiceAccountAdmissionRules(
200                 new HashMap<String, Resources.AdmissionRule>())
201             .putAllIstioServiceIdentityAdmissionRules(
202                 new HashMap<String, Resources.AdmissionRule>())
203             .setDefaultAdmissionRule(Resources.AdmissionRule.newBuilder().build())
204             .setUpdateTime(Timestamp.newBuilder().build())
205             .build();
206     mockService.addResponse(expectedResponse);
207 
208     Resources.Policy policy =
209         Resources.Policy.newBuilder()
210             .setName(PolicyName.ofProjectName("[PROJECT]").toString())
211             .setDescription("description-1724546052")
212             .addAllAdmissionWhitelistPatterns(new ArrayList<Resources.AdmissionWhitelistPattern>())
213             .putAllClusterAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
214             .putAllKubernetesNamespaceAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
215             .putAllKubernetesServiceAccountAdmissionRules(
216                 new HashMap<String, Resources.AdmissionRule>())
217             .putAllIstioServiceIdentityAdmissionRules(
218                 new HashMap<String, Resources.AdmissionRule>())
219             .setDefaultAdmissionRule(Resources.AdmissionRule.newBuilder().build())
220             .setUpdateTime(Timestamp.newBuilder().build())
221             .build();
222 
223     Resources.Policy actualResponse = client.updatePolicy(policy);
224     Assert.assertEquals(expectedResponse, actualResponse);
225 
226     List<String> actualRequests = mockService.getRequestPaths();
227     Assert.assertEquals(1, actualRequests.size());
228 
229     String apiClientHeaderKey =
230         mockService
231             .getRequestHeaders()
232             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
233             .iterator()
234             .next();
235     Assert.assertTrue(
236         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
237             .matcher(apiClientHeaderKey)
238             .matches());
239   }
240 
241   @Test
updatePolicyExceptionTest()242   public void updatePolicyExceptionTest() throws Exception {
243     ApiException exception =
244         ApiExceptionFactory.createException(
245             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
246     mockService.addException(exception);
247 
248     try {
249       Resources.Policy policy =
250           Resources.Policy.newBuilder()
251               .setName(PolicyName.ofProjectName("[PROJECT]").toString())
252               .setDescription("description-1724546052")
253               .addAllAdmissionWhitelistPatterns(
254                   new ArrayList<Resources.AdmissionWhitelistPattern>())
255               .putAllClusterAdmissionRules(new HashMap<String, Resources.AdmissionRule>())
256               .putAllKubernetesNamespaceAdmissionRules(
257                   new HashMap<String, Resources.AdmissionRule>())
258               .putAllKubernetesServiceAccountAdmissionRules(
259                   new HashMap<String, Resources.AdmissionRule>())
260               .putAllIstioServiceIdentityAdmissionRules(
261                   new HashMap<String, Resources.AdmissionRule>())
262               .setDefaultAdmissionRule(Resources.AdmissionRule.newBuilder().build())
263               .setUpdateTime(Timestamp.newBuilder().build())
264               .build();
265       client.updatePolicy(policy);
266       Assert.fail("No exception raised");
267     } catch (InvalidArgumentException e) {
268       // Expected exception.
269     }
270   }
271 
272   @Test
createAttestorTest()273   public void createAttestorTest() throws Exception {
274     Resources.Attestor expectedResponse =
275         Resources.Attestor.newBuilder()
276             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
277             .setDescription("description-1724546052")
278             .setUpdateTime(Timestamp.newBuilder().build())
279             .build();
280     mockService.addResponse(expectedResponse);
281 
282     ProjectName parent = ProjectName.of("[PROJECT]");
283     String attestorId = "attestorId2055733027";
284     Resources.Attestor attestor = Resources.Attestor.newBuilder().build();
285 
286     Resources.Attestor actualResponse = client.createAttestor(parent, attestorId, attestor);
287     Assert.assertEquals(expectedResponse, actualResponse);
288 
289     List<String> actualRequests = mockService.getRequestPaths();
290     Assert.assertEquals(1, actualRequests.size());
291 
292     String apiClientHeaderKey =
293         mockService
294             .getRequestHeaders()
295             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
296             .iterator()
297             .next();
298     Assert.assertTrue(
299         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
300             .matcher(apiClientHeaderKey)
301             .matches());
302   }
303 
304   @Test
createAttestorExceptionTest()305   public void createAttestorExceptionTest() throws Exception {
306     ApiException exception =
307         ApiExceptionFactory.createException(
308             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
309     mockService.addException(exception);
310 
311     try {
312       ProjectName parent = ProjectName.of("[PROJECT]");
313       String attestorId = "attestorId2055733027";
314       Resources.Attestor attestor = Resources.Attestor.newBuilder().build();
315       client.createAttestor(parent, attestorId, attestor);
316       Assert.fail("No exception raised");
317     } catch (InvalidArgumentException e) {
318       // Expected exception.
319     }
320   }
321 
322   @Test
createAttestorTest2()323   public void createAttestorTest2() throws Exception {
324     Resources.Attestor expectedResponse =
325         Resources.Attestor.newBuilder()
326             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
327             .setDescription("description-1724546052")
328             .setUpdateTime(Timestamp.newBuilder().build())
329             .build();
330     mockService.addResponse(expectedResponse);
331 
332     String parent = "projects/project-2353";
333     String attestorId = "attestorId2055733027";
334     Resources.Attestor attestor = Resources.Attestor.newBuilder().build();
335 
336     Resources.Attestor actualResponse = client.createAttestor(parent, attestorId, attestor);
337     Assert.assertEquals(expectedResponse, actualResponse);
338 
339     List<String> actualRequests = mockService.getRequestPaths();
340     Assert.assertEquals(1, actualRequests.size());
341 
342     String apiClientHeaderKey =
343         mockService
344             .getRequestHeaders()
345             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
346             .iterator()
347             .next();
348     Assert.assertTrue(
349         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
350             .matcher(apiClientHeaderKey)
351             .matches());
352   }
353 
354   @Test
createAttestorExceptionTest2()355   public void createAttestorExceptionTest2() throws Exception {
356     ApiException exception =
357         ApiExceptionFactory.createException(
358             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
359     mockService.addException(exception);
360 
361     try {
362       String parent = "projects/project-2353";
363       String attestorId = "attestorId2055733027";
364       Resources.Attestor attestor = Resources.Attestor.newBuilder().build();
365       client.createAttestor(parent, attestorId, attestor);
366       Assert.fail("No exception raised");
367     } catch (InvalidArgumentException e) {
368       // Expected exception.
369     }
370   }
371 
372   @Test
getAttestorTest()373   public void getAttestorTest() throws Exception {
374     Resources.Attestor expectedResponse =
375         Resources.Attestor.newBuilder()
376             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
377             .setDescription("description-1724546052")
378             .setUpdateTime(Timestamp.newBuilder().build())
379             .build();
380     mockService.addResponse(expectedResponse);
381 
382     AttestorName name = AttestorName.of("[PROJECT]", "[ATTESTOR]");
383 
384     Resources.Attestor actualResponse = client.getAttestor(name);
385     Assert.assertEquals(expectedResponse, actualResponse);
386 
387     List<String> actualRequests = mockService.getRequestPaths();
388     Assert.assertEquals(1, actualRequests.size());
389 
390     String apiClientHeaderKey =
391         mockService
392             .getRequestHeaders()
393             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
394             .iterator()
395             .next();
396     Assert.assertTrue(
397         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
398             .matcher(apiClientHeaderKey)
399             .matches());
400   }
401 
402   @Test
getAttestorExceptionTest()403   public void getAttestorExceptionTest() throws Exception {
404     ApiException exception =
405         ApiExceptionFactory.createException(
406             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
407     mockService.addException(exception);
408 
409     try {
410       AttestorName name = AttestorName.of("[PROJECT]", "[ATTESTOR]");
411       client.getAttestor(name);
412       Assert.fail("No exception raised");
413     } catch (InvalidArgumentException e) {
414       // Expected exception.
415     }
416   }
417 
418   @Test
getAttestorTest2()419   public void getAttestorTest2() throws Exception {
420     Resources.Attestor expectedResponse =
421         Resources.Attestor.newBuilder()
422             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
423             .setDescription("description-1724546052")
424             .setUpdateTime(Timestamp.newBuilder().build())
425             .build();
426     mockService.addResponse(expectedResponse);
427 
428     String name = "projects/project-2729/attestors/attestor-2729";
429 
430     Resources.Attestor actualResponse = client.getAttestor(name);
431     Assert.assertEquals(expectedResponse, actualResponse);
432 
433     List<String> actualRequests = mockService.getRequestPaths();
434     Assert.assertEquals(1, actualRequests.size());
435 
436     String apiClientHeaderKey =
437         mockService
438             .getRequestHeaders()
439             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
440             .iterator()
441             .next();
442     Assert.assertTrue(
443         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
444             .matcher(apiClientHeaderKey)
445             .matches());
446   }
447 
448   @Test
getAttestorExceptionTest2()449   public void getAttestorExceptionTest2() throws Exception {
450     ApiException exception =
451         ApiExceptionFactory.createException(
452             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
453     mockService.addException(exception);
454 
455     try {
456       String name = "projects/project-2729/attestors/attestor-2729";
457       client.getAttestor(name);
458       Assert.fail("No exception raised");
459     } catch (InvalidArgumentException e) {
460       // Expected exception.
461     }
462   }
463 
464   @Test
updateAttestorTest()465   public void updateAttestorTest() throws Exception {
466     Resources.Attestor expectedResponse =
467         Resources.Attestor.newBuilder()
468             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
469             .setDescription("description-1724546052")
470             .setUpdateTime(Timestamp.newBuilder().build())
471             .build();
472     mockService.addResponse(expectedResponse);
473 
474     Resources.Attestor attestor =
475         Resources.Attestor.newBuilder()
476             .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
477             .setDescription("description-1724546052")
478             .setUpdateTime(Timestamp.newBuilder().build())
479             .build();
480 
481     Resources.Attestor actualResponse = client.updateAttestor(attestor);
482     Assert.assertEquals(expectedResponse, actualResponse);
483 
484     List<String> actualRequests = mockService.getRequestPaths();
485     Assert.assertEquals(1, actualRequests.size());
486 
487     String apiClientHeaderKey =
488         mockService
489             .getRequestHeaders()
490             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
491             .iterator()
492             .next();
493     Assert.assertTrue(
494         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
495             .matcher(apiClientHeaderKey)
496             .matches());
497   }
498 
499   @Test
updateAttestorExceptionTest()500   public void updateAttestorExceptionTest() throws Exception {
501     ApiException exception =
502         ApiExceptionFactory.createException(
503             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
504     mockService.addException(exception);
505 
506     try {
507       Resources.Attestor attestor =
508           Resources.Attestor.newBuilder()
509               .setName(AttestorName.of("[PROJECT]", "[ATTESTOR]").toString())
510               .setDescription("description-1724546052")
511               .setUpdateTime(Timestamp.newBuilder().build())
512               .build();
513       client.updateAttestor(attestor);
514       Assert.fail("No exception raised");
515     } catch (InvalidArgumentException e) {
516       // Expected exception.
517     }
518   }
519 
520   @Test
listAttestorsTest()521   public void listAttestorsTest() throws Exception {
522     Resources.Attestor responsesElement = Resources.Attestor.newBuilder().build();
523     Service.ListAttestorsResponse expectedResponse =
524         Service.ListAttestorsResponse.newBuilder()
525             .setNextPageToken("")
526             .addAllAttestors(Arrays.asList(responsesElement))
527             .build();
528     mockService.addResponse(expectedResponse);
529 
530     ProjectName parent = ProjectName.of("[PROJECT]");
531 
532     ListAttestorsPagedResponse pagedListResponse = client.listAttestors(parent);
533 
534     List<Resources.Attestor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
535 
536     Assert.assertEquals(1, resources.size());
537     Assert.assertEquals(expectedResponse.getAttestorsList().get(0), resources.get(0));
538 
539     List<String> actualRequests = mockService.getRequestPaths();
540     Assert.assertEquals(1, actualRequests.size());
541 
542     String apiClientHeaderKey =
543         mockService
544             .getRequestHeaders()
545             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
546             .iterator()
547             .next();
548     Assert.assertTrue(
549         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
550             .matcher(apiClientHeaderKey)
551             .matches());
552   }
553 
554   @Test
listAttestorsExceptionTest()555   public void listAttestorsExceptionTest() throws Exception {
556     ApiException exception =
557         ApiExceptionFactory.createException(
558             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
559     mockService.addException(exception);
560 
561     try {
562       ProjectName parent = ProjectName.of("[PROJECT]");
563       client.listAttestors(parent);
564       Assert.fail("No exception raised");
565     } catch (InvalidArgumentException e) {
566       // Expected exception.
567     }
568   }
569 
570   @Test
listAttestorsTest2()571   public void listAttestorsTest2() throws Exception {
572     Resources.Attestor responsesElement = Resources.Attestor.newBuilder().build();
573     Service.ListAttestorsResponse expectedResponse =
574         Service.ListAttestorsResponse.newBuilder()
575             .setNextPageToken("")
576             .addAllAttestors(Arrays.asList(responsesElement))
577             .build();
578     mockService.addResponse(expectedResponse);
579 
580     String parent = "projects/project-2353";
581 
582     ListAttestorsPagedResponse pagedListResponse = client.listAttestors(parent);
583 
584     List<Resources.Attestor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
585 
586     Assert.assertEquals(1, resources.size());
587     Assert.assertEquals(expectedResponse.getAttestorsList().get(0), resources.get(0));
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
listAttestorsExceptionTest2()605   public void listAttestorsExceptionTest2() 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       String parent = "projects/project-2353";
613       client.listAttestors(parent);
614       Assert.fail("No exception raised");
615     } catch (InvalidArgumentException e) {
616       // Expected exception.
617     }
618   }
619 
620   @Test
deleteAttestorTest()621   public void deleteAttestorTest() throws Exception {
622     Empty expectedResponse = Empty.newBuilder().build();
623     mockService.addResponse(expectedResponse);
624 
625     AttestorName name = AttestorName.of("[PROJECT]", "[ATTESTOR]");
626 
627     client.deleteAttestor(name);
628 
629     List<String> actualRequests = mockService.getRequestPaths();
630     Assert.assertEquals(1, actualRequests.size());
631 
632     String apiClientHeaderKey =
633         mockService
634             .getRequestHeaders()
635             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
636             .iterator()
637             .next();
638     Assert.assertTrue(
639         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
640             .matcher(apiClientHeaderKey)
641             .matches());
642   }
643 
644   @Test
deleteAttestorExceptionTest()645   public void deleteAttestorExceptionTest() throws Exception {
646     ApiException exception =
647         ApiExceptionFactory.createException(
648             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
649     mockService.addException(exception);
650 
651     try {
652       AttestorName name = AttestorName.of("[PROJECT]", "[ATTESTOR]");
653       client.deleteAttestor(name);
654       Assert.fail("No exception raised");
655     } catch (InvalidArgumentException e) {
656       // Expected exception.
657     }
658   }
659 
660   @Test
deleteAttestorTest2()661   public void deleteAttestorTest2() throws Exception {
662     Empty expectedResponse = Empty.newBuilder().build();
663     mockService.addResponse(expectedResponse);
664 
665     String name = "projects/project-2729/attestors/attestor-2729";
666 
667     client.deleteAttestor(name);
668 
669     List<String> actualRequests = mockService.getRequestPaths();
670     Assert.assertEquals(1, actualRequests.size());
671 
672     String apiClientHeaderKey =
673         mockService
674             .getRequestHeaders()
675             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
676             .iterator()
677             .next();
678     Assert.assertTrue(
679         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
680             .matcher(apiClientHeaderKey)
681             .matches());
682   }
683 
684   @Test
deleteAttestorExceptionTest2()685   public void deleteAttestorExceptionTest2() throws Exception {
686     ApiException exception =
687         ApiExceptionFactory.createException(
688             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
689     mockService.addException(exception);
690 
691     try {
692       String name = "projects/project-2729/attestors/attestor-2729";
693       client.deleteAttestor(name);
694       Assert.fail("No exception raised");
695     } catch (InvalidArgumentException e) {
696       // Expected exception.
697     }
698   }
699 }
700