• 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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.BackendBucketsClient.ListPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
23 import com.google.api.gax.httpjson.testing.MockHttpService;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.ApiException;
26 import com.google.api.gax.rpc.ApiExceptionFactory;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.api.gax.rpc.testing.FakeStatusCode;
30 import com.google.cloud.compute.v1.Operation.Status;
31 import com.google.cloud.compute.v1.stub.HttpJsonBackendBucketsStub;
32 import com.google.common.collect.Lists;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.List;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class BackendBucketsClientTest {
48   private static MockHttpService mockService;
49   private static BackendBucketsClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonBackendBucketsStub.getMethodDescriptors(),
56             BackendBucketsSettings.getDefaultEndpoint());
57     BackendBucketsSettings settings =
58         BackendBucketsSettings.newBuilder()
59             .setTransportChannelProvider(
60                 BackendBucketsSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = BackendBucketsClient.create(settings);
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     client.close();
71   }
72 
73   @Before
setUp()74   public void setUp() {}
75 
76   @After
tearDown()77   public void tearDown() throws Exception {
78     mockService.reset();
79   }
80 
81   @Test
addSignedUrlKeyTest()82   public void addSignedUrlKeyTest() throws Exception {
83     Operation expectedResponse =
84         Operation.newBuilder()
85             .setClientOperationId("clientOperationId-1230366697")
86             .setCreationTimestamp("creationTimestamp-370203401")
87             .setDescription("description-1724546052")
88             .setEndTime("endTime-1607243192")
89             .setError(Error.newBuilder().build())
90             .setHttpErrorMessage("httpErrorMessage1577303431")
91             .setHttpErrorStatusCode(0)
92             .setId(3355)
93             .setInsertTime("insertTime966165798")
94             .setKind("kind3292052")
95             .setName("name3373707")
96             .setOperationGroupId("operationGroupId1716161683")
97             .setOperationType("operationType91999553")
98             .setProgress(-1001078227)
99             .setRegion("region-934795532")
100             .setSelfLink("selfLink1191800166")
101             .setStartTime("startTime-2129294769")
102             .setStatus(Status.DONE)
103             .setStatusMessage("statusMessage-958704715")
104             .setTargetId(-815576439)
105             .setTargetLink("targetLink486368555")
106             .setUser("user3599307")
107             .addAllWarnings(new ArrayList<Warnings>())
108             .setZone("zone3744684")
109             .build();
110     mockService.addResponse(expectedResponse);
111 
112     String project = "project-6911";
113     String backendBucket = "backendBucket-4508";
114     SignedUrlKey signedUrlKeyResource = SignedUrlKey.newBuilder().build();
115 
116     Operation actualResponse =
117         client.addSignedUrlKeyAsync(project, backendBucket, signedUrlKeyResource).get();
118     Assert.assertEquals(expectedResponse, actualResponse);
119 
120     List<String> actualRequests = mockService.getRequestPaths();
121     Assert.assertEquals(1, actualRequests.size());
122 
123     String apiClientHeaderKey =
124         mockService
125             .getRequestHeaders()
126             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
127             .iterator()
128             .next();
129     Assert.assertTrue(
130         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
131             .matcher(apiClientHeaderKey)
132             .matches());
133   }
134 
135   @Test
addSignedUrlKeyExceptionTest()136   public void addSignedUrlKeyExceptionTest() throws Exception {
137     ApiException exception =
138         ApiExceptionFactory.createException(
139             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
140     mockService.addException(exception);
141 
142     try {
143       String project = "project-6911";
144       String backendBucket = "backendBucket-4508";
145       SignedUrlKey signedUrlKeyResource = SignedUrlKey.newBuilder().build();
146       client.addSignedUrlKeyAsync(project, backendBucket, signedUrlKeyResource).get();
147       Assert.fail("No exception raised");
148     } catch (ExecutionException e) {
149     }
150   }
151 
152   @Test
deleteTest()153   public void deleteTest() throws Exception {
154     Operation expectedResponse =
155         Operation.newBuilder()
156             .setClientOperationId("clientOperationId-1230366697")
157             .setCreationTimestamp("creationTimestamp-370203401")
158             .setDescription("description-1724546052")
159             .setEndTime("endTime-1607243192")
160             .setError(Error.newBuilder().build())
161             .setHttpErrorMessage("httpErrorMessage1577303431")
162             .setHttpErrorStatusCode(0)
163             .setId(3355)
164             .setInsertTime("insertTime966165798")
165             .setKind("kind3292052")
166             .setName("name3373707")
167             .setOperationGroupId("operationGroupId1716161683")
168             .setOperationType("operationType91999553")
169             .setProgress(-1001078227)
170             .setRegion("region-934795532")
171             .setSelfLink("selfLink1191800166")
172             .setStartTime("startTime-2129294769")
173             .setStatus(Status.DONE)
174             .setStatusMessage("statusMessage-958704715")
175             .setTargetId(-815576439)
176             .setTargetLink("targetLink486368555")
177             .setUser("user3599307")
178             .addAllWarnings(new ArrayList<Warnings>())
179             .setZone("zone3744684")
180             .build();
181     mockService.addResponse(expectedResponse);
182 
183     String project = "project-6911";
184     String backendBucket = "backendBucket-4508";
185 
186     Operation actualResponse = client.deleteAsync(project, backendBucket).get();
187     Assert.assertEquals(expectedResponse, actualResponse);
188 
189     List<String> actualRequests = mockService.getRequestPaths();
190     Assert.assertEquals(1, actualRequests.size());
191 
192     String apiClientHeaderKey =
193         mockService
194             .getRequestHeaders()
195             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
196             .iterator()
197             .next();
198     Assert.assertTrue(
199         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
200             .matcher(apiClientHeaderKey)
201             .matches());
202   }
203 
204   @Test
deleteExceptionTest()205   public void deleteExceptionTest() throws Exception {
206     ApiException exception =
207         ApiExceptionFactory.createException(
208             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
209     mockService.addException(exception);
210 
211     try {
212       String project = "project-6911";
213       String backendBucket = "backendBucket-4508";
214       client.deleteAsync(project, backendBucket).get();
215       Assert.fail("No exception raised");
216     } catch (ExecutionException e) {
217     }
218   }
219 
220   @Test
deleteSignedUrlKeyTest()221   public void deleteSignedUrlKeyTest() throws Exception {
222     Operation expectedResponse =
223         Operation.newBuilder()
224             .setClientOperationId("clientOperationId-1230366697")
225             .setCreationTimestamp("creationTimestamp-370203401")
226             .setDescription("description-1724546052")
227             .setEndTime("endTime-1607243192")
228             .setError(Error.newBuilder().build())
229             .setHttpErrorMessage("httpErrorMessage1577303431")
230             .setHttpErrorStatusCode(0)
231             .setId(3355)
232             .setInsertTime("insertTime966165798")
233             .setKind("kind3292052")
234             .setName("name3373707")
235             .setOperationGroupId("operationGroupId1716161683")
236             .setOperationType("operationType91999553")
237             .setProgress(-1001078227)
238             .setRegion("region-934795532")
239             .setSelfLink("selfLink1191800166")
240             .setStartTime("startTime-2129294769")
241             .setStatus(Status.DONE)
242             .setStatusMessage("statusMessage-958704715")
243             .setTargetId(-815576439)
244             .setTargetLink("targetLink486368555")
245             .setUser("user3599307")
246             .addAllWarnings(new ArrayList<Warnings>())
247             .setZone("zone3744684")
248             .build();
249     mockService.addResponse(expectedResponse);
250 
251     String project = "project-6911";
252     String backendBucket = "backendBucket-4508";
253     String keyName = "keyName-815643254";
254 
255     Operation actualResponse =
256         client.deleteSignedUrlKeyAsync(project, backendBucket, keyName).get();
257     Assert.assertEquals(expectedResponse, actualResponse);
258 
259     List<String> actualRequests = mockService.getRequestPaths();
260     Assert.assertEquals(1, actualRequests.size());
261 
262     String apiClientHeaderKey =
263         mockService
264             .getRequestHeaders()
265             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
266             .iterator()
267             .next();
268     Assert.assertTrue(
269         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
270             .matcher(apiClientHeaderKey)
271             .matches());
272   }
273 
274   @Test
deleteSignedUrlKeyExceptionTest()275   public void deleteSignedUrlKeyExceptionTest() throws Exception {
276     ApiException exception =
277         ApiExceptionFactory.createException(
278             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
279     mockService.addException(exception);
280 
281     try {
282       String project = "project-6911";
283       String backendBucket = "backendBucket-4508";
284       String keyName = "keyName-815643254";
285       client.deleteSignedUrlKeyAsync(project, backendBucket, keyName).get();
286       Assert.fail("No exception raised");
287     } catch (ExecutionException e) {
288     }
289   }
290 
291   @Test
getTest()292   public void getTest() throws Exception {
293     BackendBucket expectedResponse =
294         BackendBucket.newBuilder()
295             .setBucketName("bucketName1117008789")
296             .setCdnPolicy(BackendBucketCdnPolicy.newBuilder().build())
297             .setCompressionMode("compressionMode71820329")
298             .setCreationTimestamp("creationTimestamp-370203401")
299             .addAllCustomResponseHeaders(new ArrayList<String>())
300             .setDescription("description-1724546052")
301             .setEdgeSecurityPolicy("edgeSecurityPolicy-630226001")
302             .setEnableCdn(true)
303             .setId(3355)
304             .setKind("kind3292052")
305             .setName("name3373707")
306             .setSelfLink("selfLink1191800166")
307             .build();
308     mockService.addResponse(expectedResponse);
309 
310     String project = "project-6911";
311     String backendBucket = "backendBucket-4508";
312 
313     BackendBucket actualResponse = client.get(project, backendBucket);
314     Assert.assertEquals(expectedResponse, actualResponse);
315 
316     List<String> actualRequests = mockService.getRequestPaths();
317     Assert.assertEquals(1, actualRequests.size());
318 
319     String apiClientHeaderKey =
320         mockService
321             .getRequestHeaders()
322             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
323             .iterator()
324             .next();
325     Assert.assertTrue(
326         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
327             .matcher(apiClientHeaderKey)
328             .matches());
329   }
330 
331   @Test
getExceptionTest()332   public void getExceptionTest() throws Exception {
333     ApiException exception =
334         ApiExceptionFactory.createException(
335             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
336     mockService.addException(exception);
337 
338     try {
339       String project = "project-6911";
340       String backendBucket = "backendBucket-4508";
341       client.get(project, backendBucket);
342       Assert.fail("No exception raised");
343     } catch (InvalidArgumentException e) {
344       // Expected exception.
345     }
346   }
347 
348   @Test
insertTest()349   public void insertTest() throws Exception {
350     Operation expectedResponse =
351         Operation.newBuilder()
352             .setClientOperationId("clientOperationId-1230366697")
353             .setCreationTimestamp("creationTimestamp-370203401")
354             .setDescription("description-1724546052")
355             .setEndTime("endTime-1607243192")
356             .setError(Error.newBuilder().build())
357             .setHttpErrorMessage("httpErrorMessage1577303431")
358             .setHttpErrorStatusCode(0)
359             .setId(3355)
360             .setInsertTime("insertTime966165798")
361             .setKind("kind3292052")
362             .setName("name3373707")
363             .setOperationGroupId("operationGroupId1716161683")
364             .setOperationType("operationType91999553")
365             .setProgress(-1001078227)
366             .setRegion("region-934795532")
367             .setSelfLink("selfLink1191800166")
368             .setStartTime("startTime-2129294769")
369             .setStatus(Status.DONE)
370             .setStatusMessage("statusMessage-958704715")
371             .setTargetId(-815576439)
372             .setTargetLink("targetLink486368555")
373             .setUser("user3599307")
374             .addAllWarnings(new ArrayList<Warnings>())
375             .setZone("zone3744684")
376             .build();
377     mockService.addResponse(expectedResponse);
378 
379     String project = "project-6911";
380     BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
381 
382     Operation actualResponse = client.insertAsync(project, backendBucketResource).get();
383     Assert.assertEquals(expectedResponse, actualResponse);
384 
385     List<String> actualRequests = mockService.getRequestPaths();
386     Assert.assertEquals(1, actualRequests.size());
387 
388     String apiClientHeaderKey =
389         mockService
390             .getRequestHeaders()
391             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
392             .iterator()
393             .next();
394     Assert.assertTrue(
395         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
396             .matcher(apiClientHeaderKey)
397             .matches());
398   }
399 
400   @Test
insertExceptionTest()401   public void insertExceptionTest() throws Exception {
402     ApiException exception =
403         ApiExceptionFactory.createException(
404             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
405     mockService.addException(exception);
406 
407     try {
408       String project = "project-6911";
409       BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
410       client.insertAsync(project, backendBucketResource).get();
411       Assert.fail("No exception raised");
412     } catch (ExecutionException e) {
413     }
414   }
415 
416   @Test
listTest()417   public void listTest() throws Exception {
418     BackendBucket responsesElement = BackendBucket.newBuilder().build();
419     BackendBucketList expectedResponse =
420         BackendBucketList.newBuilder()
421             .setNextPageToken("")
422             .addAllItems(Arrays.asList(responsesElement))
423             .build();
424     mockService.addResponse(expectedResponse);
425 
426     String project = "project-6911";
427 
428     ListPagedResponse pagedListResponse = client.list(project);
429 
430     List<BackendBucket> resources = Lists.newArrayList(pagedListResponse.iterateAll());
431 
432     Assert.assertEquals(1, resources.size());
433     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
434 
435     List<String> actualRequests = mockService.getRequestPaths();
436     Assert.assertEquals(1, actualRequests.size());
437 
438     String apiClientHeaderKey =
439         mockService
440             .getRequestHeaders()
441             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
442             .iterator()
443             .next();
444     Assert.assertTrue(
445         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
446             .matcher(apiClientHeaderKey)
447             .matches());
448   }
449 
450   @Test
listExceptionTest()451   public void listExceptionTest() throws Exception {
452     ApiException exception =
453         ApiExceptionFactory.createException(
454             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
455     mockService.addException(exception);
456 
457     try {
458       String project = "project-6911";
459       client.list(project);
460       Assert.fail("No exception raised");
461     } catch (InvalidArgumentException e) {
462       // Expected exception.
463     }
464   }
465 
466   @Test
patchTest()467   public void patchTest() throws Exception {
468     Operation expectedResponse =
469         Operation.newBuilder()
470             .setClientOperationId("clientOperationId-1230366697")
471             .setCreationTimestamp("creationTimestamp-370203401")
472             .setDescription("description-1724546052")
473             .setEndTime("endTime-1607243192")
474             .setError(Error.newBuilder().build())
475             .setHttpErrorMessage("httpErrorMessage1577303431")
476             .setHttpErrorStatusCode(0)
477             .setId(3355)
478             .setInsertTime("insertTime966165798")
479             .setKind("kind3292052")
480             .setName("name3373707")
481             .setOperationGroupId("operationGroupId1716161683")
482             .setOperationType("operationType91999553")
483             .setProgress(-1001078227)
484             .setRegion("region-934795532")
485             .setSelfLink("selfLink1191800166")
486             .setStartTime("startTime-2129294769")
487             .setStatus(Status.DONE)
488             .setStatusMessage("statusMessage-958704715")
489             .setTargetId(-815576439)
490             .setTargetLink("targetLink486368555")
491             .setUser("user3599307")
492             .addAllWarnings(new ArrayList<Warnings>())
493             .setZone("zone3744684")
494             .build();
495     mockService.addResponse(expectedResponse);
496 
497     String project = "project-6911";
498     String backendBucket = "backendBucket-4508";
499     BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
500 
501     Operation actualResponse =
502         client.patchAsync(project, backendBucket, backendBucketResource).get();
503     Assert.assertEquals(expectedResponse, actualResponse);
504 
505     List<String> actualRequests = mockService.getRequestPaths();
506     Assert.assertEquals(1, actualRequests.size());
507 
508     String apiClientHeaderKey =
509         mockService
510             .getRequestHeaders()
511             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
512             .iterator()
513             .next();
514     Assert.assertTrue(
515         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
516             .matcher(apiClientHeaderKey)
517             .matches());
518   }
519 
520   @Test
patchExceptionTest()521   public void patchExceptionTest() throws Exception {
522     ApiException exception =
523         ApiExceptionFactory.createException(
524             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
525     mockService.addException(exception);
526 
527     try {
528       String project = "project-6911";
529       String backendBucket = "backendBucket-4508";
530       BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
531       client.patchAsync(project, backendBucket, backendBucketResource).get();
532       Assert.fail("No exception raised");
533     } catch (ExecutionException e) {
534     }
535   }
536 
537   @Test
setEdgeSecurityPolicyTest()538   public void setEdgeSecurityPolicyTest() throws Exception {
539     Operation expectedResponse =
540         Operation.newBuilder()
541             .setClientOperationId("clientOperationId-1230366697")
542             .setCreationTimestamp("creationTimestamp-370203401")
543             .setDescription("description-1724546052")
544             .setEndTime("endTime-1607243192")
545             .setError(Error.newBuilder().build())
546             .setHttpErrorMessage("httpErrorMessage1577303431")
547             .setHttpErrorStatusCode(0)
548             .setId(3355)
549             .setInsertTime("insertTime966165798")
550             .setKind("kind3292052")
551             .setName("name3373707")
552             .setOperationGroupId("operationGroupId1716161683")
553             .setOperationType("operationType91999553")
554             .setProgress(-1001078227)
555             .setRegion("region-934795532")
556             .setSelfLink("selfLink1191800166")
557             .setStartTime("startTime-2129294769")
558             .setStatus(Status.DONE)
559             .setStatusMessage("statusMessage-958704715")
560             .setTargetId(-815576439)
561             .setTargetLink("targetLink486368555")
562             .setUser("user3599307")
563             .addAllWarnings(new ArrayList<Warnings>())
564             .setZone("zone3744684")
565             .build();
566     mockService.addResponse(expectedResponse);
567 
568     String project = "project-6911";
569     String backendBucket = "backendBucket-4508";
570     SecurityPolicyReference securityPolicyReferenceResource =
571         SecurityPolicyReference.newBuilder().build();
572 
573     Operation actualResponse =
574         client
575             .setEdgeSecurityPolicyAsync(project, backendBucket, securityPolicyReferenceResource)
576             .get();
577     Assert.assertEquals(expectedResponse, actualResponse);
578 
579     List<String> actualRequests = mockService.getRequestPaths();
580     Assert.assertEquals(1, actualRequests.size());
581 
582     String apiClientHeaderKey =
583         mockService
584             .getRequestHeaders()
585             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
586             .iterator()
587             .next();
588     Assert.assertTrue(
589         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
590             .matcher(apiClientHeaderKey)
591             .matches());
592   }
593 
594   @Test
setEdgeSecurityPolicyExceptionTest()595   public void setEdgeSecurityPolicyExceptionTest() throws Exception {
596     ApiException exception =
597         ApiExceptionFactory.createException(
598             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
599     mockService.addException(exception);
600 
601     try {
602       String project = "project-6911";
603       String backendBucket = "backendBucket-4508";
604       SecurityPolicyReference securityPolicyReferenceResource =
605           SecurityPolicyReference.newBuilder().build();
606       client
607           .setEdgeSecurityPolicyAsync(project, backendBucket, securityPolicyReferenceResource)
608           .get();
609       Assert.fail("No exception raised");
610     } catch (ExecutionException e) {
611     }
612   }
613 
614   @Test
updateTest()615   public void updateTest() throws Exception {
616     Operation expectedResponse =
617         Operation.newBuilder()
618             .setClientOperationId("clientOperationId-1230366697")
619             .setCreationTimestamp("creationTimestamp-370203401")
620             .setDescription("description-1724546052")
621             .setEndTime("endTime-1607243192")
622             .setError(Error.newBuilder().build())
623             .setHttpErrorMessage("httpErrorMessage1577303431")
624             .setHttpErrorStatusCode(0)
625             .setId(3355)
626             .setInsertTime("insertTime966165798")
627             .setKind("kind3292052")
628             .setName("name3373707")
629             .setOperationGroupId("operationGroupId1716161683")
630             .setOperationType("operationType91999553")
631             .setProgress(-1001078227)
632             .setRegion("region-934795532")
633             .setSelfLink("selfLink1191800166")
634             .setStartTime("startTime-2129294769")
635             .setStatus(Status.DONE)
636             .setStatusMessage("statusMessage-958704715")
637             .setTargetId(-815576439)
638             .setTargetLink("targetLink486368555")
639             .setUser("user3599307")
640             .addAllWarnings(new ArrayList<Warnings>())
641             .setZone("zone3744684")
642             .build();
643     mockService.addResponse(expectedResponse);
644 
645     String project = "project-6911";
646     String backendBucket = "backendBucket-4508";
647     BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
648 
649     Operation actualResponse =
650         client.updateAsync(project, backendBucket, backendBucketResource).get();
651     Assert.assertEquals(expectedResponse, actualResponse);
652 
653     List<String> actualRequests = mockService.getRequestPaths();
654     Assert.assertEquals(1, actualRequests.size());
655 
656     String apiClientHeaderKey =
657         mockService
658             .getRequestHeaders()
659             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
660             .iterator()
661             .next();
662     Assert.assertTrue(
663         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
664             .matcher(apiClientHeaderKey)
665             .matches());
666   }
667 
668   @Test
updateExceptionTest()669   public void updateExceptionTest() throws Exception {
670     ApiException exception =
671         ApiExceptionFactory.createException(
672             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
673     mockService.addException(exception);
674 
675     try {
676       String project = "project-6911";
677       String backendBucket = "backendBucket-4508";
678       BackendBucket backendBucketResource = BackendBucket.newBuilder().build();
679       client.updateAsync(project, backendBucket, backendBucketResource).get();
680       Assert.fail("No exception raised");
681     } catch (ExecutionException e) {
682     }
683   }
684 }
685