• 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.kms.v1;
18 
19 import static com.google.cloud.kms.v1.KeyManagementServiceClient.ListCryptoKeyVersionsPagedResponse;
20 import static com.google.cloud.kms.v1.KeyManagementServiceClient.ListCryptoKeysPagedResponse;
21 import static com.google.cloud.kms.v1.KeyManagementServiceClient.ListImportJobsPagedResponse;
22 import static com.google.cloud.kms.v1.KeyManagementServiceClient.ListKeyRingsPagedResponse;
23 import static com.google.cloud.kms.v1.KeyManagementServiceClient.ListLocationsPagedResponse;
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.kms.v1.stub.HttpJsonKeyManagementServiceStub;
36 import com.google.cloud.location.GetLocationRequest;
37 import com.google.cloud.location.ListLocationsRequest;
38 import com.google.cloud.location.ListLocationsResponse;
39 import com.google.cloud.location.Location;
40 import com.google.common.collect.Lists;
41 import com.google.iam.v1.AuditConfig;
42 import com.google.iam.v1.Binding;
43 import com.google.iam.v1.GetIamPolicyRequest;
44 import com.google.iam.v1.GetPolicyOptions;
45 import com.google.iam.v1.Policy;
46 import com.google.iam.v1.SetIamPolicyRequest;
47 import com.google.iam.v1.TestIamPermissionsRequest;
48 import com.google.iam.v1.TestIamPermissionsResponse;
49 import com.google.protobuf.Any;
50 import com.google.protobuf.ByteString;
51 import com.google.protobuf.Duration;
52 import com.google.protobuf.FieldMask;
53 import com.google.protobuf.Int64Value;
54 import com.google.protobuf.Timestamp;
55 import java.io.IOException;
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.HashMap;
59 import java.util.List;
60 import javax.annotation.Generated;
61 import org.junit.After;
62 import org.junit.AfterClass;
63 import org.junit.Assert;
64 import org.junit.Before;
65 import org.junit.BeforeClass;
66 import org.junit.Test;
67 
68 @Generated("by gapic-generator-java")
69 public class KeyManagementServiceClientHttpJsonTest {
70   private static MockHttpService mockService;
71   private static KeyManagementServiceClient client;
72 
73   @BeforeClass
startStaticServer()74   public static void startStaticServer() throws IOException {
75     mockService =
76         new MockHttpService(
77             HttpJsonKeyManagementServiceStub.getMethodDescriptors(),
78             KeyManagementServiceSettings.getDefaultEndpoint());
79     KeyManagementServiceSettings settings =
80         KeyManagementServiceSettings.newHttpJsonBuilder()
81             .setTransportChannelProvider(
82                 KeyManagementServiceSettings.defaultHttpJsonTransportProviderBuilder()
83                     .setHttpTransport(mockService)
84                     .build())
85             .setCredentialsProvider(NoCredentialsProvider.create())
86             .build();
87     client = KeyManagementServiceClient.create(settings);
88   }
89 
90   @AfterClass
stopServer()91   public static void stopServer() {
92     client.close();
93   }
94 
95   @Before
setUp()96   public void setUp() {}
97 
98   @After
tearDown()99   public void tearDown() throws Exception {
100     mockService.reset();
101   }
102 
103   @Test
listKeyRingsTest()104   public void listKeyRingsTest() throws Exception {
105     KeyRing responsesElement = KeyRing.newBuilder().build();
106     ListKeyRingsResponse expectedResponse =
107         ListKeyRingsResponse.newBuilder()
108             .setNextPageToken("")
109             .addAllKeyRings(Arrays.asList(responsesElement))
110             .build();
111     mockService.addResponse(expectedResponse);
112 
113     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
114 
115     ListKeyRingsPagedResponse pagedListResponse = client.listKeyRings(parent);
116 
117     List<KeyRing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
118 
119     Assert.assertEquals(1, resources.size());
120     Assert.assertEquals(expectedResponse.getKeyRingsList().get(0), resources.get(0));
121 
122     List<String> actualRequests = mockService.getRequestPaths();
123     Assert.assertEquals(1, actualRequests.size());
124 
125     String apiClientHeaderKey =
126         mockService
127             .getRequestHeaders()
128             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
129             .iterator()
130             .next();
131     Assert.assertTrue(
132         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
133             .matcher(apiClientHeaderKey)
134             .matches());
135   }
136 
137   @Test
listKeyRingsExceptionTest()138   public void listKeyRingsExceptionTest() throws Exception {
139     ApiException exception =
140         ApiExceptionFactory.createException(
141             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
142     mockService.addException(exception);
143 
144     try {
145       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
146       client.listKeyRings(parent);
147       Assert.fail("No exception raised");
148     } catch (InvalidArgumentException e) {
149       // Expected exception.
150     }
151   }
152 
153   @Test
listKeyRingsTest2()154   public void listKeyRingsTest2() throws Exception {
155     KeyRing responsesElement = KeyRing.newBuilder().build();
156     ListKeyRingsResponse expectedResponse =
157         ListKeyRingsResponse.newBuilder()
158             .setNextPageToken("")
159             .addAllKeyRings(Arrays.asList(responsesElement))
160             .build();
161     mockService.addResponse(expectedResponse);
162 
163     String parent = "projects/project-5833/locations/location-5833";
164 
165     ListKeyRingsPagedResponse pagedListResponse = client.listKeyRings(parent);
166 
167     List<KeyRing> resources = Lists.newArrayList(pagedListResponse.iterateAll());
168 
169     Assert.assertEquals(1, resources.size());
170     Assert.assertEquals(expectedResponse.getKeyRingsList().get(0), resources.get(0));
171 
172     List<String> actualRequests = mockService.getRequestPaths();
173     Assert.assertEquals(1, actualRequests.size());
174 
175     String apiClientHeaderKey =
176         mockService
177             .getRequestHeaders()
178             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
179             .iterator()
180             .next();
181     Assert.assertTrue(
182         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
183             .matcher(apiClientHeaderKey)
184             .matches());
185   }
186 
187   @Test
listKeyRingsExceptionTest2()188   public void listKeyRingsExceptionTest2() throws Exception {
189     ApiException exception =
190         ApiExceptionFactory.createException(
191             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
192     mockService.addException(exception);
193 
194     try {
195       String parent = "projects/project-5833/locations/location-5833";
196       client.listKeyRings(parent);
197       Assert.fail("No exception raised");
198     } catch (InvalidArgumentException e) {
199       // Expected exception.
200     }
201   }
202 
203   @Test
listCryptoKeysTest()204   public void listCryptoKeysTest() throws Exception {
205     CryptoKey responsesElement = CryptoKey.newBuilder().build();
206     ListCryptoKeysResponse expectedResponse =
207         ListCryptoKeysResponse.newBuilder()
208             .setNextPageToken("")
209             .addAllCryptoKeys(Arrays.asList(responsesElement))
210             .build();
211     mockService.addResponse(expectedResponse);
212 
213     KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
214 
215     ListCryptoKeysPagedResponse pagedListResponse = client.listCryptoKeys(parent);
216 
217     List<CryptoKey> resources = Lists.newArrayList(pagedListResponse.iterateAll());
218 
219     Assert.assertEquals(1, resources.size());
220     Assert.assertEquals(expectedResponse.getCryptoKeysList().get(0), resources.get(0));
221 
222     List<String> actualRequests = mockService.getRequestPaths();
223     Assert.assertEquals(1, actualRequests.size());
224 
225     String apiClientHeaderKey =
226         mockService
227             .getRequestHeaders()
228             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
229             .iterator()
230             .next();
231     Assert.assertTrue(
232         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
233             .matcher(apiClientHeaderKey)
234             .matches());
235   }
236 
237   @Test
listCryptoKeysExceptionTest()238   public void listCryptoKeysExceptionTest() throws Exception {
239     ApiException exception =
240         ApiExceptionFactory.createException(
241             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
242     mockService.addException(exception);
243 
244     try {
245       KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
246       client.listCryptoKeys(parent);
247       Assert.fail("No exception raised");
248     } catch (InvalidArgumentException e) {
249       // Expected exception.
250     }
251   }
252 
253   @Test
listCryptoKeysTest2()254   public void listCryptoKeysTest2() throws Exception {
255     CryptoKey responsesElement = CryptoKey.newBuilder().build();
256     ListCryptoKeysResponse expectedResponse =
257         ListCryptoKeysResponse.newBuilder()
258             .setNextPageToken("")
259             .addAllCryptoKeys(Arrays.asList(responsesElement))
260             .build();
261     mockService.addResponse(expectedResponse);
262 
263     String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
264 
265     ListCryptoKeysPagedResponse pagedListResponse = client.listCryptoKeys(parent);
266 
267     List<CryptoKey> resources = Lists.newArrayList(pagedListResponse.iterateAll());
268 
269     Assert.assertEquals(1, resources.size());
270     Assert.assertEquals(expectedResponse.getCryptoKeysList().get(0), resources.get(0));
271 
272     List<String> actualRequests = mockService.getRequestPaths();
273     Assert.assertEquals(1, actualRequests.size());
274 
275     String apiClientHeaderKey =
276         mockService
277             .getRequestHeaders()
278             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
279             .iterator()
280             .next();
281     Assert.assertTrue(
282         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
283             .matcher(apiClientHeaderKey)
284             .matches());
285   }
286 
287   @Test
listCryptoKeysExceptionTest2()288   public void listCryptoKeysExceptionTest2() throws Exception {
289     ApiException exception =
290         ApiExceptionFactory.createException(
291             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
292     mockService.addException(exception);
293 
294     try {
295       String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
296       client.listCryptoKeys(parent);
297       Assert.fail("No exception raised");
298     } catch (InvalidArgumentException e) {
299       // Expected exception.
300     }
301   }
302 
303   @Test
listCryptoKeyVersionsTest()304   public void listCryptoKeyVersionsTest() throws Exception {
305     CryptoKeyVersion responsesElement = CryptoKeyVersion.newBuilder().build();
306     ListCryptoKeyVersionsResponse expectedResponse =
307         ListCryptoKeyVersionsResponse.newBuilder()
308             .setNextPageToken("")
309             .addAllCryptoKeyVersions(Arrays.asList(responsesElement))
310             .build();
311     mockService.addResponse(expectedResponse);
312 
313     CryptoKeyName parent =
314         CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
315 
316     ListCryptoKeyVersionsPagedResponse pagedListResponse = client.listCryptoKeyVersions(parent);
317 
318     List<CryptoKeyVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
319 
320     Assert.assertEquals(1, resources.size());
321     Assert.assertEquals(expectedResponse.getCryptoKeyVersionsList().get(0), resources.get(0));
322 
323     List<String> actualRequests = mockService.getRequestPaths();
324     Assert.assertEquals(1, actualRequests.size());
325 
326     String apiClientHeaderKey =
327         mockService
328             .getRequestHeaders()
329             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
330             .iterator()
331             .next();
332     Assert.assertTrue(
333         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
334             .matcher(apiClientHeaderKey)
335             .matches());
336   }
337 
338   @Test
listCryptoKeyVersionsExceptionTest()339   public void listCryptoKeyVersionsExceptionTest() throws Exception {
340     ApiException exception =
341         ApiExceptionFactory.createException(
342             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
343     mockService.addException(exception);
344 
345     try {
346       CryptoKeyName parent =
347           CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
348       client.listCryptoKeyVersions(parent);
349       Assert.fail("No exception raised");
350     } catch (InvalidArgumentException e) {
351       // Expected exception.
352     }
353   }
354 
355   @Test
listCryptoKeyVersionsTest2()356   public void listCryptoKeyVersionsTest2() throws Exception {
357     CryptoKeyVersion responsesElement = CryptoKeyVersion.newBuilder().build();
358     ListCryptoKeyVersionsResponse expectedResponse =
359         ListCryptoKeyVersionsResponse.newBuilder()
360             .setNextPageToken("")
361             .addAllCryptoKeyVersions(Arrays.asList(responsesElement))
362             .build();
363     mockService.addResponse(expectedResponse);
364 
365     String parent =
366         "projects/project-7206/locations/location-7206/keyRings/keyRing-7206/cryptoKeys/cryptoKey-7206";
367 
368     ListCryptoKeyVersionsPagedResponse pagedListResponse = client.listCryptoKeyVersions(parent);
369 
370     List<CryptoKeyVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
371 
372     Assert.assertEquals(1, resources.size());
373     Assert.assertEquals(expectedResponse.getCryptoKeyVersionsList().get(0), resources.get(0));
374 
375     List<String> actualRequests = mockService.getRequestPaths();
376     Assert.assertEquals(1, actualRequests.size());
377 
378     String apiClientHeaderKey =
379         mockService
380             .getRequestHeaders()
381             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
382             .iterator()
383             .next();
384     Assert.assertTrue(
385         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
386             .matcher(apiClientHeaderKey)
387             .matches());
388   }
389 
390   @Test
listCryptoKeyVersionsExceptionTest2()391   public void listCryptoKeyVersionsExceptionTest2() throws Exception {
392     ApiException exception =
393         ApiExceptionFactory.createException(
394             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
395     mockService.addException(exception);
396 
397     try {
398       String parent =
399           "projects/project-7206/locations/location-7206/keyRings/keyRing-7206/cryptoKeys/cryptoKey-7206";
400       client.listCryptoKeyVersions(parent);
401       Assert.fail("No exception raised");
402     } catch (InvalidArgumentException e) {
403       // Expected exception.
404     }
405   }
406 
407   @Test
listImportJobsTest()408   public void listImportJobsTest() throws Exception {
409     ImportJob responsesElement = ImportJob.newBuilder().build();
410     ListImportJobsResponse expectedResponse =
411         ListImportJobsResponse.newBuilder()
412             .setNextPageToken("")
413             .addAllImportJobs(Arrays.asList(responsesElement))
414             .build();
415     mockService.addResponse(expectedResponse);
416 
417     KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
418 
419     ListImportJobsPagedResponse pagedListResponse = client.listImportJobs(parent);
420 
421     List<ImportJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
422 
423     Assert.assertEquals(1, resources.size());
424     Assert.assertEquals(expectedResponse.getImportJobsList().get(0), resources.get(0));
425 
426     List<String> actualRequests = mockService.getRequestPaths();
427     Assert.assertEquals(1, actualRequests.size());
428 
429     String apiClientHeaderKey =
430         mockService
431             .getRequestHeaders()
432             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
433             .iterator()
434             .next();
435     Assert.assertTrue(
436         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
437             .matcher(apiClientHeaderKey)
438             .matches());
439   }
440 
441   @Test
listImportJobsExceptionTest()442   public void listImportJobsExceptionTest() throws Exception {
443     ApiException exception =
444         ApiExceptionFactory.createException(
445             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
446     mockService.addException(exception);
447 
448     try {
449       KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
450       client.listImportJobs(parent);
451       Assert.fail("No exception raised");
452     } catch (InvalidArgumentException e) {
453       // Expected exception.
454     }
455   }
456 
457   @Test
listImportJobsTest2()458   public void listImportJobsTest2() throws Exception {
459     ImportJob responsesElement = ImportJob.newBuilder().build();
460     ListImportJobsResponse expectedResponse =
461         ListImportJobsResponse.newBuilder()
462             .setNextPageToken("")
463             .addAllImportJobs(Arrays.asList(responsesElement))
464             .build();
465     mockService.addResponse(expectedResponse);
466 
467     String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
468 
469     ListImportJobsPagedResponse pagedListResponse = client.listImportJobs(parent);
470 
471     List<ImportJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
472 
473     Assert.assertEquals(1, resources.size());
474     Assert.assertEquals(expectedResponse.getImportJobsList().get(0), resources.get(0));
475 
476     List<String> actualRequests = mockService.getRequestPaths();
477     Assert.assertEquals(1, actualRequests.size());
478 
479     String apiClientHeaderKey =
480         mockService
481             .getRequestHeaders()
482             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
483             .iterator()
484             .next();
485     Assert.assertTrue(
486         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
487             .matcher(apiClientHeaderKey)
488             .matches());
489   }
490 
491   @Test
listImportJobsExceptionTest2()492   public void listImportJobsExceptionTest2() throws Exception {
493     ApiException exception =
494         ApiExceptionFactory.createException(
495             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
496     mockService.addException(exception);
497 
498     try {
499       String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
500       client.listImportJobs(parent);
501       Assert.fail("No exception raised");
502     } catch (InvalidArgumentException e) {
503       // Expected exception.
504     }
505   }
506 
507   @Test
getKeyRingTest()508   public void getKeyRingTest() throws Exception {
509     KeyRing expectedResponse =
510         KeyRing.newBuilder()
511             .setName(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
512             .setCreateTime(Timestamp.newBuilder().build())
513             .build();
514     mockService.addResponse(expectedResponse);
515 
516     KeyRingName name = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
517 
518     KeyRing actualResponse = client.getKeyRing(name);
519     Assert.assertEquals(expectedResponse, actualResponse);
520 
521     List<String> actualRequests = mockService.getRequestPaths();
522     Assert.assertEquals(1, actualRequests.size());
523 
524     String apiClientHeaderKey =
525         mockService
526             .getRequestHeaders()
527             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
528             .iterator()
529             .next();
530     Assert.assertTrue(
531         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
532             .matcher(apiClientHeaderKey)
533             .matches());
534   }
535 
536   @Test
getKeyRingExceptionTest()537   public void getKeyRingExceptionTest() throws Exception {
538     ApiException exception =
539         ApiExceptionFactory.createException(
540             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
541     mockService.addException(exception);
542 
543     try {
544       KeyRingName name = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
545       client.getKeyRing(name);
546       Assert.fail("No exception raised");
547     } catch (InvalidArgumentException e) {
548       // Expected exception.
549     }
550   }
551 
552   @Test
getKeyRingTest2()553   public void getKeyRingTest2() throws Exception {
554     KeyRing expectedResponse =
555         KeyRing.newBuilder()
556             .setName(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
557             .setCreateTime(Timestamp.newBuilder().build())
558             .build();
559     mockService.addResponse(expectedResponse);
560 
561     String name = "projects/project-4820/locations/location-4820/keyRings/keyRing-4820";
562 
563     KeyRing actualResponse = client.getKeyRing(name);
564     Assert.assertEquals(expectedResponse, actualResponse);
565 
566     List<String> actualRequests = mockService.getRequestPaths();
567     Assert.assertEquals(1, actualRequests.size());
568 
569     String apiClientHeaderKey =
570         mockService
571             .getRequestHeaders()
572             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
573             .iterator()
574             .next();
575     Assert.assertTrue(
576         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
577             .matcher(apiClientHeaderKey)
578             .matches());
579   }
580 
581   @Test
getKeyRingExceptionTest2()582   public void getKeyRingExceptionTest2() throws Exception {
583     ApiException exception =
584         ApiExceptionFactory.createException(
585             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
586     mockService.addException(exception);
587 
588     try {
589       String name = "projects/project-4820/locations/location-4820/keyRings/keyRing-4820";
590       client.getKeyRing(name);
591       Assert.fail("No exception raised");
592     } catch (InvalidArgumentException e) {
593       // Expected exception.
594     }
595   }
596 
597   @Test
getCryptoKeyTest()598   public void getCryptoKeyTest() throws Exception {
599     CryptoKey expectedResponse =
600         CryptoKey.newBuilder()
601             .setName(
602                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
603                     .toString())
604             .setPrimary(CryptoKeyVersion.newBuilder().build())
605             .setCreateTime(Timestamp.newBuilder().build())
606             .setNextRotationTime(Timestamp.newBuilder().build())
607             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
608             .putAllLabels(new HashMap<String, String>())
609             .setImportOnly(true)
610             .setDestroyScheduledDuration(Duration.newBuilder().build())
611             .setCryptoKeyBackend(
612                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
613                     .toString())
614             .build();
615     mockService.addResponse(expectedResponse);
616 
617     CryptoKeyName name = CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
618 
619     CryptoKey actualResponse = client.getCryptoKey(name);
620     Assert.assertEquals(expectedResponse, actualResponse);
621 
622     List<String> actualRequests = mockService.getRequestPaths();
623     Assert.assertEquals(1, actualRequests.size());
624 
625     String apiClientHeaderKey =
626         mockService
627             .getRequestHeaders()
628             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
629             .iterator()
630             .next();
631     Assert.assertTrue(
632         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
633             .matcher(apiClientHeaderKey)
634             .matches());
635   }
636 
637   @Test
getCryptoKeyExceptionTest()638   public void getCryptoKeyExceptionTest() throws Exception {
639     ApiException exception =
640         ApiExceptionFactory.createException(
641             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
642     mockService.addException(exception);
643 
644     try {
645       CryptoKeyName name =
646           CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
647       client.getCryptoKey(name);
648       Assert.fail("No exception raised");
649     } catch (InvalidArgumentException e) {
650       // Expected exception.
651     }
652   }
653 
654   @Test
getCryptoKeyTest2()655   public void getCryptoKeyTest2() throws Exception {
656     CryptoKey expectedResponse =
657         CryptoKey.newBuilder()
658             .setName(
659                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
660                     .toString())
661             .setPrimary(CryptoKeyVersion.newBuilder().build())
662             .setCreateTime(Timestamp.newBuilder().build())
663             .setNextRotationTime(Timestamp.newBuilder().build())
664             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
665             .putAllLabels(new HashMap<String, String>())
666             .setImportOnly(true)
667             .setDestroyScheduledDuration(Duration.newBuilder().build())
668             .setCryptoKeyBackend(
669                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
670                     .toString())
671             .build();
672     mockService.addResponse(expectedResponse);
673 
674     String name =
675         "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
676 
677     CryptoKey actualResponse = client.getCryptoKey(name);
678     Assert.assertEquals(expectedResponse, actualResponse);
679 
680     List<String> actualRequests = mockService.getRequestPaths();
681     Assert.assertEquals(1, actualRequests.size());
682 
683     String apiClientHeaderKey =
684         mockService
685             .getRequestHeaders()
686             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
687             .iterator()
688             .next();
689     Assert.assertTrue(
690         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
691             .matcher(apiClientHeaderKey)
692             .matches());
693   }
694 
695   @Test
getCryptoKeyExceptionTest2()696   public void getCryptoKeyExceptionTest2() throws Exception {
697     ApiException exception =
698         ApiExceptionFactory.createException(
699             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
700     mockService.addException(exception);
701 
702     try {
703       String name =
704           "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
705       client.getCryptoKey(name);
706       Assert.fail("No exception raised");
707     } catch (InvalidArgumentException e) {
708       // Expected exception.
709     }
710   }
711 
712   @Test
getCryptoKeyVersionTest()713   public void getCryptoKeyVersionTest() throws Exception {
714     CryptoKeyVersion expectedResponse =
715         CryptoKeyVersion.newBuilder()
716             .setName(
717                 CryptoKeyVersionName.of(
718                         "[PROJECT]",
719                         "[LOCATION]",
720                         "[KEY_RING]",
721                         "[CRYPTO_KEY]",
722                         "[CRYPTO_KEY_VERSION]")
723                     .toString())
724             .setProtectionLevel(ProtectionLevel.forNumber(0))
725             .setAttestation(KeyOperationAttestation.newBuilder().build())
726             .setCreateTime(Timestamp.newBuilder().build())
727             .setGenerateTime(Timestamp.newBuilder().build())
728             .setDestroyTime(Timestamp.newBuilder().build())
729             .setDestroyEventTime(Timestamp.newBuilder().build())
730             .setImportJob("importJob-208547368")
731             .setImportTime(Timestamp.newBuilder().build())
732             .setImportFailureReason("importFailureReason985493705")
733             .setGenerationFailureReason("generationFailureReason-1733956042")
734             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
735             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
736             .setReimportEligible(true)
737             .build();
738     mockService.addResponse(expectedResponse);
739 
740     CryptoKeyVersionName name =
741         CryptoKeyVersionName.of(
742             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
743 
744     CryptoKeyVersion actualResponse = client.getCryptoKeyVersion(name);
745     Assert.assertEquals(expectedResponse, actualResponse);
746 
747     List<String> actualRequests = mockService.getRequestPaths();
748     Assert.assertEquals(1, actualRequests.size());
749 
750     String apiClientHeaderKey =
751         mockService
752             .getRequestHeaders()
753             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
754             .iterator()
755             .next();
756     Assert.assertTrue(
757         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
758             .matcher(apiClientHeaderKey)
759             .matches());
760   }
761 
762   @Test
getCryptoKeyVersionExceptionTest()763   public void getCryptoKeyVersionExceptionTest() throws Exception {
764     ApiException exception =
765         ApiExceptionFactory.createException(
766             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
767     mockService.addException(exception);
768 
769     try {
770       CryptoKeyVersionName name =
771           CryptoKeyVersionName.of(
772               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
773       client.getCryptoKeyVersion(name);
774       Assert.fail("No exception raised");
775     } catch (InvalidArgumentException e) {
776       // Expected exception.
777     }
778   }
779 
780   @Test
getCryptoKeyVersionTest2()781   public void getCryptoKeyVersionTest2() throws Exception {
782     CryptoKeyVersion expectedResponse =
783         CryptoKeyVersion.newBuilder()
784             .setName(
785                 CryptoKeyVersionName.of(
786                         "[PROJECT]",
787                         "[LOCATION]",
788                         "[KEY_RING]",
789                         "[CRYPTO_KEY]",
790                         "[CRYPTO_KEY_VERSION]")
791                     .toString())
792             .setProtectionLevel(ProtectionLevel.forNumber(0))
793             .setAttestation(KeyOperationAttestation.newBuilder().build())
794             .setCreateTime(Timestamp.newBuilder().build())
795             .setGenerateTime(Timestamp.newBuilder().build())
796             .setDestroyTime(Timestamp.newBuilder().build())
797             .setDestroyEventTime(Timestamp.newBuilder().build())
798             .setImportJob("importJob-208547368")
799             .setImportTime(Timestamp.newBuilder().build())
800             .setImportFailureReason("importFailureReason985493705")
801             .setGenerationFailureReason("generationFailureReason-1733956042")
802             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
803             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
804             .setReimportEligible(true)
805             .build();
806     mockService.addResponse(expectedResponse);
807 
808     String name =
809         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
810 
811     CryptoKeyVersion actualResponse = client.getCryptoKeyVersion(name);
812     Assert.assertEquals(expectedResponse, actualResponse);
813 
814     List<String> actualRequests = mockService.getRequestPaths();
815     Assert.assertEquals(1, actualRequests.size());
816 
817     String apiClientHeaderKey =
818         mockService
819             .getRequestHeaders()
820             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
821             .iterator()
822             .next();
823     Assert.assertTrue(
824         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
825             .matcher(apiClientHeaderKey)
826             .matches());
827   }
828 
829   @Test
getCryptoKeyVersionExceptionTest2()830   public void getCryptoKeyVersionExceptionTest2() throws Exception {
831     ApiException exception =
832         ApiExceptionFactory.createException(
833             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
834     mockService.addException(exception);
835 
836     try {
837       String name =
838           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
839       client.getCryptoKeyVersion(name);
840       Assert.fail("No exception raised");
841     } catch (InvalidArgumentException e) {
842       // Expected exception.
843     }
844   }
845 
846   @Test
getPublicKeyTest()847   public void getPublicKeyTest() throws Exception {
848     PublicKey expectedResponse =
849         PublicKey.newBuilder()
850             .setPem("pem110872")
851             .setPemCrc32C(Int64Value.newBuilder().build())
852             .setName("name3373707")
853             .setProtectionLevel(ProtectionLevel.forNumber(0))
854             .build();
855     mockService.addResponse(expectedResponse);
856 
857     CryptoKeyVersionName name =
858         CryptoKeyVersionName.of(
859             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
860 
861     PublicKey actualResponse = client.getPublicKey(name);
862     Assert.assertEquals(expectedResponse, actualResponse);
863 
864     List<String> actualRequests = mockService.getRequestPaths();
865     Assert.assertEquals(1, actualRequests.size());
866 
867     String apiClientHeaderKey =
868         mockService
869             .getRequestHeaders()
870             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
871             .iterator()
872             .next();
873     Assert.assertTrue(
874         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
875             .matcher(apiClientHeaderKey)
876             .matches());
877   }
878 
879   @Test
getPublicKeyExceptionTest()880   public void getPublicKeyExceptionTest() throws Exception {
881     ApiException exception =
882         ApiExceptionFactory.createException(
883             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
884     mockService.addException(exception);
885 
886     try {
887       CryptoKeyVersionName name =
888           CryptoKeyVersionName.of(
889               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
890       client.getPublicKey(name);
891       Assert.fail("No exception raised");
892     } catch (InvalidArgumentException e) {
893       // Expected exception.
894     }
895   }
896 
897   @Test
getPublicKeyTest2()898   public void getPublicKeyTest2() throws Exception {
899     PublicKey expectedResponse =
900         PublicKey.newBuilder()
901             .setPem("pem110872")
902             .setPemCrc32C(Int64Value.newBuilder().build())
903             .setName("name3373707")
904             .setProtectionLevel(ProtectionLevel.forNumber(0))
905             .build();
906     mockService.addResponse(expectedResponse);
907 
908     String name =
909         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
910 
911     PublicKey actualResponse = client.getPublicKey(name);
912     Assert.assertEquals(expectedResponse, actualResponse);
913 
914     List<String> actualRequests = mockService.getRequestPaths();
915     Assert.assertEquals(1, actualRequests.size());
916 
917     String apiClientHeaderKey =
918         mockService
919             .getRequestHeaders()
920             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
921             .iterator()
922             .next();
923     Assert.assertTrue(
924         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
925             .matcher(apiClientHeaderKey)
926             .matches());
927   }
928 
929   @Test
getPublicKeyExceptionTest2()930   public void getPublicKeyExceptionTest2() throws Exception {
931     ApiException exception =
932         ApiExceptionFactory.createException(
933             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
934     mockService.addException(exception);
935 
936     try {
937       String name =
938           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
939       client.getPublicKey(name);
940       Assert.fail("No exception raised");
941     } catch (InvalidArgumentException e) {
942       // Expected exception.
943     }
944   }
945 
946   @Test
getImportJobTest()947   public void getImportJobTest() throws Exception {
948     ImportJob expectedResponse =
949         ImportJob.newBuilder()
950             .setName(
951                 ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
952                     .toString())
953             .setProtectionLevel(ProtectionLevel.forNumber(0))
954             .setCreateTime(Timestamp.newBuilder().build())
955             .setGenerateTime(Timestamp.newBuilder().build())
956             .setExpireTime(Timestamp.newBuilder().build())
957             .setExpireEventTime(Timestamp.newBuilder().build())
958             .setPublicKey(ImportJob.WrappingPublicKey.newBuilder().build())
959             .setAttestation(KeyOperationAttestation.newBuilder().build())
960             .build();
961     mockService.addResponse(expectedResponse);
962 
963     ImportJobName name = ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]");
964 
965     ImportJob actualResponse = client.getImportJob(name);
966     Assert.assertEquals(expectedResponse, actualResponse);
967 
968     List<String> actualRequests = mockService.getRequestPaths();
969     Assert.assertEquals(1, actualRequests.size());
970 
971     String apiClientHeaderKey =
972         mockService
973             .getRequestHeaders()
974             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
975             .iterator()
976             .next();
977     Assert.assertTrue(
978         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
979             .matcher(apiClientHeaderKey)
980             .matches());
981   }
982 
983   @Test
getImportJobExceptionTest()984   public void getImportJobExceptionTest() throws Exception {
985     ApiException exception =
986         ApiExceptionFactory.createException(
987             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
988     mockService.addException(exception);
989 
990     try {
991       ImportJobName name =
992           ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]");
993       client.getImportJob(name);
994       Assert.fail("No exception raised");
995     } catch (InvalidArgumentException e) {
996       // Expected exception.
997     }
998   }
999 
1000   @Test
getImportJobTest2()1001   public void getImportJobTest2() throws Exception {
1002     ImportJob expectedResponse =
1003         ImportJob.newBuilder()
1004             .setName(
1005                 ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
1006                     .toString())
1007             .setProtectionLevel(ProtectionLevel.forNumber(0))
1008             .setCreateTime(Timestamp.newBuilder().build())
1009             .setGenerateTime(Timestamp.newBuilder().build())
1010             .setExpireTime(Timestamp.newBuilder().build())
1011             .setExpireEventTime(Timestamp.newBuilder().build())
1012             .setPublicKey(ImportJob.WrappingPublicKey.newBuilder().build())
1013             .setAttestation(KeyOperationAttestation.newBuilder().build())
1014             .build();
1015     mockService.addResponse(expectedResponse);
1016 
1017     String name =
1018         "projects/project-6111/locations/location-6111/keyRings/keyRing-6111/importJobs/importJob-6111";
1019 
1020     ImportJob actualResponse = client.getImportJob(name);
1021     Assert.assertEquals(expectedResponse, actualResponse);
1022 
1023     List<String> actualRequests = mockService.getRequestPaths();
1024     Assert.assertEquals(1, actualRequests.size());
1025 
1026     String apiClientHeaderKey =
1027         mockService
1028             .getRequestHeaders()
1029             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1030             .iterator()
1031             .next();
1032     Assert.assertTrue(
1033         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1034             .matcher(apiClientHeaderKey)
1035             .matches());
1036   }
1037 
1038   @Test
getImportJobExceptionTest2()1039   public void getImportJobExceptionTest2() throws Exception {
1040     ApiException exception =
1041         ApiExceptionFactory.createException(
1042             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1043     mockService.addException(exception);
1044 
1045     try {
1046       String name =
1047           "projects/project-6111/locations/location-6111/keyRings/keyRing-6111/importJobs/importJob-6111";
1048       client.getImportJob(name);
1049       Assert.fail("No exception raised");
1050     } catch (InvalidArgumentException e) {
1051       // Expected exception.
1052     }
1053   }
1054 
1055   @Test
createKeyRingTest()1056   public void createKeyRingTest() throws Exception {
1057     KeyRing expectedResponse =
1058         KeyRing.newBuilder()
1059             .setName(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
1060             .setCreateTime(Timestamp.newBuilder().build())
1061             .build();
1062     mockService.addResponse(expectedResponse);
1063 
1064     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1065     String keyRingId = "keyRingId-2027180374";
1066     KeyRing keyRing = KeyRing.newBuilder().build();
1067 
1068     KeyRing actualResponse = client.createKeyRing(parent, keyRingId, keyRing);
1069     Assert.assertEquals(expectedResponse, actualResponse);
1070 
1071     List<String> actualRequests = mockService.getRequestPaths();
1072     Assert.assertEquals(1, actualRequests.size());
1073 
1074     String apiClientHeaderKey =
1075         mockService
1076             .getRequestHeaders()
1077             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1078             .iterator()
1079             .next();
1080     Assert.assertTrue(
1081         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1082             .matcher(apiClientHeaderKey)
1083             .matches());
1084   }
1085 
1086   @Test
createKeyRingExceptionTest()1087   public void createKeyRingExceptionTest() throws Exception {
1088     ApiException exception =
1089         ApiExceptionFactory.createException(
1090             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1091     mockService.addException(exception);
1092 
1093     try {
1094       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1095       String keyRingId = "keyRingId-2027180374";
1096       KeyRing keyRing = KeyRing.newBuilder().build();
1097       client.createKeyRing(parent, keyRingId, keyRing);
1098       Assert.fail("No exception raised");
1099     } catch (InvalidArgumentException e) {
1100       // Expected exception.
1101     }
1102   }
1103 
1104   @Test
createKeyRingTest2()1105   public void createKeyRingTest2() throws Exception {
1106     KeyRing expectedResponse =
1107         KeyRing.newBuilder()
1108             .setName(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
1109             .setCreateTime(Timestamp.newBuilder().build())
1110             .build();
1111     mockService.addResponse(expectedResponse);
1112 
1113     String parent = "projects/project-5833/locations/location-5833";
1114     String keyRingId = "keyRingId-2027180374";
1115     KeyRing keyRing = KeyRing.newBuilder().build();
1116 
1117     KeyRing actualResponse = client.createKeyRing(parent, keyRingId, keyRing);
1118     Assert.assertEquals(expectedResponse, actualResponse);
1119 
1120     List<String> actualRequests = mockService.getRequestPaths();
1121     Assert.assertEquals(1, actualRequests.size());
1122 
1123     String apiClientHeaderKey =
1124         mockService
1125             .getRequestHeaders()
1126             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1127             .iterator()
1128             .next();
1129     Assert.assertTrue(
1130         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1131             .matcher(apiClientHeaderKey)
1132             .matches());
1133   }
1134 
1135   @Test
createKeyRingExceptionTest2()1136   public void createKeyRingExceptionTest2() throws Exception {
1137     ApiException exception =
1138         ApiExceptionFactory.createException(
1139             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1140     mockService.addException(exception);
1141 
1142     try {
1143       String parent = "projects/project-5833/locations/location-5833";
1144       String keyRingId = "keyRingId-2027180374";
1145       KeyRing keyRing = KeyRing.newBuilder().build();
1146       client.createKeyRing(parent, keyRingId, keyRing);
1147       Assert.fail("No exception raised");
1148     } catch (InvalidArgumentException e) {
1149       // Expected exception.
1150     }
1151   }
1152 
1153   @Test
createCryptoKeyTest()1154   public void createCryptoKeyTest() throws Exception {
1155     CryptoKey expectedResponse =
1156         CryptoKey.newBuilder()
1157             .setName(
1158                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1159                     .toString())
1160             .setPrimary(CryptoKeyVersion.newBuilder().build())
1161             .setCreateTime(Timestamp.newBuilder().build())
1162             .setNextRotationTime(Timestamp.newBuilder().build())
1163             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1164             .putAllLabels(new HashMap<String, String>())
1165             .setImportOnly(true)
1166             .setDestroyScheduledDuration(Duration.newBuilder().build())
1167             .setCryptoKeyBackend(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
1168             .build();
1169     mockService.addResponse(expectedResponse);
1170 
1171     KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
1172     String cryptoKeyId = "cryptoKeyId-1643185255";
1173     CryptoKey cryptoKey = CryptoKey.newBuilder().build();
1174 
1175     CryptoKey actualResponse = client.createCryptoKey(parent, cryptoKeyId, cryptoKey);
1176     Assert.assertEquals(expectedResponse, actualResponse);
1177 
1178     List<String> actualRequests = mockService.getRequestPaths();
1179     Assert.assertEquals(1, actualRequests.size());
1180 
1181     String apiClientHeaderKey =
1182         mockService
1183             .getRequestHeaders()
1184             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1185             .iterator()
1186             .next();
1187     Assert.assertTrue(
1188         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1189             .matcher(apiClientHeaderKey)
1190             .matches());
1191   }
1192 
1193   @Test
createCryptoKeyExceptionTest()1194   public void createCryptoKeyExceptionTest() throws Exception {
1195     ApiException exception =
1196         ApiExceptionFactory.createException(
1197             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1198     mockService.addException(exception);
1199 
1200     try {
1201       KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
1202       String cryptoKeyId = "cryptoKeyId-1643185255";
1203       CryptoKey cryptoKey = CryptoKey.newBuilder().build();
1204       client.createCryptoKey(parent, cryptoKeyId, cryptoKey);
1205       Assert.fail("No exception raised");
1206     } catch (InvalidArgumentException e) {
1207       // Expected exception.
1208     }
1209   }
1210 
1211   @Test
createCryptoKeyTest2()1212   public void createCryptoKeyTest2() throws Exception {
1213     CryptoKey expectedResponse =
1214         CryptoKey.newBuilder()
1215             .setName(
1216                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1217                     .toString())
1218             .setPrimary(CryptoKeyVersion.newBuilder().build())
1219             .setCreateTime(Timestamp.newBuilder().build())
1220             .setNextRotationTime(Timestamp.newBuilder().build())
1221             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1222             .putAllLabels(new HashMap<String, String>())
1223             .setImportOnly(true)
1224             .setDestroyScheduledDuration(Duration.newBuilder().build())
1225             .setCryptoKeyBackend(KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]").toString())
1226             .build();
1227     mockService.addResponse(expectedResponse);
1228 
1229     String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
1230     String cryptoKeyId = "cryptoKeyId-1643185255";
1231     CryptoKey cryptoKey = CryptoKey.newBuilder().build();
1232 
1233     CryptoKey actualResponse = client.createCryptoKey(parent, cryptoKeyId, cryptoKey);
1234     Assert.assertEquals(expectedResponse, actualResponse);
1235 
1236     List<String> actualRequests = mockService.getRequestPaths();
1237     Assert.assertEquals(1, actualRequests.size());
1238 
1239     String apiClientHeaderKey =
1240         mockService
1241             .getRequestHeaders()
1242             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1243             .iterator()
1244             .next();
1245     Assert.assertTrue(
1246         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1247             .matcher(apiClientHeaderKey)
1248             .matches());
1249   }
1250 
1251   @Test
createCryptoKeyExceptionTest2()1252   public void createCryptoKeyExceptionTest2() throws Exception {
1253     ApiException exception =
1254         ApiExceptionFactory.createException(
1255             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1256     mockService.addException(exception);
1257 
1258     try {
1259       String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
1260       String cryptoKeyId = "cryptoKeyId-1643185255";
1261       CryptoKey cryptoKey = CryptoKey.newBuilder().build();
1262       client.createCryptoKey(parent, cryptoKeyId, cryptoKey);
1263       Assert.fail("No exception raised");
1264     } catch (InvalidArgumentException e) {
1265       // Expected exception.
1266     }
1267   }
1268 
1269   @Test
createCryptoKeyVersionTest()1270   public void createCryptoKeyVersionTest() throws Exception {
1271     CryptoKeyVersion expectedResponse =
1272         CryptoKeyVersion.newBuilder()
1273             .setName(
1274                 CryptoKeyVersionName.of(
1275                         "[PROJECT]",
1276                         "[LOCATION]",
1277                         "[KEY_RING]",
1278                         "[CRYPTO_KEY]",
1279                         "[CRYPTO_KEY_VERSION]")
1280                     .toString())
1281             .setProtectionLevel(ProtectionLevel.forNumber(0))
1282             .setAttestation(KeyOperationAttestation.newBuilder().build())
1283             .setCreateTime(Timestamp.newBuilder().build())
1284             .setGenerateTime(Timestamp.newBuilder().build())
1285             .setDestroyTime(Timestamp.newBuilder().build())
1286             .setDestroyEventTime(Timestamp.newBuilder().build())
1287             .setImportJob("importJob-208547368")
1288             .setImportTime(Timestamp.newBuilder().build())
1289             .setImportFailureReason("importFailureReason985493705")
1290             .setGenerationFailureReason("generationFailureReason-1733956042")
1291             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1292             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1293             .setReimportEligible(true)
1294             .build();
1295     mockService.addResponse(expectedResponse);
1296 
1297     CryptoKeyName parent =
1298         CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
1299     CryptoKeyVersion cryptoKeyVersion = CryptoKeyVersion.newBuilder().build();
1300 
1301     CryptoKeyVersion actualResponse = client.createCryptoKeyVersion(parent, cryptoKeyVersion);
1302     Assert.assertEquals(expectedResponse, actualResponse);
1303 
1304     List<String> actualRequests = mockService.getRequestPaths();
1305     Assert.assertEquals(1, actualRequests.size());
1306 
1307     String apiClientHeaderKey =
1308         mockService
1309             .getRequestHeaders()
1310             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1311             .iterator()
1312             .next();
1313     Assert.assertTrue(
1314         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1315             .matcher(apiClientHeaderKey)
1316             .matches());
1317   }
1318 
1319   @Test
createCryptoKeyVersionExceptionTest()1320   public void createCryptoKeyVersionExceptionTest() throws Exception {
1321     ApiException exception =
1322         ApiExceptionFactory.createException(
1323             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1324     mockService.addException(exception);
1325 
1326     try {
1327       CryptoKeyName parent =
1328           CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
1329       CryptoKeyVersion cryptoKeyVersion = CryptoKeyVersion.newBuilder().build();
1330       client.createCryptoKeyVersion(parent, cryptoKeyVersion);
1331       Assert.fail("No exception raised");
1332     } catch (InvalidArgumentException e) {
1333       // Expected exception.
1334     }
1335   }
1336 
1337   @Test
createCryptoKeyVersionTest2()1338   public void createCryptoKeyVersionTest2() throws Exception {
1339     CryptoKeyVersion expectedResponse =
1340         CryptoKeyVersion.newBuilder()
1341             .setName(
1342                 CryptoKeyVersionName.of(
1343                         "[PROJECT]",
1344                         "[LOCATION]",
1345                         "[KEY_RING]",
1346                         "[CRYPTO_KEY]",
1347                         "[CRYPTO_KEY_VERSION]")
1348                     .toString())
1349             .setProtectionLevel(ProtectionLevel.forNumber(0))
1350             .setAttestation(KeyOperationAttestation.newBuilder().build())
1351             .setCreateTime(Timestamp.newBuilder().build())
1352             .setGenerateTime(Timestamp.newBuilder().build())
1353             .setDestroyTime(Timestamp.newBuilder().build())
1354             .setDestroyEventTime(Timestamp.newBuilder().build())
1355             .setImportJob("importJob-208547368")
1356             .setImportTime(Timestamp.newBuilder().build())
1357             .setImportFailureReason("importFailureReason985493705")
1358             .setGenerationFailureReason("generationFailureReason-1733956042")
1359             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1360             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1361             .setReimportEligible(true)
1362             .build();
1363     mockService.addResponse(expectedResponse);
1364 
1365     String parent =
1366         "projects/project-7206/locations/location-7206/keyRings/keyRing-7206/cryptoKeys/cryptoKey-7206";
1367     CryptoKeyVersion cryptoKeyVersion = CryptoKeyVersion.newBuilder().build();
1368 
1369     CryptoKeyVersion actualResponse = client.createCryptoKeyVersion(parent, cryptoKeyVersion);
1370     Assert.assertEquals(expectedResponse, actualResponse);
1371 
1372     List<String> actualRequests = mockService.getRequestPaths();
1373     Assert.assertEquals(1, actualRequests.size());
1374 
1375     String apiClientHeaderKey =
1376         mockService
1377             .getRequestHeaders()
1378             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1379             .iterator()
1380             .next();
1381     Assert.assertTrue(
1382         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1383             .matcher(apiClientHeaderKey)
1384             .matches());
1385   }
1386 
1387   @Test
createCryptoKeyVersionExceptionTest2()1388   public void createCryptoKeyVersionExceptionTest2() throws Exception {
1389     ApiException exception =
1390         ApiExceptionFactory.createException(
1391             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1392     mockService.addException(exception);
1393 
1394     try {
1395       String parent =
1396           "projects/project-7206/locations/location-7206/keyRings/keyRing-7206/cryptoKeys/cryptoKey-7206";
1397       CryptoKeyVersion cryptoKeyVersion = CryptoKeyVersion.newBuilder().build();
1398       client.createCryptoKeyVersion(parent, cryptoKeyVersion);
1399       Assert.fail("No exception raised");
1400     } catch (InvalidArgumentException e) {
1401       // Expected exception.
1402     }
1403   }
1404 
1405   @Test
importCryptoKeyVersionTest()1406   public void importCryptoKeyVersionTest() throws Exception {
1407     CryptoKeyVersion expectedResponse =
1408         CryptoKeyVersion.newBuilder()
1409             .setName(
1410                 CryptoKeyVersionName.of(
1411                         "[PROJECT]",
1412                         "[LOCATION]",
1413                         "[KEY_RING]",
1414                         "[CRYPTO_KEY]",
1415                         "[CRYPTO_KEY_VERSION]")
1416                     .toString())
1417             .setProtectionLevel(ProtectionLevel.forNumber(0))
1418             .setAttestation(KeyOperationAttestation.newBuilder().build())
1419             .setCreateTime(Timestamp.newBuilder().build())
1420             .setGenerateTime(Timestamp.newBuilder().build())
1421             .setDestroyTime(Timestamp.newBuilder().build())
1422             .setDestroyEventTime(Timestamp.newBuilder().build())
1423             .setImportJob("importJob-208547368")
1424             .setImportTime(Timestamp.newBuilder().build())
1425             .setImportFailureReason("importFailureReason985493705")
1426             .setGenerationFailureReason("generationFailureReason-1733956042")
1427             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1428             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1429             .setReimportEligible(true)
1430             .build();
1431     mockService.addResponse(expectedResponse);
1432 
1433     ImportCryptoKeyVersionRequest request =
1434         ImportCryptoKeyVersionRequest.newBuilder()
1435             .setParent(
1436                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1437                     .toString())
1438             .setCryptoKeyVersion(
1439                 CryptoKeyVersionName.of(
1440                         "[PROJECT]",
1441                         "[LOCATION]",
1442                         "[KEY_RING]",
1443                         "[CRYPTO_KEY]",
1444                         "[CRYPTO_KEY_VERSION]")
1445                     .toString())
1446             .setImportJob("importJob-208547368")
1447             .setWrappedKey(ByteString.EMPTY)
1448             .build();
1449 
1450     CryptoKeyVersion actualResponse = client.importCryptoKeyVersion(request);
1451     Assert.assertEquals(expectedResponse, actualResponse);
1452 
1453     List<String> actualRequests = mockService.getRequestPaths();
1454     Assert.assertEquals(1, actualRequests.size());
1455 
1456     String apiClientHeaderKey =
1457         mockService
1458             .getRequestHeaders()
1459             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1460             .iterator()
1461             .next();
1462     Assert.assertTrue(
1463         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1464             .matcher(apiClientHeaderKey)
1465             .matches());
1466   }
1467 
1468   @Test
importCryptoKeyVersionExceptionTest()1469   public void importCryptoKeyVersionExceptionTest() throws Exception {
1470     ApiException exception =
1471         ApiExceptionFactory.createException(
1472             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1473     mockService.addException(exception);
1474 
1475     try {
1476       ImportCryptoKeyVersionRequest request =
1477           ImportCryptoKeyVersionRequest.newBuilder()
1478               .setParent(
1479                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1480                       .toString())
1481               .setCryptoKeyVersion(
1482                   CryptoKeyVersionName.of(
1483                           "[PROJECT]",
1484                           "[LOCATION]",
1485                           "[KEY_RING]",
1486                           "[CRYPTO_KEY]",
1487                           "[CRYPTO_KEY_VERSION]")
1488                       .toString())
1489               .setImportJob("importJob-208547368")
1490               .setWrappedKey(ByteString.EMPTY)
1491               .build();
1492       client.importCryptoKeyVersion(request);
1493       Assert.fail("No exception raised");
1494     } catch (InvalidArgumentException e) {
1495       // Expected exception.
1496     }
1497   }
1498 
1499   @Test
createImportJobTest()1500   public void createImportJobTest() throws Exception {
1501     ImportJob expectedResponse =
1502         ImportJob.newBuilder()
1503             .setName(
1504                 ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
1505                     .toString())
1506             .setProtectionLevel(ProtectionLevel.forNumber(0))
1507             .setCreateTime(Timestamp.newBuilder().build())
1508             .setGenerateTime(Timestamp.newBuilder().build())
1509             .setExpireTime(Timestamp.newBuilder().build())
1510             .setExpireEventTime(Timestamp.newBuilder().build())
1511             .setPublicKey(ImportJob.WrappingPublicKey.newBuilder().build())
1512             .setAttestation(KeyOperationAttestation.newBuilder().build())
1513             .build();
1514     mockService.addResponse(expectedResponse);
1515 
1516     KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
1517     String importJobId = "importJobId1449444627";
1518     ImportJob importJob = ImportJob.newBuilder().build();
1519 
1520     ImportJob actualResponse = client.createImportJob(parent, importJobId, importJob);
1521     Assert.assertEquals(expectedResponse, actualResponse);
1522 
1523     List<String> actualRequests = mockService.getRequestPaths();
1524     Assert.assertEquals(1, actualRequests.size());
1525 
1526     String apiClientHeaderKey =
1527         mockService
1528             .getRequestHeaders()
1529             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1530             .iterator()
1531             .next();
1532     Assert.assertTrue(
1533         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1534             .matcher(apiClientHeaderKey)
1535             .matches());
1536   }
1537 
1538   @Test
createImportJobExceptionTest()1539   public void createImportJobExceptionTest() throws Exception {
1540     ApiException exception =
1541         ApiExceptionFactory.createException(
1542             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1543     mockService.addException(exception);
1544 
1545     try {
1546       KeyRingName parent = KeyRingName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]");
1547       String importJobId = "importJobId1449444627";
1548       ImportJob importJob = ImportJob.newBuilder().build();
1549       client.createImportJob(parent, importJobId, importJob);
1550       Assert.fail("No exception raised");
1551     } catch (InvalidArgumentException e) {
1552       // Expected exception.
1553     }
1554   }
1555 
1556   @Test
createImportJobTest2()1557   public void createImportJobTest2() throws Exception {
1558     ImportJob expectedResponse =
1559         ImportJob.newBuilder()
1560             .setName(
1561                 ImportJobName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
1562                     .toString())
1563             .setProtectionLevel(ProtectionLevel.forNumber(0))
1564             .setCreateTime(Timestamp.newBuilder().build())
1565             .setGenerateTime(Timestamp.newBuilder().build())
1566             .setExpireTime(Timestamp.newBuilder().build())
1567             .setExpireEventTime(Timestamp.newBuilder().build())
1568             .setPublicKey(ImportJob.WrappingPublicKey.newBuilder().build())
1569             .setAttestation(KeyOperationAttestation.newBuilder().build())
1570             .build();
1571     mockService.addResponse(expectedResponse);
1572 
1573     String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
1574     String importJobId = "importJobId1449444627";
1575     ImportJob importJob = ImportJob.newBuilder().build();
1576 
1577     ImportJob actualResponse = client.createImportJob(parent, importJobId, importJob);
1578     Assert.assertEquals(expectedResponse, actualResponse);
1579 
1580     List<String> actualRequests = mockService.getRequestPaths();
1581     Assert.assertEquals(1, actualRequests.size());
1582 
1583     String apiClientHeaderKey =
1584         mockService
1585             .getRequestHeaders()
1586             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1587             .iterator()
1588             .next();
1589     Assert.assertTrue(
1590         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1591             .matcher(apiClientHeaderKey)
1592             .matches());
1593   }
1594 
1595   @Test
createImportJobExceptionTest2()1596   public void createImportJobExceptionTest2() throws Exception {
1597     ApiException exception =
1598         ApiExceptionFactory.createException(
1599             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1600     mockService.addException(exception);
1601 
1602     try {
1603       String parent = "projects/project-7749/locations/location-7749/keyRings/keyRing-7749";
1604       String importJobId = "importJobId1449444627";
1605       ImportJob importJob = ImportJob.newBuilder().build();
1606       client.createImportJob(parent, importJobId, importJob);
1607       Assert.fail("No exception raised");
1608     } catch (InvalidArgumentException e) {
1609       // Expected exception.
1610     }
1611   }
1612 
1613   @Test
updateCryptoKeyTest()1614   public void updateCryptoKeyTest() throws Exception {
1615     CryptoKey expectedResponse =
1616         CryptoKey.newBuilder()
1617             .setName(
1618                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1619                     .toString())
1620             .setPrimary(CryptoKeyVersion.newBuilder().build())
1621             .setCreateTime(Timestamp.newBuilder().build())
1622             .setNextRotationTime(Timestamp.newBuilder().build())
1623             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1624             .putAllLabels(new HashMap<String, String>())
1625             .setImportOnly(true)
1626             .setDestroyScheduledDuration(Duration.newBuilder().build())
1627             .setCryptoKeyBackend(
1628                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1629                     .toString())
1630             .build();
1631     mockService.addResponse(expectedResponse);
1632 
1633     CryptoKey cryptoKey =
1634         CryptoKey.newBuilder()
1635             .setName(
1636                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1637                     .toString())
1638             .setPrimary(CryptoKeyVersion.newBuilder().build())
1639             .setCreateTime(Timestamp.newBuilder().build())
1640             .setNextRotationTime(Timestamp.newBuilder().build())
1641             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1642             .putAllLabels(new HashMap<String, String>())
1643             .setImportOnly(true)
1644             .setDestroyScheduledDuration(Duration.newBuilder().build())
1645             .setCryptoKeyBackend(
1646                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1647                     .toString())
1648             .build();
1649     FieldMask updateMask = FieldMask.newBuilder().build();
1650 
1651     CryptoKey actualResponse = client.updateCryptoKey(cryptoKey, updateMask);
1652     Assert.assertEquals(expectedResponse, actualResponse);
1653 
1654     List<String> actualRequests = mockService.getRequestPaths();
1655     Assert.assertEquals(1, actualRequests.size());
1656 
1657     String apiClientHeaderKey =
1658         mockService
1659             .getRequestHeaders()
1660             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1661             .iterator()
1662             .next();
1663     Assert.assertTrue(
1664         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1665             .matcher(apiClientHeaderKey)
1666             .matches());
1667   }
1668 
1669   @Test
updateCryptoKeyExceptionTest()1670   public void updateCryptoKeyExceptionTest() throws Exception {
1671     ApiException exception =
1672         ApiExceptionFactory.createException(
1673             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1674     mockService.addException(exception);
1675 
1676     try {
1677       CryptoKey cryptoKey =
1678           CryptoKey.newBuilder()
1679               .setName(
1680                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1681                       .toString())
1682               .setPrimary(CryptoKeyVersion.newBuilder().build())
1683               .setCreateTime(Timestamp.newBuilder().build())
1684               .setNextRotationTime(Timestamp.newBuilder().build())
1685               .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1686               .putAllLabels(new HashMap<String, String>())
1687               .setImportOnly(true)
1688               .setDestroyScheduledDuration(Duration.newBuilder().build())
1689               .setCryptoKeyBackend(
1690                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1691                       .toString())
1692               .build();
1693       FieldMask updateMask = FieldMask.newBuilder().build();
1694       client.updateCryptoKey(cryptoKey, updateMask);
1695       Assert.fail("No exception raised");
1696     } catch (InvalidArgumentException e) {
1697       // Expected exception.
1698     }
1699   }
1700 
1701   @Test
updateCryptoKeyVersionTest()1702   public void updateCryptoKeyVersionTest() throws Exception {
1703     CryptoKeyVersion expectedResponse =
1704         CryptoKeyVersion.newBuilder()
1705             .setName(
1706                 CryptoKeyVersionName.of(
1707                         "[PROJECT]",
1708                         "[LOCATION]",
1709                         "[KEY_RING]",
1710                         "[CRYPTO_KEY]",
1711                         "[CRYPTO_KEY_VERSION]")
1712                     .toString())
1713             .setProtectionLevel(ProtectionLevel.forNumber(0))
1714             .setAttestation(KeyOperationAttestation.newBuilder().build())
1715             .setCreateTime(Timestamp.newBuilder().build())
1716             .setGenerateTime(Timestamp.newBuilder().build())
1717             .setDestroyTime(Timestamp.newBuilder().build())
1718             .setDestroyEventTime(Timestamp.newBuilder().build())
1719             .setImportJob("importJob-208547368")
1720             .setImportTime(Timestamp.newBuilder().build())
1721             .setImportFailureReason("importFailureReason985493705")
1722             .setGenerationFailureReason("generationFailureReason-1733956042")
1723             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1724             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1725             .setReimportEligible(true)
1726             .build();
1727     mockService.addResponse(expectedResponse);
1728 
1729     CryptoKeyVersion cryptoKeyVersion =
1730         CryptoKeyVersion.newBuilder()
1731             .setName(
1732                 CryptoKeyVersionName.of(
1733                         "[PROJECT]",
1734                         "[LOCATION]",
1735                         "[KEY_RING]",
1736                         "[CRYPTO_KEY]",
1737                         "[CRYPTO_KEY_VERSION]")
1738                     .toString())
1739             .setProtectionLevel(ProtectionLevel.forNumber(0))
1740             .setAttestation(KeyOperationAttestation.newBuilder().build())
1741             .setCreateTime(Timestamp.newBuilder().build())
1742             .setGenerateTime(Timestamp.newBuilder().build())
1743             .setDestroyTime(Timestamp.newBuilder().build())
1744             .setDestroyEventTime(Timestamp.newBuilder().build())
1745             .setImportJob("importJob-208547368")
1746             .setImportTime(Timestamp.newBuilder().build())
1747             .setImportFailureReason("importFailureReason985493705")
1748             .setGenerationFailureReason("generationFailureReason-1733956042")
1749             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1750             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1751             .setReimportEligible(true)
1752             .build();
1753     FieldMask updateMask = FieldMask.newBuilder().build();
1754 
1755     CryptoKeyVersion actualResponse = client.updateCryptoKeyVersion(cryptoKeyVersion, updateMask);
1756     Assert.assertEquals(expectedResponse, actualResponse);
1757 
1758     List<String> actualRequests = mockService.getRequestPaths();
1759     Assert.assertEquals(1, actualRequests.size());
1760 
1761     String apiClientHeaderKey =
1762         mockService
1763             .getRequestHeaders()
1764             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1765             .iterator()
1766             .next();
1767     Assert.assertTrue(
1768         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1769             .matcher(apiClientHeaderKey)
1770             .matches());
1771   }
1772 
1773   @Test
updateCryptoKeyVersionExceptionTest()1774   public void updateCryptoKeyVersionExceptionTest() throws Exception {
1775     ApiException exception =
1776         ApiExceptionFactory.createException(
1777             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1778     mockService.addException(exception);
1779 
1780     try {
1781       CryptoKeyVersion cryptoKeyVersion =
1782           CryptoKeyVersion.newBuilder()
1783               .setName(
1784                   CryptoKeyVersionName.of(
1785                           "[PROJECT]",
1786                           "[LOCATION]",
1787                           "[KEY_RING]",
1788                           "[CRYPTO_KEY]",
1789                           "[CRYPTO_KEY_VERSION]")
1790                       .toString())
1791               .setProtectionLevel(ProtectionLevel.forNumber(0))
1792               .setAttestation(KeyOperationAttestation.newBuilder().build())
1793               .setCreateTime(Timestamp.newBuilder().build())
1794               .setGenerateTime(Timestamp.newBuilder().build())
1795               .setDestroyTime(Timestamp.newBuilder().build())
1796               .setDestroyEventTime(Timestamp.newBuilder().build())
1797               .setImportJob("importJob-208547368")
1798               .setImportTime(Timestamp.newBuilder().build())
1799               .setImportFailureReason("importFailureReason985493705")
1800               .setGenerationFailureReason("generationFailureReason-1733956042")
1801               .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1802               .setExternalProtectionLevelOptions(
1803                   ExternalProtectionLevelOptions.newBuilder().build())
1804               .setReimportEligible(true)
1805               .build();
1806       FieldMask updateMask = FieldMask.newBuilder().build();
1807       client.updateCryptoKeyVersion(cryptoKeyVersion, updateMask);
1808       Assert.fail("No exception raised");
1809     } catch (InvalidArgumentException e) {
1810       // Expected exception.
1811     }
1812   }
1813 
1814   @Test
updateCryptoKeyPrimaryVersionTest()1815   public void updateCryptoKeyPrimaryVersionTest() throws Exception {
1816     CryptoKey expectedResponse =
1817         CryptoKey.newBuilder()
1818             .setName(
1819                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1820                     .toString())
1821             .setPrimary(CryptoKeyVersion.newBuilder().build())
1822             .setCreateTime(Timestamp.newBuilder().build())
1823             .setNextRotationTime(Timestamp.newBuilder().build())
1824             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1825             .putAllLabels(new HashMap<String, String>())
1826             .setImportOnly(true)
1827             .setDestroyScheduledDuration(Duration.newBuilder().build())
1828             .setCryptoKeyBackend(
1829                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1830                     .toString())
1831             .build();
1832     mockService.addResponse(expectedResponse);
1833 
1834     CryptoKeyName name = CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
1835     String cryptoKeyVersionId = "cryptoKeyVersionId987674581";
1836 
1837     CryptoKey actualResponse = client.updateCryptoKeyPrimaryVersion(name, cryptoKeyVersionId);
1838     Assert.assertEquals(expectedResponse, actualResponse);
1839 
1840     List<String> actualRequests = mockService.getRequestPaths();
1841     Assert.assertEquals(1, actualRequests.size());
1842 
1843     String apiClientHeaderKey =
1844         mockService
1845             .getRequestHeaders()
1846             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1847             .iterator()
1848             .next();
1849     Assert.assertTrue(
1850         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1851             .matcher(apiClientHeaderKey)
1852             .matches());
1853   }
1854 
1855   @Test
updateCryptoKeyPrimaryVersionExceptionTest()1856   public void updateCryptoKeyPrimaryVersionExceptionTest() throws Exception {
1857     ApiException exception =
1858         ApiExceptionFactory.createException(
1859             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1860     mockService.addException(exception);
1861 
1862     try {
1863       CryptoKeyName name =
1864           CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
1865       String cryptoKeyVersionId = "cryptoKeyVersionId987674581";
1866       client.updateCryptoKeyPrimaryVersion(name, cryptoKeyVersionId);
1867       Assert.fail("No exception raised");
1868     } catch (InvalidArgumentException e) {
1869       // Expected exception.
1870     }
1871   }
1872 
1873   @Test
updateCryptoKeyPrimaryVersionTest2()1874   public void updateCryptoKeyPrimaryVersionTest2() throws Exception {
1875     CryptoKey expectedResponse =
1876         CryptoKey.newBuilder()
1877             .setName(
1878                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1879                     .toString())
1880             .setPrimary(CryptoKeyVersion.newBuilder().build())
1881             .setCreateTime(Timestamp.newBuilder().build())
1882             .setNextRotationTime(Timestamp.newBuilder().build())
1883             .setVersionTemplate(CryptoKeyVersionTemplate.newBuilder().build())
1884             .putAllLabels(new HashMap<String, String>())
1885             .setImportOnly(true)
1886             .setDestroyScheduledDuration(Duration.newBuilder().build())
1887             .setCryptoKeyBackend(
1888                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1889                     .toString())
1890             .build();
1891     mockService.addResponse(expectedResponse);
1892 
1893     String name =
1894         "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
1895     String cryptoKeyVersionId = "cryptoKeyVersionId987674581";
1896 
1897     CryptoKey actualResponse = client.updateCryptoKeyPrimaryVersion(name, cryptoKeyVersionId);
1898     Assert.assertEquals(expectedResponse, actualResponse);
1899 
1900     List<String> actualRequests = mockService.getRequestPaths();
1901     Assert.assertEquals(1, actualRequests.size());
1902 
1903     String apiClientHeaderKey =
1904         mockService
1905             .getRequestHeaders()
1906             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1907             .iterator()
1908             .next();
1909     Assert.assertTrue(
1910         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1911             .matcher(apiClientHeaderKey)
1912             .matches());
1913   }
1914 
1915   @Test
updateCryptoKeyPrimaryVersionExceptionTest2()1916   public void updateCryptoKeyPrimaryVersionExceptionTest2() throws Exception {
1917     ApiException exception =
1918         ApiExceptionFactory.createException(
1919             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1920     mockService.addException(exception);
1921 
1922     try {
1923       String name =
1924           "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
1925       String cryptoKeyVersionId = "cryptoKeyVersionId987674581";
1926       client.updateCryptoKeyPrimaryVersion(name, cryptoKeyVersionId);
1927       Assert.fail("No exception raised");
1928     } catch (InvalidArgumentException e) {
1929       // Expected exception.
1930     }
1931   }
1932 
1933   @Test
destroyCryptoKeyVersionTest()1934   public void destroyCryptoKeyVersionTest() throws Exception {
1935     CryptoKeyVersion expectedResponse =
1936         CryptoKeyVersion.newBuilder()
1937             .setName(
1938                 CryptoKeyVersionName.of(
1939                         "[PROJECT]",
1940                         "[LOCATION]",
1941                         "[KEY_RING]",
1942                         "[CRYPTO_KEY]",
1943                         "[CRYPTO_KEY_VERSION]")
1944                     .toString())
1945             .setProtectionLevel(ProtectionLevel.forNumber(0))
1946             .setAttestation(KeyOperationAttestation.newBuilder().build())
1947             .setCreateTime(Timestamp.newBuilder().build())
1948             .setGenerateTime(Timestamp.newBuilder().build())
1949             .setDestroyTime(Timestamp.newBuilder().build())
1950             .setDestroyEventTime(Timestamp.newBuilder().build())
1951             .setImportJob("importJob-208547368")
1952             .setImportTime(Timestamp.newBuilder().build())
1953             .setImportFailureReason("importFailureReason985493705")
1954             .setGenerationFailureReason("generationFailureReason-1733956042")
1955             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
1956             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
1957             .setReimportEligible(true)
1958             .build();
1959     mockService.addResponse(expectedResponse);
1960 
1961     CryptoKeyVersionName name =
1962         CryptoKeyVersionName.of(
1963             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
1964 
1965     CryptoKeyVersion actualResponse = client.destroyCryptoKeyVersion(name);
1966     Assert.assertEquals(expectedResponse, actualResponse);
1967 
1968     List<String> actualRequests = mockService.getRequestPaths();
1969     Assert.assertEquals(1, actualRequests.size());
1970 
1971     String apiClientHeaderKey =
1972         mockService
1973             .getRequestHeaders()
1974             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1975             .iterator()
1976             .next();
1977     Assert.assertTrue(
1978         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1979             .matcher(apiClientHeaderKey)
1980             .matches());
1981   }
1982 
1983   @Test
destroyCryptoKeyVersionExceptionTest()1984   public void destroyCryptoKeyVersionExceptionTest() throws Exception {
1985     ApiException exception =
1986         ApiExceptionFactory.createException(
1987             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1988     mockService.addException(exception);
1989 
1990     try {
1991       CryptoKeyVersionName name =
1992           CryptoKeyVersionName.of(
1993               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
1994       client.destroyCryptoKeyVersion(name);
1995       Assert.fail("No exception raised");
1996     } catch (InvalidArgumentException e) {
1997       // Expected exception.
1998     }
1999   }
2000 
2001   @Test
destroyCryptoKeyVersionTest2()2002   public void destroyCryptoKeyVersionTest2() throws Exception {
2003     CryptoKeyVersion expectedResponse =
2004         CryptoKeyVersion.newBuilder()
2005             .setName(
2006                 CryptoKeyVersionName.of(
2007                         "[PROJECT]",
2008                         "[LOCATION]",
2009                         "[KEY_RING]",
2010                         "[CRYPTO_KEY]",
2011                         "[CRYPTO_KEY_VERSION]")
2012                     .toString())
2013             .setProtectionLevel(ProtectionLevel.forNumber(0))
2014             .setAttestation(KeyOperationAttestation.newBuilder().build())
2015             .setCreateTime(Timestamp.newBuilder().build())
2016             .setGenerateTime(Timestamp.newBuilder().build())
2017             .setDestroyTime(Timestamp.newBuilder().build())
2018             .setDestroyEventTime(Timestamp.newBuilder().build())
2019             .setImportJob("importJob-208547368")
2020             .setImportTime(Timestamp.newBuilder().build())
2021             .setImportFailureReason("importFailureReason985493705")
2022             .setGenerationFailureReason("generationFailureReason-1733956042")
2023             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
2024             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
2025             .setReimportEligible(true)
2026             .build();
2027     mockService.addResponse(expectedResponse);
2028 
2029     String name =
2030         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2031 
2032     CryptoKeyVersion actualResponse = client.destroyCryptoKeyVersion(name);
2033     Assert.assertEquals(expectedResponse, actualResponse);
2034 
2035     List<String> actualRequests = mockService.getRequestPaths();
2036     Assert.assertEquals(1, actualRequests.size());
2037 
2038     String apiClientHeaderKey =
2039         mockService
2040             .getRequestHeaders()
2041             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2042             .iterator()
2043             .next();
2044     Assert.assertTrue(
2045         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2046             .matcher(apiClientHeaderKey)
2047             .matches());
2048   }
2049 
2050   @Test
destroyCryptoKeyVersionExceptionTest2()2051   public void destroyCryptoKeyVersionExceptionTest2() throws Exception {
2052     ApiException exception =
2053         ApiExceptionFactory.createException(
2054             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2055     mockService.addException(exception);
2056 
2057     try {
2058       String name =
2059           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2060       client.destroyCryptoKeyVersion(name);
2061       Assert.fail("No exception raised");
2062     } catch (InvalidArgumentException e) {
2063       // Expected exception.
2064     }
2065   }
2066 
2067   @Test
restoreCryptoKeyVersionTest()2068   public void restoreCryptoKeyVersionTest() throws Exception {
2069     CryptoKeyVersion expectedResponse =
2070         CryptoKeyVersion.newBuilder()
2071             .setName(
2072                 CryptoKeyVersionName.of(
2073                         "[PROJECT]",
2074                         "[LOCATION]",
2075                         "[KEY_RING]",
2076                         "[CRYPTO_KEY]",
2077                         "[CRYPTO_KEY_VERSION]")
2078                     .toString())
2079             .setProtectionLevel(ProtectionLevel.forNumber(0))
2080             .setAttestation(KeyOperationAttestation.newBuilder().build())
2081             .setCreateTime(Timestamp.newBuilder().build())
2082             .setGenerateTime(Timestamp.newBuilder().build())
2083             .setDestroyTime(Timestamp.newBuilder().build())
2084             .setDestroyEventTime(Timestamp.newBuilder().build())
2085             .setImportJob("importJob-208547368")
2086             .setImportTime(Timestamp.newBuilder().build())
2087             .setImportFailureReason("importFailureReason985493705")
2088             .setGenerationFailureReason("generationFailureReason-1733956042")
2089             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
2090             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
2091             .setReimportEligible(true)
2092             .build();
2093     mockService.addResponse(expectedResponse);
2094 
2095     CryptoKeyVersionName name =
2096         CryptoKeyVersionName.of(
2097             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2098 
2099     CryptoKeyVersion actualResponse = client.restoreCryptoKeyVersion(name);
2100     Assert.assertEquals(expectedResponse, actualResponse);
2101 
2102     List<String> actualRequests = mockService.getRequestPaths();
2103     Assert.assertEquals(1, actualRequests.size());
2104 
2105     String apiClientHeaderKey =
2106         mockService
2107             .getRequestHeaders()
2108             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2109             .iterator()
2110             .next();
2111     Assert.assertTrue(
2112         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2113             .matcher(apiClientHeaderKey)
2114             .matches());
2115   }
2116 
2117   @Test
restoreCryptoKeyVersionExceptionTest()2118   public void restoreCryptoKeyVersionExceptionTest() throws Exception {
2119     ApiException exception =
2120         ApiExceptionFactory.createException(
2121             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2122     mockService.addException(exception);
2123 
2124     try {
2125       CryptoKeyVersionName name =
2126           CryptoKeyVersionName.of(
2127               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2128       client.restoreCryptoKeyVersion(name);
2129       Assert.fail("No exception raised");
2130     } catch (InvalidArgumentException e) {
2131       // Expected exception.
2132     }
2133   }
2134 
2135   @Test
restoreCryptoKeyVersionTest2()2136   public void restoreCryptoKeyVersionTest2() throws Exception {
2137     CryptoKeyVersion expectedResponse =
2138         CryptoKeyVersion.newBuilder()
2139             .setName(
2140                 CryptoKeyVersionName.of(
2141                         "[PROJECT]",
2142                         "[LOCATION]",
2143                         "[KEY_RING]",
2144                         "[CRYPTO_KEY]",
2145                         "[CRYPTO_KEY_VERSION]")
2146                     .toString())
2147             .setProtectionLevel(ProtectionLevel.forNumber(0))
2148             .setAttestation(KeyOperationAttestation.newBuilder().build())
2149             .setCreateTime(Timestamp.newBuilder().build())
2150             .setGenerateTime(Timestamp.newBuilder().build())
2151             .setDestroyTime(Timestamp.newBuilder().build())
2152             .setDestroyEventTime(Timestamp.newBuilder().build())
2153             .setImportJob("importJob-208547368")
2154             .setImportTime(Timestamp.newBuilder().build())
2155             .setImportFailureReason("importFailureReason985493705")
2156             .setGenerationFailureReason("generationFailureReason-1733956042")
2157             .setExternalDestructionFailureReason("externalDestructionFailureReason-914693177")
2158             .setExternalProtectionLevelOptions(ExternalProtectionLevelOptions.newBuilder().build())
2159             .setReimportEligible(true)
2160             .build();
2161     mockService.addResponse(expectedResponse);
2162 
2163     String name =
2164         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2165 
2166     CryptoKeyVersion actualResponse = client.restoreCryptoKeyVersion(name);
2167     Assert.assertEquals(expectedResponse, actualResponse);
2168 
2169     List<String> actualRequests = mockService.getRequestPaths();
2170     Assert.assertEquals(1, actualRequests.size());
2171 
2172     String apiClientHeaderKey =
2173         mockService
2174             .getRequestHeaders()
2175             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2176             .iterator()
2177             .next();
2178     Assert.assertTrue(
2179         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2180             .matcher(apiClientHeaderKey)
2181             .matches());
2182   }
2183 
2184   @Test
restoreCryptoKeyVersionExceptionTest2()2185   public void restoreCryptoKeyVersionExceptionTest2() throws Exception {
2186     ApiException exception =
2187         ApiExceptionFactory.createException(
2188             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2189     mockService.addException(exception);
2190 
2191     try {
2192       String name =
2193           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2194       client.restoreCryptoKeyVersion(name);
2195       Assert.fail("No exception raised");
2196     } catch (InvalidArgumentException e) {
2197       // Expected exception.
2198     }
2199   }
2200 
2201   @Test
encryptTest()2202   public void encryptTest() throws Exception {
2203     EncryptResponse expectedResponse =
2204         EncryptResponse.newBuilder()
2205             .setName("name3373707")
2206             .setCiphertext(ByteString.EMPTY)
2207             .setCiphertextCrc32C(Int64Value.newBuilder().build())
2208             .setVerifiedPlaintextCrc32C(true)
2209             .setVerifiedAdditionalAuthenticatedDataCrc32C(true)
2210             .setProtectionLevel(ProtectionLevel.forNumber(0))
2211             .build();
2212     mockService.addResponse(expectedResponse);
2213 
2214     ResourceName name = CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
2215     ByteString plaintext = ByteString.EMPTY;
2216 
2217     EncryptResponse actualResponse = client.encrypt(name, plaintext);
2218     Assert.assertEquals(expectedResponse, actualResponse);
2219 
2220     List<String> actualRequests = mockService.getRequestPaths();
2221     Assert.assertEquals(1, actualRequests.size());
2222 
2223     String apiClientHeaderKey =
2224         mockService
2225             .getRequestHeaders()
2226             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2227             .iterator()
2228             .next();
2229     Assert.assertTrue(
2230         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2231             .matcher(apiClientHeaderKey)
2232             .matches());
2233   }
2234 
2235   @Test
encryptExceptionTest()2236   public void encryptExceptionTest() throws Exception {
2237     ApiException exception =
2238         ApiExceptionFactory.createException(
2239             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2240     mockService.addException(exception);
2241 
2242     try {
2243       ResourceName name = CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
2244       ByteString plaintext = ByteString.EMPTY;
2245       client.encrypt(name, plaintext);
2246       Assert.fail("No exception raised");
2247     } catch (InvalidArgumentException e) {
2248       // Expected exception.
2249     }
2250   }
2251 
2252   @Test
encryptTest2()2253   public void encryptTest2() throws Exception {
2254     EncryptResponse expectedResponse =
2255         EncryptResponse.newBuilder()
2256             .setName("name3373707")
2257             .setCiphertext(ByteString.EMPTY)
2258             .setCiphertextCrc32C(Int64Value.newBuilder().build())
2259             .setVerifiedPlaintextCrc32C(true)
2260             .setVerifiedAdditionalAuthenticatedDataCrc32C(true)
2261             .setProtectionLevel(ProtectionLevel.forNumber(0))
2262             .build();
2263     mockService.addResponse(expectedResponse);
2264 
2265     String name =
2266         "projects/project-4975/locations/location-4975/keyRings/keyRing-4975/cryptoKeys/cryptoKey-4975";
2267     ByteString plaintext = ByteString.EMPTY;
2268 
2269     EncryptResponse actualResponse = client.encrypt(name, plaintext);
2270     Assert.assertEquals(expectedResponse, actualResponse);
2271 
2272     List<String> actualRequests = mockService.getRequestPaths();
2273     Assert.assertEquals(1, actualRequests.size());
2274 
2275     String apiClientHeaderKey =
2276         mockService
2277             .getRequestHeaders()
2278             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2279             .iterator()
2280             .next();
2281     Assert.assertTrue(
2282         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2283             .matcher(apiClientHeaderKey)
2284             .matches());
2285   }
2286 
2287   @Test
encryptExceptionTest2()2288   public void encryptExceptionTest2() throws Exception {
2289     ApiException exception =
2290         ApiExceptionFactory.createException(
2291             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2292     mockService.addException(exception);
2293 
2294     try {
2295       String name =
2296           "projects/project-4975/locations/location-4975/keyRings/keyRing-4975/cryptoKeys/cryptoKey-4975";
2297       ByteString plaintext = ByteString.EMPTY;
2298       client.encrypt(name, plaintext);
2299       Assert.fail("No exception raised");
2300     } catch (InvalidArgumentException e) {
2301       // Expected exception.
2302     }
2303   }
2304 
2305   @Test
decryptTest()2306   public void decryptTest() throws Exception {
2307     DecryptResponse expectedResponse =
2308         DecryptResponse.newBuilder()
2309             .setPlaintext(ByteString.EMPTY)
2310             .setPlaintextCrc32C(Int64Value.newBuilder().build())
2311             .setUsedPrimary(true)
2312             .setProtectionLevel(ProtectionLevel.forNumber(0))
2313             .build();
2314     mockService.addResponse(expectedResponse);
2315 
2316     CryptoKeyName name = CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
2317     ByteString ciphertext = ByteString.EMPTY;
2318 
2319     DecryptResponse actualResponse = client.decrypt(name, ciphertext);
2320     Assert.assertEquals(expectedResponse, actualResponse);
2321 
2322     List<String> actualRequests = mockService.getRequestPaths();
2323     Assert.assertEquals(1, actualRequests.size());
2324 
2325     String apiClientHeaderKey =
2326         mockService
2327             .getRequestHeaders()
2328             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2329             .iterator()
2330             .next();
2331     Assert.assertTrue(
2332         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2333             .matcher(apiClientHeaderKey)
2334             .matches());
2335   }
2336 
2337   @Test
decryptExceptionTest()2338   public void decryptExceptionTest() throws Exception {
2339     ApiException exception =
2340         ApiExceptionFactory.createException(
2341             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2342     mockService.addException(exception);
2343 
2344     try {
2345       CryptoKeyName name =
2346           CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]");
2347       ByteString ciphertext = ByteString.EMPTY;
2348       client.decrypt(name, ciphertext);
2349       Assert.fail("No exception raised");
2350     } catch (InvalidArgumentException e) {
2351       // Expected exception.
2352     }
2353   }
2354 
2355   @Test
decryptTest2()2356   public void decryptTest2() throws Exception {
2357     DecryptResponse expectedResponse =
2358         DecryptResponse.newBuilder()
2359             .setPlaintext(ByteString.EMPTY)
2360             .setPlaintextCrc32C(Int64Value.newBuilder().build())
2361             .setUsedPrimary(true)
2362             .setProtectionLevel(ProtectionLevel.forNumber(0))
2363             .build();
2364     mockService.addResponse(expectedResponse);
2365 
2366     String name =
2367         "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
2368     ByteString ciphertext = ByteString.EMPTY;
2369 
2370     DecryptResponse actualResponse = client.decrypt(name, ciphertext);
2371     Assert.assertEquals(expectedResponse, actualResponse);
2372 
2373     List<String> actualRequests = mockService.getRequestPaths();
2374     Assert.assertEquals(1, actualRequests.size());
2375 
2376     String apiClientHeaderKey =
2377         mockService
2378             .getRequestHeaders()
2379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2380             .iterator()
2381             .next();
2382     Assert.assertTrue(
2383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2384             .matcher(apiClientHeaderKey)
2385             .matches());
2386   }
2387 
2388   @Test
decryptExceptionTest2()2389   public void decryptExceptionTest2() throws Exception {
2390     ApiException exception =
2391         ApiExceptionFactory.createException(
2392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2393     mockService.addException(exception);
2394 
2395     try {
2396       String name =
2397           "projects/project-5355/locations/location-5355/keyRings/keyRing-5355/cryptoKeys/cryptoKey-5355";
2398       ByteString ciphertext = ByteString.EMPTY;
2399       client.decrypt(name, ciphertext);
2400       Assert.fail("No exception raised");
2401     } catch (InvalidArgumentException e) {
2402       // Expected exception.
2403     }
2404   }
2405 
2406   @Test
asymmetricSignTest()2407   public void asymmetricSignTest() throws Exception {
2408     AsymmetricSignResponse expectedResponse =
2409         AsymmetricSignResponse.newBuilder()
2410             .setSignature(ByteString.EMPTY)
2411             .setSignatureCrc32C(Int64Value.newBuilder().build())
2412             .setVerifiedDigestCrc32C(true)
2413             .setName("name3373707")
2414             .setVerifiedDataCrc32C(true)
2415             .setProtectionLevel(ProtectionLevel.forNumber(0))
2416             .build();
2417     mockService.addResponse(expectedResponse);
2418 
2419     CryptoKeyVersionName name =
2420         CryptoKeyVersionName.of(
2421             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2422     Digest digest = Digest.newBuilder().build();
2423 
2424     AsymmetricSignResponse actualResponse = client.asymmetricSign(name, digest);
2425     Assert.assertEquals(expectedResponse, actualResponse);
2426 
2427     List<String> actualRequests = mockService.getRequestPaths();
2428     Assert.assertEquals(1, actualRequests.size());
2429 
2430     String apiClientHeaderKey =
2431         mockService
2432             .getRequestHeaders()
2433             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2434             .iterator()
2435             .next();
2436     Assert.assertTrue(
2437         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2438             .matcher(apiClientHeaderKey)
2439             .matches());
2440   }
2441 
2442   @Test
asymmetricSignExceptionTest()2443   public void asymmetricSignExceptionTest() throws Exception {
2444     ApiException exception =
2445         ApiExceptionFactory.createException(
2446             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2447     mockService.addException(exception);
2448 
2449     try {
2450       CryptoKeyVersionName name =
2451           CryptoKeyVersionName.of(
2452               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2453       Digest digest = Digest.newBuilder().build();
2454       client.asymmetricSign(name, digest);
2455       Assert.fail("No exception raised");
2456     } catch (InvalidArgumentException e) {
2457       // Expected exception.
2458     }
2459   }
2460 
2461   @Test
asymmetricSignTest2()2462   public void asymmetricSignTest2() throws Exception {
2463     AsymmetricSignResponse expectedResponse =
2464         AsymmetricSignResponse.newBuilder()
2465             .setSignature(ByteString.EMPTY)
2466             .setSignatureCrc32C(Int64Value.newBuilder().build())
2467             .setVerifiedDigestCrc32C(true)
2468             .setName("name3373707")
2469             .setVerifiedDataCrc32C(true)
2470             .setProtectionLevel(ProtectionLevel.forNumber(0))
2471             .build();
2472     mockService.addResponse(expectedResponse);
2473 
2474     String name =
2475         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2476     Digest digest = Digest.newBuilder().build();
2477 
2478     AsymmetricSignResponse actualResponse = client.asymmetricSign(name, digest);
2479     Assert.assertEquals(expectedResponse, actualResponse);
2480 
2481     List<String> actualRequests = mockService.getRequestPaths();
2482     Assert.assertEquals(1, actualRequests.size());
2483 
2484     String apiClientHeaderKey =
2485         mockService
2486             .getRequestHeaders()
2487             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2488             .iterator()
2489             .next();
2490     Assert.assertTrue(
2491         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2492             .matcher(apiClientHeaderKey)
2493             .matches());
2494   }
2495 
2496   @Test
asymmetricSignExceptionTest2()2497   public void asymmetricSignExceptionTest2() throws Exception {
2498     ApiException exception =
2499         ApiExceptionFactory.createException(
2500             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2501     mockService.addException(exception);
2502 
2503     try {
2504       String name =
2505           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2506       Digest digest = Digest.newBuilder().build();
2507       client.asymmetricSign(name, digest);
2508       Assert.fail("No exception raised");
2509     } catch (InvalidArgumentException e) {
2510       // Expected exception.
2511     }
2512   }
2513 
2514   @Test
asymmetricDecryptTest()2515   public void asymmetricDecryptTest() throws Exception {
2516     AsymmetricDecryptResponse expectedResponse =
2517         AsymmetricDecryptResponse.newBuilder()
2518             .setPlaintext(ByteString.EMPTY)
2519             .setPlaintextCrc32C(Int64Value.newBuilder().build())
2520             .setVerifiedCiphertextCrc32C(true)
2521             .setProtectionLevel(ProtectionLevel.forNumber(0))
2522             .build();
2523     mockService.addResponse(expectedResponse);
2524 
2525     CryptoKeyVersionName name =
2526         CryptoKeyVersionName.of(
2527             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2528     ByteString ciphertext = ByteString.EMPTY;
2529 
2530     AsymmetricDecryptResponse actualResponse = client.asymmetricDecrypt(name, ciphertext);
2531     Assert.assertEquals(expectedResponse, actualResponse);
2532 
2533     List<String> actualRequests = mockService.getRequestPaths();
2534     Assert.assertEquals(1, actualRequests.size());
2535 
2536     String apiClientHeaderKey =
2537         mockService
2538             .getRequestHeaders()
2539             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2540             .iterator()
2541             .next();
2542     Assert.assertTrue(
2543         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2544             .matcher(apiClientHeaderKey)
2545             .matches());
2546   }
2547 
2548   @Test
asymmetricDecryptExceptionTest()2549   public void asymmetricDecryptExceptionTest() throws Exception {
2550     ApiException exception =
2551         ApiExceptionFactory.createException(
2552             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2553     mockService.addException(exception);
2554 
2555     try {
2556       CryptoKeyVersionName name =
2557           CryptoKeyVersionName.of(
2558               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2559       ByteString ciphertext = ByteString.EMPTY;
2560       client.asymmetricDecrypt(name, ciphertext);
2561       Assert.fail("No exception raised");
2562     } catch (InvalidArgumentException e) {
2563       // Expected exception.
2564     }
2565   }
2566 
2567   @Test
asymmetricDecryptTest2()2568   public void asymmetricDecryptTest2() throws Exception {
2569     AsymmetricDecryptResponse expectedResponse =
2570         AsymmetricDecryptResponse.newBuilder()
2571             .setPlaintext(ByteString.EMPTY)
2572             .setPlaintextCrc32C(Int64Value.newBuilder().build())
2573             .setVerifiedCiphertextCrc32C(true)
2574             .setProtectionLevel(ProtectionLevel.forNumber(0))
2575             .build();
2576     mockService.addResponse(expectedResponse);
2577 
2578     String name =
2579         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2580     ByteString ciphertext = ByteString.EMPTY;
2581 
2582     AsymmetricDecryptResponse actualResponse = client.asymmetricDecrypt(name, ciphertext);
2583     Assert.assertEquals(expectedResponse, actualResponse);
2584 
2585     List<String> actualRequests = mockService.getRequestPaths();
2586     Assert.assertEquals(1, actualRequests.size());
2587 
2588     String apiClientHeaderKey =
2589         mockService
2590             .getRequestHeaders()
2591             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2592             .iterator()
2593             .next();
2594     Assert.assertTrue(
2595         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2596             .matcher(apiClientHeaderKey)
2597             .matches());
2598   }
2599 
2600   @Test
asymmetricDecryptExceptionTest2()2601   public void asymmetricDecryptExceptionTest2() throws Exception {
2602     ApiException exception =
2603         ApiExceptionFactory.createException(
2604             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2605     mockService.addException(exception);
2606 
2607     try {
2608       String name =
2609           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2610       ByteString ciphertext = ByteString.EMPTY;
2611       client.asymmetricDecrypt(name, ciphertext);
2612       Assert.fail("No exception raised");
2613     } catch (InvalidArgumentException e) {
2614       // Expected exception.
2615     }
2616   }
2617 
2618   @Test
macSignTest()2619   public void macSignTest() throws Exception {
2620     MacSignResponse expectedResponse =
2621         MacSignResponse.newBuilder()
2622             .setName("name3373707")
2623             .setMac(ByteString.EMPTY)
2624             .setMacCrc32C(Int64Value.newBuilder().build())
2625             .setVerifiedDataCrc32C(true)
2626             .setProtectionLevel(ProtectionLevel.forNumber(0))
2627             .build();
2628     mockService.addResponse(expectedResponse);
2629 
2630     CryptoKeyVersionName name =
2631         CryptoKeyVersionName.of(
2632             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2633     ByteString data = ByteString.EMPTY;
2634 
2635     MacSignResponse actualResponse = client.macSign(name, data);
2636     Assert.assertEquals(expectedResponse, actualResponse);
2637 
2638     List<String> actualRequests = mockService.getRequestPaths();
2639     Assert.assertEquals(1, actualRequests.size());
2640 
2641     String apiClientHeaderKey =
2642         mockService
2643             .getRequestHeaders()
2644             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2645             .iterator()
2646             .next();
2647     Assert.assertTrue(
2648         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2649             .matcher(apiClientHeaderKey)
2650             .matches());
2651   }
2652 
2653   @Test
macSignExceptionTest()2654   public void macSignExceptionTest() throws Exception {
2655     ApiException exception =
2656         ApiExceptionFactory.createException(
2657             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2658     mockService.addException(exception);
2659 
2660     try {
2661       CryptoKeyVersionName name =
2662           CryptoKeyVersionName.of(
2663               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2664       ByteString data = ByteString.EMPTY;
2665       client.macSign(name, data);
2666       Assert.fail("No exception raised");
2667     } catch (InvalidArgumentException e) {
2668       // Expected exception.
2669     }
2670   }
2671 
2672   @Test
macSignTest2()2673   public void macSignTest2() throws Exception {
2674     MacSignResponse expectedResponse =
2675         MacSignResponse.newBuilder()
2676             .setName("name3373707")
2677             .setMac(ByteString.EMPTY)
2678             .setMacCrc32C(Int64Value.newBuilder().build())
2679             .setVerifiedDataCrc32C(true)
2680             .setProtectionLevel(ProtectionLevel.forNumber(0))
2681             .build();
2682     mockService.addResponse(expectedResponse);
2683 
2684     String name =
2685         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2686     ByteString data = ByteString.EMPTY;
2687 
2688     MacSignResponse actualResponse = client.macSign(name, data);
2689     Assert.assertEquals(expectedResponse, actualResponse);
2690 
2691     List<String> actualRequests = mockService.getRequestPaths();
2692     Assert.assertEquals(1, actualRequests.size());
2693 
2694     String apiClientHeaderKey =
2695         mockService
2696             .getRequestHeaders()
2697             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2698             .iterator()
2699             .next();
2700     Assert.assertTrue(
2701         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2702             .matcher(apiClientHeaderKey)
2703             .matches());
2704   }
2705 
2706   @Test
macSignExceptionTest2()2707   public void macSignExceptionTest2() throws Exception {
2708     ApiException exception =
2709         ApiExceptionFactory.createException(
2710             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2711     mockService.addException(exception);
2712 
2713     try {
2714       String name =
2715           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2716       ByteString data = ByteString.EMPTY;
2717       client.macSign(name, data);
2718       Assert.fail("No exception raised");
2719     } catch (InvalidArgumentException e) {
2720       // Expected exception.
2721     }
2722   }
2723 
2724   @Test
macVerifyTest()2725   public void macVerifyTest() throws Exception {
2726     MacVerifyResponse expectedResponse =
2727         MacVerifyResponse.newBuilder()
2728             .setName("name3373707")
2729             .setSuccess(true)
2730             .setVerifiedDataCrc32C(true)
2731             .setVerifiedMacCrc32C(true)
2732             .setVerifiedSuccessIntegrity(true)
2733             .setProtectionLevel(ProtectionLevel.forNumber(0))
2734             .build();
2735     mockService.addResponse(expectedResponse);
2736 
2737     CryptoKeyVersionName name =
2738         CryptoKeyVersionName.of(
2739             "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2740     ByteString data = ByteString.EMPTY;
2741     ByteString mac = ByteString.EMPTY;
2742 
2743     MacVerifyResponse actualResponse = client.macVerify(name, data, mac);
2744     Assert.assertEquals(expectedResponse, actualResponse);
2745 
2746     List<String> actualRequests = mockService.getRequestPaths();
2747     Assert.assertEquals(1, actualRequests.size());
2748 
2749     String apiClientHeaderKey =
2750         mockService
2751             .getRequestHeaders()
2752             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2753             .iterator()
2754             .next();
2755     Assert.assertTrue(
2756         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2757             .matcher(apiClientHeaderKey)
2758             .matches());
2759   }
2760 
2761   @Test
macVerifyExceptionTest()2762   public void macVerifyExceptionTest() throws Exception {
2763     ApiException exception =
2764         ApiExceptionFactory.createException(
2765             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2766     mockService.addException(exception);
2767 
2768     try {
2769       CryptoKeyVersionName name =
2770           CryptoKeyVersionName.of(
2771               "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]");
2772       ByteString data = ByteString.EMPTY;
2773       ByteString mac = ByteString.EMPTY;
2774       client.macVerify(name, data, mac);
2775       Assert.fail("No exception raised");
2776     } catch (InvalidArgumentException e) {
2777       // Expected exception.
2778     }
2779   }
2780 
2781   @Test
macVerifyTest2()2782   public void macVerifyTest2() throws Exception {
2783     MacVerifyResponse expectedResponse =
2784         MacVerifyResponse.newBuilder()
2785             .setName("name3373707")
2786             .setSuccess(true)
2787             .setVerifiedDataCrc32C(true)
2788             .setVerifiedMacCrc32C(true)
2789             .setVerifiedSuccessIntegrity(true)
2790             .setProtectionLevel(ProtectionLevel.forNumber(0))
2791             .build();
2792     mockService.addResponse(expectedResponse);
2793 
2794     String name =
2795         "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2796     ByteString data = ByteString.EMPTY;
2797     ByteString mac = ByteString.EMPTY;
2798 
2799     MacVerifyResponse actualResponse = client.macVerify(name, data, mac);
2800     Assert.assertEquals(expectedResponse, actualResponse);
2801 
2802     List<String> actualRequests = mockService.getRequestPaths();
2803     Assert.assertEquals(1, actualRequests.size());
2804 
2805     String apiClientHeaderKey =
2806         mockService
2807             .getRequestHeaders()
2808             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2809             .iterator()
2810             .next();
2811     Assert.assertTrue(
2812         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2813             .matcher(apiClientHeaderKey)
2814             .matches());
2815   }
2816 
2817   @Test
macVerifyExceptionTest2()2818   public void macVerifyExceptionTest2() throws Exception {
2819     ApiException exception =
2820         ApiExceptionFactory.createException(
2821             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2822     mockService.addException(exception);
2823 
2824     try {
2825       String name =
2826           "projects/project-9504/locations/location-9504/keyRings/keyRing-9504/cryptoKeys/cryptoKey-9504/cryptoKeyVersions/cryptoKeyVersion-9504";
2827       ByteString data = ByteString.EMPTY;
2828       ByteString mac = ByteString.EMPTY;
2829       client.macVerify(name, data, mac);
2830       Assert.fail("No exception raised");
2831     } catch (InvalidArgumentException e) {
2832       // Expected exception.
2833     }
2834   }
2835 
2836   @Test
generateRandomBytesTest()2837   public void generateRandomBytesTest() throws Exception {
2838     GenerateRandomBytesResponse expectedResponse =
2839         GenerateRandomBytesResponse.newBuilder()
2840             .setData(ByteString.EMPTY)
2841             .setDataCrc32C(Int64Value.newBuilder().build())
2842             .build();
2843     mockService.addResponse(expectedResponse);
2844 
2845     String location = "projects/project-7132/locations/location-7132";
2846     int lengthBytes = -745661998;
2847     ProtectionLevel protectionLevel = ProtectionLevel.forNumber(0);
2848 
2849     GenerateRandomBytesResponse actualResponse =
2850         client.generateRandomBytes(location, lengthBytes, protectionLevel);
2851     Assert.assertEquals(expectedResponse, actualResponse);
2852 
2853     List<String> actualRequests = mockService.getRequestPaths();
2854     Assert.assertEquals(1, actualRequests.size());
2855 
2856     String apiClientHeaderKey =
2857         mockService
2858             .getRequestHeaders()
2859             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2860             .iterator()
2861             .next();
2862     Assert.assertTrue(
2863         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2864             .matcher(apiClientHeaderKey)
2865             .matches());
2866   }
2867 
2868   @Test
generateRandomBytesExceptionTest()2869   public void generateRandomBytesExceptionTest() throws Exception {
2870     ApiException exception =
2871         ApiExceptionFactory.createException(
2872             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2873     mockService.addException(exception);
2874 
2875     try {
2876       String location = "projects/project-7132/locations/location-7132";
2877       int lengthBytes = -745661998;
2878       ProtectionLevel protectionLevel = ProtectionLevel.forNumber(0);
2879       client.generateRandomBytes(location, lengthBytes, protectionLevel);
2880       Assert.fail("No exception raised");
2881     } catch (InvalidArgumentException e) {
2882       // Expected exception.
2883     }
2884   }
2885 
2886   @Test
listLocationsTest()2887   public void listLocationsTest() throws Exception {
2888     Location responsesElement = Location.newBuilder().build();
2889     ListLocationsResponse expectedResponse =
2890         ListLocationsResponse.newBuilder()
2891             .setNextPageToken("")
2892             .addAllLocations(Arrays.asList(responsesElement))
2893             .build();
2894     mockService.addResponse(expectedResponse);
2895 
2896     ListLocationsRequest request =
2897         ListLocationsRequest.newBuilder()
2898             .setName("projects/project-3664")
2899             .setFilter("filter-1274492040")
2900             .setPageSize(883849137)
2901             .setPageToken("pageToken873572522")
2902             .build();
2903 
2904     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2905 
2906     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2907 
2908     Assert.assertEquals(1, resources.size());
2909     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2910 
2911     List<String> actualRequests = mockService.getRequestPaths();
2912     Assert.assertEquals(1, actualRequests.size());
2913 
2914     String apiClientHeaderKey =
2915         mockService
2916             .getRequestHeaders()
2917             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2918             .iterator()
2919             .next();
2920     Assert.assertTrue(
2921         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2922             .matcher(apiClientHeaderKey)
2923             .matches());
2924   }
2925 
2926   @Test
listLocationsExceptionTest()2927   public void listLocationsExceptionTest() throws Exception {
2928     ApiException exception =
2929         ApiExceptionFactory.createException(
2930             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2931     mockService.addException(exception);
2932 
2933     try {
2934       ListLocationsRequest request =
2935           ListLocationsRequest.newBuilder()
2936               .setName("projects/project-3664")
2937               .setFilter("filter-1274492040")
2938               .setPageSize(883849137)
2939               .setPageToken("pageToken873572522")
2940               .build();
2941       client.listLocations(request);
2942       Assert.fail("No exception raised");
2943     } catch (InvalidArgumentException e) {
2944       // Expected exception.
2945     }
2946   }
2947 
2948   @Test
getLocationTest()2949   public void getLocationTest() throws Exception {
2950     Location expectedResponse =
2951         Location.newBuilder()
2952             .setName("name3373707")
2953             .setLocationId("locationId1541836720")
2954             .setDisplayName("displayName1714148973")
2955             .putAllLabels(new HashMap<String, String>())
2956             .setMetadata(Any.newBuilder().build())
2957             .build();
2958     mockService.addResponse(expectedResponse);
2959 
2960     GetLocationRequest request =
2961         GetLocationRequest.newBuilder()
2962             .setName("projects/project-9062/locations/location-9062")
2963             .build();
2964 
2965     Location actualResponse = client.getLocation(request);
2966     Assert.assertEquals(expectedResponse, actualResponse);
2967 
2968     List<String> actualRequests = mockService.getRequestPaths();
2969     Assert.assertEquals(1, actualRequests.size());
2970 
2971     String apiClientHeaderKey =
2972         mockService
2973             .getRequestHeaders()
2974             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2975             .iterator()
2976             .next();
2977     Assert.assertTrue(
2978         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2979             .matcher(apiClientHeaderKey)
2980             .matches());
2981   }
2982 
2983   @Test
getLocationExceptionTest()2984   public void getLocationExceptionTest() throws Exception {
2985     ApiException exception =
2986         ApiExceptionFactory.createException(
2987             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2988     mockService.addException(exception);
2989 
2990     try {
2991       GetLocationRequest request =
2992           GetLocationRequest.newBuilder()
2993               .setName("projects/project-9062/locations/location-9062")
2994               .build();
2995       client.getLocation(request);
2996       Assert.fail("No exception raised");
2997     } catch (InvalidArgumentException e) {
2998       // Expected exception.
2999     }
3000   }
3001 
3002   @Test
setIamPolicyTest()3003   public void setIamPolicyTest() throws Exception {
3004     Policy expectedResponse =
3005         Policy.newBuilder()
3006             .setVersion(351608024)
3007             .addAllBindings(new ArrayList<Binding>())
3008             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3009             .setEtag(ByteString.EMPTY)
3010             .build();
3011     mockService.addResponse(expectedResponse);
3012 
3013     SetIamPolicyRequest request =
3014         SetIamPolicyRequest.newBuilder()
3015             .setResource(
3016                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3017                     .toString())
3018             .setPolicy(Policy.newBuilder().build())
3019             .setUpdateMask(FieldMask.newBuilder().build())
3020             .build();
3021 
3022     Policy actualResponse = client.setIamPolicy(request);
3023     Assert.assertEquals(expectedResponse, actualResponse);
3024 
3025     List<String> actualRequests = mockService.getRequestPaths();
3026     Assert.assertEquals(1, actualRequests.size());
3027 
3028     String apiClientHeaderKey =
3029         mockService
3030             .getRequestHeaders()
3031             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3032             .iterator()
3033             .next();
3034     Assert.assertTrue(
3035         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3036             .matcher(apiClientHeaderKey)
3037             .matches());
3038   }
3039 
3040   @Test
setIamPolicyExceptionTest()3041   public void setIamPolicyExceptionTest() throws Exception {
3042     ApiException exception =
3043         ApiExceptionFactory.createException(
3044             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3045     mockService.addException(exception);
3046 
3047     try {
3048       SetIamPolicyRequest request =
3049           SetIamPolicyRequest.newBuilder()
3050               .setResource(
3051                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3052                       .toString())
3053               .setPolicy(Policy.newBuilder().build())
3054               .setUpdateMask(FieldMask.newBuilder().build())
3055               .build();
3056       client.setIamPolicy(request);
3057       Assert.fail("No exception raised");
3058     } catch (InvalidArgumentException e) {
3059       // Expected exception.
3060     }
3061   }
3062 
3063   @Test
getIamPolicyTest()3064   public void getIamPolicyTest() throws Exception {
3065     Policy expectedResponse =
3066         Policy.newBuilder()
3067             .setVersion(351608024)
3068             .addAllBindings(new ArrayList<Binding>())
3069             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3070             .setEtag(ByteString.EMPTY)
3071             .build();
3072     mockService.addResponse(expectedResponse);
3073 
3074     GetIamPolicyRequest request =
3075         GetIamPolicyRequest.newBuilder()
3076             .setResource(
3077                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3078                     .toString())
3079             .setOptions(GetPolicyOptions.newBuilder().build())
3080             .build();
3081 
3082     Policy actualResponse = client.getIamPolicy(request);
3083     Assert.assertEquals(expectedResponse, actualResponse);
3084 
3085     List<String> actualRequests = mockService.getRequestPaths();
3086     Assert.assertEquals(1, actualRequests.size());
3087 
3088     String apiClientHeaderKey =
3089         mockService
3090             .getRequestHeaders()
3091             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3092             .iterator()
3093             .next();
3094     Assert.assertTrue(
3095         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3096             .matcher(apiClientHeaderKey)
3097             .matches());
3098   }
3099 
3100   @Test
getIamPolicyExceptionTest()3101   public void getIamPolicyExceptionTest() throws Exception {
3102     ApiException exception =
3103         ApiExceptionFactory.createException(
3104             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3105     mockService.addException(exception);
3106 
3107     try {
3108       GetIamPolicyRequest request =
3109           GetIamPolicyRequest.newBuilder()
3110               .setResource(
3111                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3112                       .toString())
3113               .setOptions(GetPolicyOptions.newBuilder().build())
3114               .build();
3115       client.getIamPolicy(request);
3116       Assert.fail("No exception raised");
3117     } catch (InvalidArgumentException e) {
3118       // Expected exception.
3119     }
3120   }
3121 
3122   @Test
testIamPermissionsTest()3123   public void testIamPermissionsTest() throws Exception {
3124     TestIamPermissionsResponse expectedResponse =
3125         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
3126     mockService.addResponse(expectedResponse);
3127 
3128     TestIamPermissionsRequest request =
3129         TestIamPermissionsRequest.newBuilder()
3130             .setResource(
3131                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3132                     .toString())
3133             .addAllPermissions(new ArrayList<String>())
3134             .build();
3135 
3136     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
3137     Assert.assertEquals(expectedResponse, actualResponse);
3138 
3139     List<String> actualRequests = mockService.getRequestPaths();
3140     Assert.assertEquals(1, actualRequests.size());
3141 
3142     String apiClientHeaderKey =
3143         mockService
3144             .getRequestHeaders()
3145             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3146             .iterator()
3147             .next();
3148     Assert.assertTrue(
3149         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3150             .matcher(apiClientHeaderKey)
3151             .matches());
3152   }
3153 
3154   @Test
testIamPermissionsExceptionTest()3155   public void testIamPermissionsExceptionTest() throws Exception {
3156     ApiException exception =
3157         ApiExceptionFactory.createException(
3158             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3159     mockService.addException(exception);
3160 
3161     try {
3162       TestIamPermissionsRequest request =
3163           TestIamPermissionsRequest.newBuilder()
3164               .setResource(
3165                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
3166                       .toString())
3167               .addAllPermissions(new ArrayList<String>())
3168               .build();
3169       client.testIamPermissions(request);
3170       Assert.fail("No exception raised");
3171     } catch (InvalidArgumentException e) {
3172       // Expected exception.
3173     }
3174   }
3175 }
3176