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