• 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.NetworksClient.ListPagedResponse;
20 import static com.google.cloud.compute.v1.NetworksClient.ListPeeringRoutesPagedResponse;
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.HttpJsonNetworksStub;
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.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 NetworksClientTest {
49   private static MockHttpService mockService;
50   private static NetworksClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonNetworksStub.getMethodDescriptors(), NetworksSettings.getDefaultEndpoint());
57     NetworksSettings settings =
58         NetworksSettings.newBuilder()
59             .setTransportChannelProvider(
60                 NetworksSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = NetworksClient.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
addPeeringTest()82   public void addPeeringTest() 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 network = "network-7324";
114     NetworksAddPeeringRequest networksAddPeeringRequestResource =
115         NetworksAddPeeringRequest.newBuilder().build();
116 
117     Operation actualResponse =
118         client.addPeeringAsync(project, network, networksAddPeeringRequestResource).get();
119     Assert.assertEquals(expectedResponse, actualResponse);
120 
121     List<String> actualRequests = mockService.getRequestPaths();
122     Assert.assertEquals(1, actualRequests.size());
123 
124     String apiClientHeaderKey =
125         mockService
126             .getRequestHeaders()
127             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
128             .iterator()
129             .next();
130     Assert.assertTrue(
131         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
132             .matcher(apiClientHeaderKey)
133             .matches());
134   }
135 
136   @Test
addPeeringExceptionTest()137   public void addPeeringExceptionTest() throws Exception {
138     ApiException exception =
139         ApiExceptionFactory.createException(
140             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
141     mockService.addException(exception);
142 
143     try {
144       String project = "project-6911";
145       String network = "network-7324";
146       NetworksAddPeeringRequest networksAddPeeringRequestResource =
147           NetworksAddPeeringRequest.newBuilder().build();
148       client.addPeeringAsync(project, network, networksAddPeeringRequestResource).get();
149       Assert.fail("No exception raised");
150     } catch (ExecutionException e) {
151     }
152   }
153 
154   @Test
deleteTest()155   public void deleteTest() throws Exception {
156     Operation expectedResponse =
157         Operation.newBuilder()
158             .setClientOperationId("clientOperationId-1230366697")
159             .setCreationTimestamp("creationTimestamp-370203401")
160             .setDescription("description-1724546052")
161             .setEndTime("endTime-1607243192")
162             .setError(Error.newBuilder().build())
163             .setHttpErrorMessage("httpErrorMessage1577303431")
164             .setHttpErrorStatusCode(0)
165             .setId(3355)
166             .setInsertTime("insertTime966165798")
167             .setKind("kind3292052")
168             .setName("name3373707")
169             .setOperationGroupId("operationGroupId1716161683")
170             .setOperationType("operationType91999553")
171             .setProgress(-1001078227)
172             .setRegion("region-934795532")
173             .setSelfLink("selfLink1191800166")
174             .setStartTime("startTime-2129294769")
175             .setStatus(Status.DONE)
176             .setStatusMessage("statusMessage-958704715")
177             .setTargetId(-815576439)
178             .setTargetLink("targetLink486368555")
179             .setUser("user3599307")
180             .addAllWarnings(new ArrayList<Warnings>())
181             .setZone("zone3744684")
182             .build();
183     mockService.addResponse(expectedResponse);
184 
185     String project = "project-6911";
186     String network = "network-7324";
187 
188     Operation actualResponse = client.deleteAsync(project, network).get();
189     Assert.assertEquals(expectedResponse, actualResponse);
190 
191     List<String> actualRequests = mockService.getRequestPaths();
192     Assert.assertEquals(1, actualRequests.size());
193 
194     String apiClientHeaderKey =
195         mockService
196             .getRequestHeaders()
197             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
198             .iterator()
199             .next();
200     Assert.assertTrue(
201         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
202             .matcher(apiClientHeaderKey)
203             .matches());
204   }
205 
206   @Test
deleteExceptionTest()207   public void deleteExceptionTest() throws Exception {
208     ApiException exception =
209         ApiExceptionFactory.createException(
210             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
211     mockService.addException(exception);
212 
213     try {
214       String project = "project-6911";
215       String network = "network-7324";
216       client.deleteAsync(project, network).get();
217       Assert.fail("No exception raised");
218     } catch (ExecutionException e) {
219     }
220   }
221 
222   @Test
getTest()223   public void getTest() throws Exception {
224     Network expectedResponse =
225         Network.newBuilder()
226             .setIPv4Range("iPv4Range100411000")
227             .setAutoCreateSubnetworks(true)
228             .setCreationTimestamp("creationTimestamp-370203401")
229             .setDescription("description-1724546052")
230             .setEnableUlaInternalIpv6(true)
231             .setFirewallPolicy("firewallPolicy1819692626")
232             .setGatewayIPv4("gatewayIPv4-435687895")
233             .setId(3355)
234             .setInternalIpv6Range("internalIpv6Range1368723801")
235             .setKind("kind3292052")
236             .setMtu(108462)
237             .setName("name3373707")
238             .setNetworkFirewallPolicyEnforcementOrder(
239                 "networkFirewallPolicyEnforcementOrder1610545966")
240             .addAllPeerings(new ArrayList<NetworkPeering>())
241             .setRoutingConfig(NetworkRoutingConfig.newBuilder().build())
242             .setSelfLink("selfLink1191800166")
243             .setSelfLinkWithId("selfLinkWithId-776809081")
244             .addAllSubnetworks(new ArrayList<String>())
245             .build();
246     mockService.addResponse(expectedResponse);
247 
248     String project = "project-6911";
249     String network = "network-7324";
250 
251     Network actualResponse = client.get(project, network);
252     Assert.assertEquals(expectedResponse, actualResponse);
253 
254     List<String> actualRequests = mockService.getRequestPaths();
255     Assert.assertEquals(1, actualRequests.size());
256 
257     String apiClientHeaderKey =
258         mockService
259             .getRequestHeaders()
260             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
261             .iterator()
262             .next();
263     Assert.assertTrue(
264         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
265             .matcher(apiClientHeaderKey)
266             .matches());
267   }
268 
269   @Test
getExceptionTest()270   public void getExceptionTest() throws Exception {
271     ApiException exception =
272         ApiExceptionFactory.createException(
273             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
274     mockService.addException(exception);
275 
276     try {
277       String project = "project-6911";
278       String network = "network-7324";
279       client.get(project, network);
280       Assert.fail("No exception raised");
281     } catch (InvalidArgumentException e) {
282       // Expected exception.
283     }
284   }
285 
286   @Test
getEffectiveFirewallsTest()287   public void getEffectiveFirewallsTest() throws Exception {
288     NetworksGetEffectiveFirewallsResponse expectedResponse =
289         NetworksGetEffectiveFirewallsResponse.newBuilder()
290             .addAllFirewallPolicys(
291                 new ArrayList<NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy>())
292             .addAllFirewalls(new ArrayList<Firewall>())
293             .build();
294     mockService.addResponse(expectedResponse);
295 
296     String project = "project-6911";
297     String network = "network-7324";
298 
299     NetworksGetEffectiveFirewallsResponse actualResponse =
300         client.getEffectiveFirewalls(project, network);
301     Assert.assertEquals(expectedResponse, actualResponse);
302 
303     List<String> actualRequests = mockService.getRequestPaths();
304     Assert.assertEquals(1, actualRequests.size());
305 
306     String apiClientHeaderKey =
307         mockService
308             .getRequestHeaders()
309             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
310             .iterator()
311             .next();
312     Assert.assertTrue(
313         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
314             .matcher(apiClientHeaderKey)
315             .matches());
316   }
317 
318   @Test
getEffectiveFirewallsExceptionTest()319   public void getEffectiveFirewallsExceptionTest() throws Exception {
320     ApiException exception =
321         ApiExceptionFactory.createException(
322             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
323     mockService.addException(exception);
324 
325     try {
326       String project = "project-6911";
327       String network = "network-7324";
328       client.getEffectiveFirewalls(project, network);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
insertTest()336   public void insertTest() throws Exception {
337     Operation expectedResponse =
338         Operation.newBuilder()
339             .setClientOperationId("clientOperationId-1230366697")
340             .setCreationTimestamp("creationTimestamp-370203401")
341             .setDescription("description-1724546052")
342             .setEndTime("endTime-1607243192")
343             .setError(Error.newBuilder().build())
344             .setHttpErrorMessage("httpErrorMessage1577303431")
345             .setHttpErrorStatusCode(0)
346             .setId(3355)
347             .setInsertTime("insertTime966165798")
348             .setKind("kind3292052")
349             .setName("name3373707")
350             .setOperationGroupId("operationGroupId1716161683")
351             .setOperationType("operationType91999553")
352             .setProgress(-1001078227)
353             .setRegion("region-934795532")
354             .setSelfLink("selfLink1191800166")
355             .setStartTime("startTime-2129294769")
356             .setStatus(Status.DONE)
357             .setStatusMessage("statusMessage-958704715")
358             .setTargetId(-815576439)
359             .setTargetLink("targetLink486368555")
360             .setUser("user3599307")
361             .addAllWarnings(new ArrayList<Warnings>())
362             .setZone("zone3744684")
363             .build();
364     mockService.addResponse(expectedResponse);
365 
366     String project = "project-6911";
367     Network networkResource = Network.newBuilder().build();
368 
369     Operation actualResponse = client.insertAsync(project, networkResource).get();
370     Assert.assertEquals(expectedResponse, actualResponse);
371 
372     List<String> actualRequests = mockService.getRequestPaths();
373     Assert.assertEquals(1, actualRequests.size());
374 
375     String apiClientHeaderKey =
376         mockService
377             .getRequestHeaders()
378             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
379             .iterator()
380             .next();
381     Assert.assertTrue(
382         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
383             .matcher(apiClientHeaderKey)
384             .matches());
385   }
386 
387   @Test
insertExceptionTest()388   public void insertExceptionTest() throws Exception {
389     ApiException exception =
390         ApiExceptionFactory.createException(
391             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
392     mockService.addException(exception);
393 
394     try {
395       String project = "project-6911";
396       Network networkResource = Network.newBuilder().build();
397       client.insertAsync(project, networkResource).get();
398       Assert.fail("No exception raised");
399     } catch (ExecutionException e) {
400     }
401   }
402 
403   @Test
listTest()404   public void listTest() throws Exception {
405     Network responsesElement = Network.newBuilder().build();
406     NetworkList expectedResponse =
407         NetworkList.newBuilder()
408             .setNextPageToken("")
409             .addAllItems(Arrays.asList(responsesElement))
410             .build();
411     mockService.addResponse(expectedResponse);
412 
413     String project = "project-6911";
414 
415     ListPagedResponse pagedListResponse = client.list(project);
416 
417     List<Network> resources = Lists.newArrayList(pagedListResponse.iterateAll());
418 
419     Assert.assertEquals(1, resources.size());
420     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
421 
422     List<String> actualRequests = mockService.getRequestPaths();
423     Assert.assertEquals(1, actualRequests.size());
424 
425     String apiClientHeaderKey =
426         mockService
427             .getRequestHeaders()
428             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
429             .iterator()
430             .next();
431     Assert.assertTrue(
432         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
433             .matcher(apiClientHeaderKey)
434             .matches());
435   }
436 
437   @Test
listExceptionTest()438   public void listExceptionTest() throws Exception {
439     ApiException exception =
440         ApiExceptionFactory.createException(
441             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
442     mockService.addException(exception);
443 
444     try {
445       String project = "project-6911";
446       client.list(project);
447       Assert.fail("No exception raised");
448     } catch (InvalidArgumentException e) {
449       // Expected exception.
450     }
451   }
452 
453   @Test
listPeeringRoutesTest()454   public void listPeeringRoutesTest() throws Exception {
455     ExchangedPeeringRoute responsesElement = ExchangedPeeringRoute.newBuilder().build();
456     ExchangedPeeringRoutesList expectedResponse =
457         ExchangedPeeringRoutesList.newBuilder()
458             .setNextPageToken("")
459             .addAllItems(Arrays.asList(responsesElement))
460             .build();
461     mockService.addResponse(expectedResponse);
462 
463     String project = "project-6911";
464     String network = "network-7324";
465 
466     ListPeeringRoutesPagedResponse pagedListResponse = client.listPeeringRoutes(project, network);
467 
468     List<ExchangedPeeringRoute> resources = Lists.newArrayList(pagedListResponse.iterateAll());
469 
470     Assert.assertEquals(1, resources.size());
471     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
472 
473     List<String> actualRequests = mockService.getRequestPaths();
474     Assert.assertEquals(1, actualRequests.size());
475 
476     String apiClientHeaderKey =
477         mockService
478             .getRequestHeaders()
479             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
480             .iterator()
481             .next();
482     Assert.assertTrue(
483         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
484             .matcher(apiClientHeaderKey)
485             .matches());
486   }
487 
488   @Test
listPeeringRoutesExceptionTest()489   public void listPeeringRoutesExceptionTest() throws Exception {
490     ApiException exception =
491         ApiExceptionFactory.createException(
492             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
493     mockService.addException(exception);
494 
495     try {
496       String project = "project-6911";
497       String network = "network-7324";
498       client.listPeeringRoutes(project, network);
499       Assert.fail("No exception raised");
500     } catch (InvalidArgumentException e) {
501       // Expected exception.
502     }
503   }
504 
505   @Test
patchTest()506   public void patchTest() throws Exception {
507     Operation expectedResponse =
508         Operation.newBuilder()
509             .setClientOperationId("clientOperationId-1230366697")
510             .setCreationTimestamp("creationTimestamp-370203401")
511             .setDescription("description-1724546052")
512             .setEndTime("endTime-1607243192")
513             .setError(Error.newBuilder().build())
514             .setHttpErrorMessage("httpErrorMessage1577303431")
515             .setHttpErrorStatusCode(0)
516             .setId(3355)
517             .setInsertTime("insertTime966165798")
518             .setKind("kind3292052")
519             .setName("name3373707")
520             .setOperationGroupId("operationGroupId1716161683")
521             .setOperationType("operationType91999553")
522             .setProgress(-1001078227)
523             .setRegion("region-934795532")
524             .setSelfLink("selfLink1191800166")
525             .setStartTime("startTime-2129294769")
526             .setStatus(Status.DONE)
527             .setStatusMessage("statusMessage-958704715")
528             .setTargetId(-815576439)
529             .setTargetLink("targetLink486368555")
530             .setUser("user3599307")
531             .addAllWarnings(new ArrayList<Warnings>())
532             .setZone("zone3744684")
533             .build();
534     mockService.addResponse(expectedResponse);
535 
536     String project = "project-6911";
537     String network = "network-7324";
538     Network networkResource = Network.newBuilder().build();
539 
540     Operation actualResponse = client.patchAsync(project, network, networkResource).get();
541     Assert.assertEquals(expectedResponse, actualResponse);
542 
543     List<String> actualRequests = mockService.getRequestPaths();
544     Assert.assertEquals(1, actualRequests.size());
545 
546     String apiClientHeaderKey =
547         mockService
548             .getRequestHeaders()
549             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
550             .iterator()
551             .next();
552     Assert.assertTrue(
553         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
554             .matcher(apiClientHeaderKey)
555             .matches());
556   }
557 
558   @Test
patchExceptionTest()559   public void patchExceptionTest() throws Exception {
560     ApiException exception =
561         ApiExceptionFactory.createException(
562             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
563     mockService.addException(exception);
564 
565     try {
566       String project = "project-6911";
567       String network = "network-7324";
568       Network networkResource = Network.newBuilder().build();
569       client.patchAsync(project, network, networkResource).get();
570       Assert.fail("No exception raised");
571     } catch (ExecutionException e) {
572     }
573   }
574 
575   @Test
removePeeringTest()576   public void removePeeringTest() throws Exception {
577     Operation expectedResponse =
578         Operation.newBuilder()
579             .setClientOperationId("clientOperationId-1230366697")
580             .setCreationTimestamp("creationTimestamp-370203401")
581             .setDescription("description-1724546052")
582             .setEndTime("endTime-1607243192")
583             .setError(Error.newBuilder().build())
584             .setHttpErrorMessage("httpErrorMessage1577303431")
585             .setHttpErrorStatusCode(0)
586             .setId(3355)
587             .setInsertTime("insertTime966165798")
588             .setKind("kind3292052")
589             .setName("name3373707")
590             .setOperationGroupId("operationGroupId1716161683")
591             .setOperationType("operationType91999553")
592             .setProgress(-1001078227)
593             .setRegion("region-934795532")
594             .setSelfLink("selfLink1191800166")
595             .setStartTime("startTime-2129294769")
596             .setStatus(Status.DONE)
597             .setStatusMessage("statusMessage-958704715")
598             .setTargetId(-815576439)
599             .setTargetLink("targetLink486368555")
600             .setUser("user3599307")
601             .addAllWarnings(new ArrayList<Warnings>())
602             .setZone("zone3744684")
603             .build();
604     mockService.addResponse(expectedResponse);
605 
606     String project = "project-6911";
607     String network = "network-7324";
608     NetworksRemovePeeringRequest networksRemovePeeringRequestResource =
609         NetworksRemovePeeringRequest.newBuilder().build();
610 
611     Operation actualResponse =
612         client.removePeeringAsync(project, network, networksRemovePeeringRequestResource).get();
613     Assert.assertEquals(expectedResponse, actualResponse);
614 
615     List<String> actualRequests = mockService.getRequestPaths();
616     Assert.assertEquals(1, actualRequests.size());
617 
618     String apiClientHeaderKey =
619         mockService
620             .getRequestHeaders()
621             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
622             .iterator()
623             .next();
624     Assert.assertTrue(
625         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
626             .matcher(apiClientHeaderKey)
627             .matches());
628   }
629 
630   @Test
removePeeringExceptionTest()631   public void removePeeringExceptionTest() throws Exception {
632     ApiException exception =
633         ApiExceptionFactory.createException(
634             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
635     mockService.addException(exception);
636 
637     try {
638       String project = "project-6911";
639       String network = "network-7324";
640       NetworksRemovePeeringRequest networksRemovePeeringRequestResource =
641           NetworksRemovePeeringRequest.newBuilder().build();
642       client.removePeeringAsync(project, network, networksRemovePeeringRequestResource).get();
643       Assert.fail("No exception raised");
644     } catch (ExecutionException e) {
645     }
646   }
647 
648   @Test
switchToCustomModeTest()649   public void switchToCustomModeTest() throws Exception {
650     Operation expectedResponse =
651         Operation.newBuilder()
652             .setClientOperationId("clientOperationId-1230366697")
653             .setCreationTimestamp("creationTimestamp-370203401")
654             .setDescription("description-1724546052")
655             .setEndTime("endTime-1607243192")
656             .setError(Error.newBuilder().build())
657             .setHttpErrorMessage("httpErrorMessage1577303431")
658             .setHttpErrorStatusCode(0)
659             .setId(3355)
660             .setInsertTime("insertTime966165798")
661             .setKind("kind3292052")
662             .setName("name3373707")
663             .setOperationGroupId("operationGroupId1716161683")
664             .setOperationType("operationType91999553")
665             .setProgress(-1001078227)
666             .setRegion("region-934795532")
667             .setSelfLink("selfLink1191800166")
668             .setStartTime("startTime-2129294769")
669             .setStatus(Status.DONE)
670             .setStatusMessage("statusMessage-958704715")
671             .setTargetId(-815576439)
672             .setTargetLink("targetLink486368555")
673             .setUser("user3599307")
674             .addAllWarnings(new ArrayList<Warnings>())
675             .setZone("zone3744684")
676             .build();
677     mockService.addResponse(expectedResponse);
678 
679     String project = "project-6911";
680     String network = "network-7324";
681 
682     Operation actualResponse = client.switchToCustomModeAsync(project, network).get();
683     Assert.assertEquals(expectedResponse, actualResponse);
684 
685     List<String> actualRequests = mockService.getRequestPaths();
686     Assert.assertEquals(1, actualRequests.size());
687 
688     String apiClientHeaderKey =
689         mockService
690             .getRequestHeaders()
691             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
692             .iterator()
693             .next();
694     Assert.assertTrue(
695         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
696             .matcher(apiClientHeaderKey)
697             .matches());
698   }
699 
700   @Test
switchToCustomModeExceptionTest()701   public void switchToCustomModeExceptionTest() throws Exception {
702     ApiException exception =
703         ApiExceptionFactory.createException(
704             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
705     mockService.addException(exception);
706 
707     try {
708       String project = "project-6911";
709       String network = "network-7324";
710       client.switchToCustomModeAsync(project, network).get();
711       Assert.fail("No exception raised");
712     } catch (ExecutionException e) {
713     }
714   }
715 
716   @Test
updatePeeringTest()717   public void updatePeeringTest() throws Exception {
718     Operation expectedResponse =
719         Operation.newBuilder()
720             .setClientOperationId("clientOperationId-1230366697")
721             .setCreationTimestamp("creationTimestamp-370203401")
722             .setDescription("description-1724546052")
723             .setEndTime("endTime-1607243192")
724             .setError(Error.newBuilder().build())
725             .setHttpErrorMessage("httpErrorMessage1577303431")
726             .setHttpErrorStatusCode(0)
727             .setId(3355)
728             .setInsertTime("insertTime966165798")
729             .setKind("kind3292052")
730             .setName("name3373707")
731             .setOperationGroupId("operationGroupId1716161683")
732             .setOperationType("operationType91999553")
733             .setProgress(-1001078227)
734             .setRegion("region-934795532")
735             .setSelfLink("selfLink1191800166")
736             .setStartTime("startTime-2129294769")
737             .setStatus(Status.DONE)
738             .setStatusMessage("statusMessage-958704715")
739             .setTargetId(-815576439)
740             .setTargetLink("targetLink486368555")
741             .setUser("user3599307")
742             .addAllWarnings(new ArrayList<Warnings>())
743             .setZone("zone3744684")
744             .build();
745     mockService.addResponse(expectedResponse);
746 
747     String project = "project-6911";
748     String network = "network-7324";
749     NetworksUpdatePeeringRequest networksUpdatePeeringRequestResource =
750         NetworksUpdatePeeringRequest.newBuilder().build();
751 
752     Operation actualResponse =
753         client.updatePeeringAsync(project, network, networksUpdatePeeringRequestResource).get();
754     Assert.assertEquals(expectedResponse, actualResponse);
755 
756     List<String> actualRequests = mockService.getRequestPaths();
757     Assert.assertEquals(1, actualRequests.size());
758 
759     String apiClientHeaderKey =
760         mockService
761             .getRequestHeaders()
762             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
763             .iterator()
764             .next();
765     Assert.assertTrue(
766         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
767             .matcher(apiClientHeaderKey)
768             .matches());
769   }
770 
771   @Test
updatePeeringExceptionTest()772   public void updatePeeringExceptionTest() throws Exception {
773     ApiException exception =
774         ApiExceptionFactory.createException(
775             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
776     mockService.addException(exception);
777 
778     try {
779       String project = "project-6911";
780       String network = "network-7324";
781       NetworksUpdatePeeringRequest networksUpdatePeeringRequestResource =
782           NetworksUpdatePeeringRequest.newBuilder().build();
783       client.updatePeeringAsync(project, network, networksUpdatePeeringRequestResource).get();
784       Assert.fail("No exception raised");
785     } catch (ExecutionException e) {
786     }
787   }
788 }
789