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