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