• 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.RegionBackendServicesClient.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.HttpJsonRegionBackendServicesStub;
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.HashMap;
37 import java.util.List;
38 import java.util.concurrent.ExecutionException;
39 import javax.annotation.Generated;
40 import org.junit.After;
41 import org.junit.AfterClass;
42 import org.junit.Assert;
43 import org.junit.Before;
44 import org.junit.BeforeClass;
45 import org.junit.Test;
46 
47 @Generated("by gapic-generator-java")
48 public class RegionBackendServicesClientTest {
49   private static MockHttpService mockService;
50   private static RegionBackendServicesClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonRegionBackendServicesStub.getMethodDescriptors(),
57             RegionBackendServicesSettings.getDefaultEndpoint());
58     RegionBackendServicesSettings settings =
59         RegionBackendServicesSettings.newBuilder()
60             .setTransportChannelProvider(
61                 RegionBackendServicesSettings.defaultHttpJsonTransportProviderBuilder()
62                     .setHttpTransport(mockService)
63                     .build())
64             .setCredentialsProvider(NoCredentialsProvider.create())
65             .build();
66     client = RegionBackendServicesClient.create(settings);
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     client.close();
72   }
73 
74   @Before
setUp()75   public void setUp() {}
76 
77   @After
tearDown()78   public void tearDown() throws Exception {
79     mockService.reset();
80   }
81 
82   @Test
deleteTest()83   public void deleteTest() throws Exception {
84     Operation expectedResponse =
85         Operation.newBuilder()
86             .setClientOperationId("clientOperationId-1230366697")
87             .setCreationTimestamp("creationTimestamp-370203401")
88             .setDescription("description-1724546052")
89             .setEndTime("endTime-1607243192")
90             .setError(Error.newBuilder().build())
91             .setHttpErrorMessage("httpErrorMessage1577303431")
92             .setHttpErrorStatusCode(0)
93             .setId(3355)
94             .setInsertTime("insertTime966165798")
95             .setKind("kind3292052")
96             .setName("name3373707")
97             .setOperationGroupId("operationGroupId1716161683")
98             .setOperationType("operationType91999553")
99             .setProgress(-1001078227)
100             .setRegion("region-934795532")
101             .setSelfLink("selfLink1191800166")
102             .setStartTime("startTime-2129294769")
103             .setStatus(Status.DONE)
104             .setStatusMessage("statusMessage-958704715")
105             .setTargetId(-815576439)
106             .setTargetLink("targetLink486368555")
107             .setUser("user3599307")
108             .addAllWarnings(new ArrayList<Warnings>())
109             .setZone("zone3744684")
110             .build();
111     mockService.addResponse(expectedResponse);
112 
113     String project = "project-6911";
114     String region = "region-9622";
115     String backendService = "backendService-8873";
116 
117     Operation actualResponse = client.deleteAsync(project, region, backendService).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
deleteExceptionTest()136   public void deleteExceptionTest() 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 region = "region-9622";
145       String backendService = "backendService-8873";
146       client.deleteAsync(project, region, backendService).get();
147       Assert.fail("No exception raised");
148     } catch (ExecutionException e) {
149     }
150   }
151 
152   @Test
getTest()153   public void getTest() throws Exception {
154     BackendService expectedResponse =
155         BackendService.newBuilder()
156             .setAffinityCookieTtlSec(-1777486694)
157             .addAllBackends(new ArrayList<Backend>())
158             .setCdnPolicy(BackendServiceCdnPolicy.newBuilder().build())
159             .setCircuitBreakers(CircuitBreakers.newBuilder().build())
160             .setCompressionMode("compressionMode71820329")
161             .setConnectionDraining(ConnectionDraining.newBuilder().build())
162             .setConnectionTrackingPolicy(
163                 BackendServiceConnectionTrackingPolicy.newBuilder().build())
164             .setConsistentHash(ConsistentHashLoadBalancerSettings.newBuilder().build())
165             .setCreationTimestamp("creationTimestamp-370203401")
166             .addAllCustomRequestHeaders(new ArrayList<String>())
167             .addAllCustomResponseHeaders(new ArrayList<String>())
168             .setDescription("description-1724546052")
169             .setEdgeSecurityPolicy("edgeSecurityPolicy-630226001")
170             .setEnableCDN(true)
171             .setFailoverPolicy(BackendServiceFailoverPolicy.newBuilder().build())
172             .setFingerprint("fingerprint-1375934236")
173             .addAllHealthChecks(new ArrayList<String>())
174             .setIap(BackendServiceIAP.newBuilder().build())
175             .setId(3355)
176             .setKind("kind3292052")
177             .setLoadBalancingScheme("loadBalancingScheme-1223583272")
178             .addAllLocalityLbPolicies(
179                 new ArrayList<BackendServiceLocalityLoadBalancingPolicyConfig>())
180             .setLocalityLbPolicy("localityLbPolicy-1807450933")
181             .setLogConfig(BackendServiceLogConfig.newBuilder().build())
182             .setMaxStreamDuration(Duration.newBuilder().build())
183             .setName("name3373707")
184             .setNetwork("network1843485230")
185             .setOutlierDetection(OutlierDetection.newBuilder().build())
186             .setPort(3446913)
187             .setPortName("portName728194732")
188             .setProtocol("protocol-989163880")
189             .setRegion("region-934795532")
190             .setSecurityPolicy("securityPolicy-788621166")
191             .setSecuritySettings(SecuritySettings.newBuilder().build())
192             .setSelfLink("selfLink1191800166")
193             .addAllServiceBindings(new ArrayList<String>())
194             .setSessionAffinity("sessionAffinity-289859106")
195             .setSubsetting(Subsetting.newBuilder().build())
196             .setTimeoutSec(-2067488653)
197             .build();
198     mockService.addResponse(expectedResponse);
199 
200     String project = "project-6911";
201     String region = "region-9622";
202     String backendService = "backendService-8873";
203 
204     BackendService actualResponse = client.get(project, region, backendService);
205     Assert.assertEquals(expectedResponse, actualResponse);
206 
207     List<String> actualRequests = mockService.getRequestPaths();
208     Assert.assertEquals(1, actualRequests.size());
209 
210     String apiClientHeaderKey =
211         mockService
212             .getRequestHeaders()
213             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
214             .iterator()
215             .next();
216     Assert.assertTrue(
217         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
218             .matcher(apiClientHeaderKey)
219             .matches());
220   }
221 
222   @Test
getExceptionTest()223   public void getExceptionTest() throws Exception {
224     ApiException exception =
225         ApiExceptionFactory.createException(
226             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
227     mockService.addException(exception);
228 
229     try {
230       String project = "project-6911";
231       String region = "region-9622";
232       String backendService = "backendService-8873";
233       client.get(project, region, backendService);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
getHealthTest()241   public void getHealthTest() throws Exception {
242     BackendServiceGroupHealth expectedResponse =
243         BackendServiceGroupHealth.newBuilder()
244             .putAllAnnotations(new HashMap<String, String>())
245             .addAllHealthStatus(new ArrayList<HealthStatus>())
246             .setKind("kind3292052")
247             .build();
248     mockService.addResponse(expectedResponse);
249 
250     String project = "project-6911";
251     String region = "region-9622";
252     String backendService = "backendService-8873";
253     ResourceGroupReference resourceGroupReferenceResource =
254         ResourceGroupReference.newBuilder().build();
255 
256     BackendServiceGroupHealth actualResponse =
257         client.getHealth(project, region, backendService, resourceGroupReferenceResource);
258     Assert.assertEquals(expectedResponse, actualResponse);
259 
260     List<String> actualRequests = mockService.getRequestPaths();
261     Assert.assertEquals(1, actualRequests.size());
262 
263     String apiClientHeaderKey =
264         mockService
265             .getRequestHeaders()
266             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
267             .iterator()
268             .next();
269     Assert.assertTrue(
270         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
271             .matcher(apiClientHeaderKey)
272             .matches());
273   }
274 
275   @Test
getHealthExceptionTest()276   public void getHealthExceptionTest() throws Exception {
277     ApiException exception =
278         ApiExceptionFactory.createException(
279             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
280     mockService.addException(exception);
281 
282     try {
283       String project = "project-6911";
284       String region = "region-9622";
285       String backendService = "backendService-8873";
286       ResourceGroupReference resourceGroupReferenceResource =
287           ResourceGroupReference.newBuilder().build();
288       client.getHealth(project, region, backendService, resourceGroupReferenceResource);
289       Assert.fail("No exception raised");
290     } catch (InvalidArgumentException e) {
291       // Expected exception.
292     }
293   }
294 
295   @Test
getIamPolicyTest()296   public void getIamPolicyTest() throws Exception {
297     Policy expectedResponse =
298         Policy.newBuilder()
299             .addAllAuditConfigs(new ArrayList<AuditConfig>())
300             .addAllBindings(new ArrayList<Binding>())
301             .setEtag("etag3123477")
302             .setIamOwned(true)
303             .addAllRules(new ArrayList<Rule>())
304             .setVersion(351608024)
305             .build();
306     mockService.addResponse(expectedResponse);
307 
308     String project = "project-6911";
309     String region = "region-9622";
310     String resource = "resource-756";
311 
312     Policy actualResponse = client.getIamPolicy(project, region, resource);
313     Assert.assertEquals(expectedResponse, actualResponse);
314 
315     List<String> actualRequests = mockService.getRequestPaths();
316     Assert.assertEquals(1, actualRequests.size());
317 
318     String apiClientHeaderKey =
319         mockService
320             .getRequestHeaders()
321             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
322             .iterator()
323             .next();
324     Assert.assertTrue(
325         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
326             .matcher(apiClientHeaderKey)
327             .matches());
328   }
329 
330   @Test
getIamPolicyExceptionTest()331   public void getIamPolicyExceptionTest() throws Exception {
332     ApiException exception =
333         ApiExceptionFactory.createException(
334             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
335     mockService.addException(exception);
336 
337     try {
338       String project = "project-6911";
339       String region = "region-9622";
340       String resource = "resource-756";
341       client.getIamPolicy(project, region, resource);
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     String region = "region-9622";
381     BackendService backendServiceResource = BackendService.newBuilder().build();
382 
383     Operation actualResponse = client.insertAsync(project, region, backendServiceResource).get();
384     Assert.assertEquals(expectedResponse, actualResponse);
385 
386     List<String> actualRequests = mockService.getRequestPaths();
387     Assert.assertEquals(1, actualRequests.size());
388 
389     String apiClientHeaderKey =
390         mockService
391             .getRequestHeaders()
392             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
393             .iterator()
394             .next();
395     Assert.assertTrue(
396         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
397             .matcher(apiClientHeaderKey)
398             .matches());
399   }
400 
401   @Test
insertExceptionTest()402   public void insertExceptionTest() throws Exception {
403     ApiException exception =
404         ApiExceptionFactory.createException(
405             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
406     mockService.addException(exception);
407 
408     try {
409       String project = "project-6911";
410       String region = "region-9622";
411       BackendService backendServiceResource = BackendService.newBuilder().build();
412       client.insertAsync(project, region, backendServiceResource).get();
413       Assert.fail("No exception raised");
414     } catch (ExecutionException e) {
415     }
416   }
417 
418   @Test
listTest()419   public void listTest() throws Exception {
420     BackendService responsesElement = BackendService.newBuilder().build();
421     BackendServiceList expectedResponse =
422         BackendServiceList.newBuilder()
423             .setNextPageToken("")
424             .addAllItems(Arrays.asList(responsesElement))
425             .build();
426     mockService.addResponse(expectedResponse);
427 
428     String project = "project-6911";
429     String region = "region-9622";
430 
431     ListPagedResponse pagedListResponse = client.list(project, region);
432 
433     List<BackendService> resources = Lists.newArrayList(pagedListResponse.iterateAll());
434 
435     Assert.assertEquals(1, resources.size());
436     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
437 
438     List<String> actualRequests = mockService.getRequestPaths();
439     Assert.assertEquals(1, actualRequests.size());
440 
441     String apiClientHeaderKey =
442         mockService
443             .getRequestHeaders()
444             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
445             .iterator()
446             .next();
447     Assert.assertTrue(
448         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
449             .matcher(apiClientHeaderKey)
450             .matches());
451   }
452 
453   @Test
listExceptionTest()454   public void listExceptionTest() throws Exception {
455     ApiException exception =
456         ApiExceptionFactory.createException(
457             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
458     mockService.addException(exception);
459 
460     try {
461       String project = "project-6911";
462       String region = "region-9622";
463       client.list(project, region);
464       Assert.fail("No exception raised");
465     } catch (InvalidArgumentException e) {
466       // Expected exception.
467     }
468   }
469 
470   @Test
patchTest()471   public void patchTest() throws Exception {
472     Operation expectedResponse =
473         Operation.newBuilder()
474             .setClientOperationId("clientOperationId-1230366697")
475             .setCreationTimestamp("creationTimestamp-370203401")
476             .setDescription("description-1724546052")
477             .setEndTime("endTime-1607243192")
478             .setError(Error.newBuilder().build())
479             .setHttpErrorMessage("httpErrorMessage1577303431")
480             .setHttpErrorStatusCode(0)
481             .setId(3355)
482             .setInsertTime("insertTime966165798")
483             .setKind("kind3292052")
484             .setName("name3373707")
485             .setOperationGroupId("operationGroupId1716161683")
486             .setOperationType("operationType91999553")
487             .setProgress(-1001078227)
488             .setRegion("region-934795532")
489             .setSelfLink("selfLink1191800166")
490             .setStartTime("startTime-2129294769")
491             .setStatus(Status.DONE)
492             .setStatusMessage("statusMessage-958704715")
493             .setTargetId(-815576439)
494             .setTargetLink("targetLink486368555")
495             .setUser("user3599307")
496             .addAllWarnings(new ArrayList<Warnings>())
497             .setZone("zone3744684")
498             .build();
499     mockService.addResponse(expectedResponse);
500 
501     String project = "project-6911";
502     String region = "region-9622";
503     String backendService = "backendService-8873";
504     BackendService backendServiceResource = BackendService.newBuilder().build();
505 
506     Operation actualResponse =
507         client.patchAsync(project, region, backendService, backendServiceResource).get();
508     Assert.assertEquals(expectedResponse, actualResponse);
509 
510     List<String> actualRequests = mockService.getRequestPaths();
511     Assert.assertEquals(1, actualRequests.size());
512 
513     String apiClientHeaderKey =
514         mockService
515             .getRequestHeaders()
516             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
517             .iterator()
518             .next();
519     Assert.assertTrue(
520         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
521             .matcher(apiClientHeaderKey)
522             .matches());
523   }
524 
525   @Test
patchExceptionTest()526   public void patchExceptionTest() throws Exception {
527     ApiException exception =
528         ApiExceptionFactory.createException(
529             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
530     mockService.addException(exception);
531 
532     try {
533       String project = "project-6911";
534       String region = "region-9622";
535       String backendService = "backendService-8873";
536       BackendService backendServiceResource = BackendService.newBuilder().build();
537       client.patchAsync(project, region, backendService, backendServiceResource).get();
538       Assert.fail("No exception raised");
539     } catch (ExecutionException e) {
540     }
541   }
542 
543   @Test
setIamPolicyTest()544   public void setIamPolicyTest() throws Exception {
545     Policy expectedResponse =
546         Policy.newBuilder()
547             .addAllAuditConfigs(new ArrayList<AuditConfig>())
548             .addAllBindings(new ArrayList<Binding>())
549             .setEtag("etag3123477")
550             .setIamOwned(true)
551             .addAllRules(new ArrayList<Rule>())
552             .setVersion(351608024)
553             .build();
554     mockService.addResponse(expectedResponse);
555 
556     String project = "project-6911";
557     String region = "region-9622";
558     String resource = "resource-756";
559     RegionSetPolicyRequest regionSetPolicyRequestResource =
560         RegionSetPolicyRequest.newBuilder().build();
561 
562     Policy actualResponse =
563         client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
564     Assert.assertEquals(expectedResponse, actualResponse);
565 
566     List<String> actualRequests = mockService.getRequestPaths();
567     Assert.assertEquals(1, actualRequests.size());
568 
569     String apiClientHeaderKey =
570         mockService
571             .getRequestHeaders()
572             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
573             .iterator()
574             .next();
575     Assert.assertTrue(
576         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
577             .matcher(apiClientHeaderKey)
578             .matches());
579   }
580 
581   @Test
setIamPolicyExceptionTest()582   public void setIamPolicyExceptionTest() throws Exception {
583     ApiException exception =
584         ApiExceptionFactory.createException(
585             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
586     mockService.addException(exception);
587 
588     try {
589       String project = "project-6911";
590       String region = "region-9622";
591       String resource = "resource-756";
592       RegionSetPolicyRequest regionSetPolicyRequestResource =
593           RegionSetPolicyRequest.newBuilder().build();
594       client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
595       Assert.fail("No exception raised");
596     } catch (InvalidArgumentException e) {
597       // Expected exception.
598     }
599   }
600 
601   @Test
updateTest()602   public void updateTest() throws Exception {
603     Operation expectedResponse =
604         Operation.newBuilder()
605             .setClientOperationId("clientOperationId-1230366697")
606             .setCreationTimestamp("creationTimestamp-370203401")
607             .setDescription("description-1724546052")
608             .setEndTime("endTime-1607243192")
609             .setError(Error.newBuilder().build())
610             .setHttpErrorMessage("httpErrorMessage1577303431")
611             .setHttpErrorStatusCode(0)
612             .setId(3355)
613             .setInsertTime("insertTime966165798")
614             .setKind("kind3292052")
615             .setName("name3373707")
616             .setOperationGroupId("operationGroupId1716161683")
617             .setOperationType("operationType91999553")
618             .setProgress(-1001078227)
619             .setRegion("region-934795532")
620             .setSelfLink("selfLink1191800166")
621             .setStartTime("startTime-2129294769")
622             .setStatus(Status.DONE)
623             .setStatusMessage("statusMessage-958704715")
624             .setTargetId(-815576439)
625             .setTargetLink("targetLink486368555")
626             .setUser("user3599307")
627             .addAllWarnings(new ArrayList<Warnings>())
628             .setZone("zone3744684")
629             .build();
630     mockService.addResponse(expectedResponse);
631 
632     String project = "project-6911";
633     String region = "region-9622";
634     String backendService = "backendService-8873";
635     BackendService backendServiceResource = BackendService.newBuilder().build();
636 
637     Operation actualResponse =
638         client.updateAsync(project, region, backendService, backendServiceResource).get();
639     Assert.assertEquals(expectedResponse, actualResponse);
640 
641     List<String> actualRequests = mockService.getRequestPaths();
642     Assert.assertEquals(1, actualRequests.size());
643 
644     String apiClientHeaderKey =
645         mockService
646             .getRequestHeaders()
647             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
648             .iterator()
649             .next();
650     Assert.assertTrue(
651         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
652             .matcher(apiClientHeaderKey)
653             .matches());
654   }
655 
656   @Test
updateExceptionTest()657   public void updateExceptionTest() throws Exception {
658     ApiException exception =
659         ApiExceptionFactory.createException(
660             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
661     mockService.addException(exception);
662 
663     try {
664       String project = "project-6911";
665       String region = "region-9622";
666       String backendService = "backendService-8873";
667       BackendService backendServiceResource = BackendService.newBuilder().build();
668       client.updateAsync(project, region, backendService, backendServiceResource).get();
669       Assert.fail("No exception raised");
670     } catch (ExecutionException e) {
671     }
672   }
673 }
674