• 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.BackendServicesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.BackendServicesClient.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.HttpJsonBackendServicesStub;
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 BackendServicesClientTest {
52   private static MockHttpService mockService;
53   private static BackendServicesClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonBackendServicesStub.getMethodDescriptors(),
60             BackendServicesSettings.getDefaultEndpoint());
61     BackendServicesSettings settings =
62         BackendServicesSettings.newBuilder()
63             .setTransportChannelProvider(
64                 BackendServicesSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = BackendServicesClient.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
addSignedUrlKeyTest()86   public void addSignedUrlKeyTest() throws Exception {
87     Operation expectedResponse =
88         Operation.newBuilder()
89             .setClientOperationId("clientOperationId-1230366697")
90             .setCreationTimestamp("creationTimestamp-370203401")
91             .setDescription("description-1724546052")
92             .setEndTime("endTime-1607243192")
93             .setError(Error.newBuilder().build())
94             .setHttpErrorMessage("httpErrorMessage1577303431")
95             .setHttpErrorStatusCode(0)
96             .setId(3355)
97             .setInsertTime("insertTime966165798")
98             .setKind("kind3292052")
99             .setName("name3373707")
100             .setOperationGroupId("operationGroupId1716161683")
101             .setOperationType("operationType91999553")
102             .setProgress(-1001078227)
103             .setRegion("region-934795532")
104             .setSelfLink("selfLink1191800166")
105             .setStartTime("startTime-2129294769")
106             .setStatus(Status.DONE)
107             .setStatusMessage("statusMessage-958704715")
108             .setTargetId(-815576439)
109             .setTargetLink("targetLink486368555")
110             .setUser("user3599307")
111             .addAllWarnings(new ArrayList<Warnings>())
112             .setZone("zone3744684")
113             .build();
114     mockService.addResponse(expectedResponse);
115 
116     String project = "project-6911";
117     String backendService = "backendService-8873";
118     SignedUrlKey signedUrlKeyResource = SignedUrlKey.newBuilder().build();
119 
120     Operation actualResponse =
121         client.addSignedUrlKeyAsync(project, backendService, signedUrlKeyResource).get();
122     Assert.assertEquals(expectedResponse, actualResponse);
123 
124     List<String> actualRequests = mockService.getRequestPaths();
125     Assert.assertEquals(1, actualRequests.size());
126 
127     String apiClientHeaderKey =
128         mockService
129             .getRequestHeaders()
130             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
131             .iterator()
132             .next();
133     Assert.assertTrue(
134         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
135             .matcher(apiClientHeaderKey)
136             .matches());
137   }
138 
139   @Test
addSignedUrlKeyExceptionTest()140   public void addSignedUrlKeyExceptionTest() throws Exception {
141     ApiException exception =
142         ApiExceptionFactory.createException(
143             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
144     mockService.addException(exception);
145 
146     try {
147       String project = "project-6911";
148       String backendService = "backendService-8873";
149       SignedUrlKey signedUrlKeyResource = SignedUrlKey.newBuilder().build();
150       client.addSignedUrlKeyAsync(project, backendService, signedUrlKeyResource).get();
151       Assert.fail("No exception raised");
152     } catch (ExecutionException e) {
153     }
154   }
155 
156   @Test
aggregatedListTest()157   public void aggregatedListTest() throws Exception {
158     BackendServicesScopedList responsesElement = BackendServicesScopedList.newBuilder().build();
159     BackendServiceAggregatedList expectedResponse =
160         BackendServiceAggregatedList.newBuilder()
161             .setNextPageToken("")
162             .putAllItems(Collections.singletonMap("items", responsesElement))
163             .build();
164     mockService.addResponse(expectedResponse);
165 
166     String project = "project-6911";
167 
168     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
169 
170     List<Map.Entry<String, BackendServicesScopedList>> resources =
171         Lists.newArrayList(pagedListResponse.iterateAll());
172 
173     Assert.assertEquals(1, resources.size());
174     Assert.assertEquals(
175         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
176 
177     List<String> actualRequests = mockService.getRequestPaths();
178     Assert.assertEquals(1, actualRequests.size());
179 
180     String apiClientHeaderKey =
181         mockService
182             .getRequestHeaders()
183             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
184             .iterator()
185             .next();
186     Assert.assertTrue(
187         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
188             .matcher(apiClientHeaderKey)
189             .matches());
190   }
191 
192   @Test
aggregatedListExceptionTest()193   public void aggregatedListExceptionTest() throws Exception {
194     ApiException exception =
195         ApiExceptionFactory.createException(
196             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
197     mockService.addException(exception);
198 
199     try {
200       String project = "project-6911";
201       client.aggregatedList(project);
202       Assert.fail("No exception raised");
203     } catch (InvalidArgumentException e) {
204       // Expected exception.
205     }
206   }
207 
208   @Test
deleteTest()209   public void deleteTest() throws Exception {
210     Operation expectedResponse =
211         Operation.newBuilder()
212             .setClientOperationId("clientOperationId-1230366697")
213             .setCreationTimestamp("creationTimestamp-370203401")
214             .setDescription("description-1724546052")
215             .setEndTime("endTime-1607243192")
216             .setError(Error.newBuilder().build())
217             .setHttpErrorMessage("httpErrorMessage1577303431")
218             .setHttpErrorStatusCode(0)
219             .setId(3355)
220             .setInsertTime("insertTime966165798")
221             .setKind("kind3292052")
222             .setName("name3373707")
223             .setOperationGroupId("operationGroupId1716161683")
224             .setOperationType("operationType91999553")
225             .setProgress(-1001078227)
226             .setRegion("region-934795532")
227             .setSelfLink("selfLink1191800166")
228             .setStartTime("startTime-2129294769")
229             .setStatus(Status.DONE)
230             .setStatusMessage("statusMessage-958704715")
231             .setTargetId(-815576439)
232             .setTargetLink("targetLink486368555")
233             .setUser("user3599307")
234             .addAllWarnings(new ArrayList<Warnings>())
235             .setZone("zone3744684")
236             .build();
237     mockService.addResponse(expectedResponse);
238 
239     String project = "project-6911";
240     String backendService = "backendService-8873";
241 
242     Operation actualResponse = client.deleteAsync(project, backendService).get();
243     Assert.assertEquals(expectedResponse, actualResponse);
244 
245     List<String> actualRequests = mockService.getRequestPaths();
246     Assert.assertEquals(1, actualRequests.size());
247 
248     String apiClientHeaderKey =
249         mockService
250             .getRequestHeaders()
251             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
252             .iterator()
253             .next();
254     Assert.assertTrue(
255         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
256             .matcher(apiClientHeaderKey)
257             .matches());
258   }
259 
260   @Test
deleteExceptionTest()261   public void deleteExceptionTest() throws Exception {
262     ApiException exception =
263         ApiExceptionFactory.createException(
264             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
265     mockService.addException(exception);
266 
267     try {
268       String project = "project-6911";
269       String backendService = "backendService-8873";
270       client.deleteAsync(project, backendService).get();
271       Assert.fail("No exception raised");
272     } catch (ExecutionException e) {
273     }
274   }
275 
276   @Test
deleteSignedUrlKeyTest()277   public void deleteSignedUrlKeyTest() throws Exception {
278     Operation expectedResponse =
279         Operation.newBuilder()
280             .setClientOperationId("clientOperationId-1230366697")
281             .setCreationTimestamp("creationTimestamp-370203401")
282             .setDescription("description-1724546052")
283             .setEndTime("endTime-1607243192")
284             .setError(Error.newBuilder().build())
285             .setHttpErrorMessage("httpErrorMessage1577303431")
286             .setHttpErrorStatusCode(0)
287             .setId(3355)
288             .setInsertTime("insertTime966165798")
289             .setKind("kind3292052")
290             .setName("name3373707")
291             .setOperationGroupId("operationGroupId1716161683")
292             .setOperationType("operationType91999553")
293             .setProgress(-1001078227)
294             .setRegion("region-934795532")
295             .setSelfLink("selfLink1191800166")
296             .setStartTime("startTime-2129294769")
297             .setStatus(Status.DONE)
298             .setStatusMessage("statusMessage-958704715")
299             .setTargetId(-815576439)
300             .setTargetLink("targetLink486368555")
301             .setUser("user3599307")
302             .addAllWarnings(new ArrayList<Warnings>())
303             .setZone("zone3744684")
304             .build();
305     mockService.addResponse(expectedResponse);
306 
307     String project = "project-6911";
308     String backendService = "backendService-8873";
309     String keyName = "keyName-815643254";
310 
311     Operation actualResponse =
312         client.deleteSignedUrlKeyAsync(project, backendService, keyName).get();
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
deleteSignedUrlKeyExceptionTest()331   public void deleteSignedUrlKeyExceptionTest() 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 backendService = "backendService-8873";
340       String keyName = "keyName-815643254";
341       client.deleteSignedUrlKeyAsync(project, backendService, keyName).get();
342       Assert.fail("No exception raised");
343     } catch (ExecutionException e) {
344     }
345   }
346 
347   @Test
getTest()348   public void getTest() throws Exception {
349     BackendService expectedResponse =
350         BackendService.newBuilder()
351             .setAffinityCookieTtlSec(-1777486694)
352             .addAllBackends(new ArrayList<Backend>())
353             .setCdnPolicy(BackendServiceCdnPolicy.newBuilder().build())
354             .setCircuitBreakers(CircuitBreakers.newBuilder().build())
355             .setCompressionMode("compressionMode71820329")
356             .setConnectionDraining(ConnectionDraining.newBuilder().build())
357             .setConnectionTrackingPolicy(
358                 BackendServiceConnectionTrackingPolicy.newBuilder().build())
359             .setConsistentHash(ConsistentHashLoadBalancerSettings.newBuilder().build())
360             .setCreationTimestamp("creationTimestamp-370203401")
361             .addAllCustomRequestHeaders(new ArrayList<String>())
362             .addAllCustomResponseHeaders(new ArrayList<String>())
363             .setDescription("description-1724546052")
364             .setEdgeSecurityPolicy("edgeSecurityPolicy-630226001")
365             .setEnableCDN(true)
366             .setFailoverPolicy(BackendServiceFailoverPolicy.newBuilder().build())
367             .setFingerprint("fingerprint-1375934236")
368             .addAllHealthChecks(new ArrayList<String>())
369             .setIap(BackendServiceIAP.newBuilder().build())
370             .setId(3355)
371             .setKind("kind3292052")
372             .setLoadBalancingScheme("loadBalancingScheme-1223583272")
373             .addAllLocalityLbPolicies(
374                 new ArrayList<BackendServiceLocalityLoadBalancingPolicyConfig>())
375             .setLocalityLbPolicy("localityLbPolicy-1807450933")
376             .setLogConfig(BackendServiceLogConfig.newBuilder().build())
377             .setMaxStreamDuration(Duration.newBuilder().build())
378             .setName("name3373707")
379             .setNetwork("network1843485230")
380             .setOutlierDetection(OutlierDetection.newBuilder().build())
381             .setPort(3446913)
382             .setPortName("portName728194732")
383             .setProtocol("protocol-989163880")
384             .setRegion("region-934795532")
385             .setSecurityPolicy("securityPolicy-788621166")
386             .setSecuritySettings(SecuritySettings.newBuilder().build())
387             .setSelfLink("selfLink1191800166")
388             .addAllServiceBindings(new ArrayList<String>())
389             .setSessionAffinity("sessionAffinity-289859106")
390             .setSubsetting(Subsetting.newBuilder().build())
391             .setTimeoutSec(-2067488653)
392             .build();
393     mockService.addResponse(expectedResponse);
394 
395     String project = "project-6911";
396     String backendService = "backendService-8873";
397 
398     BackendService actualResponse = client.get(project, backendService);
399     Assert.assertEquals(expectedResponse, actualResponse);
400 
401     List<String> actualRequests = mockService.getRequestPaths();
402     Assert.assertEquals(1, actualRequests.size());
403 
404     String apiClientHeaderKey =
405         mockService
406             .getRequestHeaders()
407             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
408             .iterator()
409             .next();
410     Assert.assertTrue(
411         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
412             .matcher(apiClientHeaderKey)
413             .matches());
414   }
415 
416   @Test
getExceptionTest()417   public void getExceptionTest() throws Exception {
418     ApiException exception =
419         ApiExceptionFactory.createException(
420             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
421     mockService.addException(exception);
422 
423     try {
424       String project = "project-6911";
425       String backendService = "backendService-8873";
426       client.get(project, backendService);
427       Assert.fail("No exception raised");
428     } catch (InvalidArgumentException e) {
429       // Expected exception.
430     }
431   }
432 
433   @Test
getHealthTest()434   public void getHealthTest() throws Exception {
435     BackendServiceGroupHealth expectedResponse =
436         BackendServiceGroupHealth.newBuilder()
437             .putAllAnnotations(new HashMap<String, String>())
438             .addAllHealthStatus(new ArrayList<HealthStatus>())
439             .setKind("kind3292052")
440             .build();
441     mockService.addResponse(expectedResponse);
442 
443     String project = "project-6911";
444     String backendService = "backendService-8873";
445     ResourceGroupReference resourceGroupReferenceResource =
446         ResourceGroupReference.newBuilder().build();
447 
448     BackendServiceGroupHealth actualResponse =
449         client.getHealth(project, backendService, resourceGroupReferenceResource);
450     Assert.assertEquals(expectedResponse, actualResponse);
451 
452     List<String> actualRequests = mockService.getRequestPaths();
453     Assert.assertEquals(1, actualRequests.size());
454 
455     String apiClientHeaderKey =
456         mockService
457             .getRequestHeaders()
458             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
459             .iterator()
460             .next();
461     Assert.assertTrue(
462         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
463             .matcher(apiClientHeaderKey)
464             .matches());
465   }
466 
467   @Test
getHealthExceptionTest()468   public void getHealthExceptionTest() throws Exception {
469     ApiException exception =
470         ApiExceptionFactory.createException(
471             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
472     mockService.addException(exception);
473 
474     try {
475       String project = "project-6911";
476       String backendService = "backendService-8873";
477       ResourceGroupReference resourceGroupReferenceResource =
478           ResourceGroupReference.newBuilder().build();
479       client.getHealth(project, backendService, resourceGroupReferenceResource);
480       Assert.fail("No exception raised");
481     } catch (InvalidArgumentException e) {
482       // Expected exception.
483     }
484   }
485 
486   @Test
getIamPolicyTest()487   public void getIamPolicyTest() throws Exception {
488     Policy expectedResponse =
489         Policy.newBuilder()
490             .addAllAuditConfigs(new ArrayList<AuditConfig>())
491             .addAllBindings(new ArrayList<Binding>())
492             .setEtag("etag3123477")
493             .setIamOwned(true)
494             .addAllRules(new ArrayList<Rule>())
495             .setVersion(351608024)
496             .build();
497     mockService.addResponse(expectedResponse);
498 
499     String project = "project-6911";
500     String resource = "resource-756";
501 
502     Policy actualResponse = client.getIamPolicy(project, resource);
503     Assert.assertEquals(expectedResponse, actualResponse);
504 
505     List<String> actualRequests = mockService.getRequestPaths();
506     Assert.assertEquals(1, actualRequests.size());
507 
508     String apiClientHeaderKey =
509         mockService
510             .getRequestHeaders()
511             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
512             .iterator()
513             .next();
514     Assert.assertTrue(
515         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
516             .matcher(apiClientHeaderKey)
517             .matches());
518   }
519 
520   @Test
getIamPolicyExceptionTest()521   public void getIamPolicyExceptionTest() throws Exception {
522     ApiException exception =
523         ApiExceptionFactory.createException(
524             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
525     mockService.addException(exception);
526 
527     try {
528       String project = "project-6911";
529       String resource = "resource-756";
530       client.getIamPolicy(project, resource);
531       Assert.fail("No exception raised");
532     } catch (InvalidArgumentException e) {
533       // Expected exception.
534     }
535   }
536 
537   @Test
insertTest()538   public void insertTest() throws Exception {
539     Operation expectedResponse =
540         Operation.newBuilder()
541             .setClientOperationId("clientOperationId-1230366697")
542             .setCreationTimestamp("creationTimestamp-370203401")
543             .setDescription("description-1724546052")
544             .setEndTime("endTime-1607243192")
545             .setError(Error.newBuilder().build())
546             .setHttpErrorMessage("httpErrorMessage1577303431")
547             .setHttpErrorStatusCode(0)
548             .setId(3355)
549             .setInsertTime("insertTime966165798")
550             .setKind("kind3292052")
551             .setName("name3373707")
552             .setOperationGroupId("operationGroupId1716161683")
553             .setOperationType("operationType91999553")
554             .setProgress(-1001078227)
555             .setRegion("region-934795532")
556             .setSelfLink("selfLink1191800166")
557             .setStartTime("startTime-2129294769")
558             .setStatus(Status.DONE)
559             .setStatusMessage("statusMessage-958704715")
560             .setTargetId(-815576439)
561             .setTargetLink("targetLink486368555")
562             .setUser("user3599307")
563             .addAllWarnings(new ArrayList<Warnings>())
564             .setZone("zone3744684")
565             .build();
566     mockService.addResponse(expectedResponse);
567 
568     String project = "project-6911";
569     BackendService backendServiceResource = BackendService.newBuilder().build();
570 
571     Operation actualResponse = client.insertAsync(project, backendServiceResource).get();
572     Assert.assertEquals(expectedResponse, actualResponse);
573 
574     List<String> actualRequests = mockService.getRequestPaths();
575     Assert.assertEquals(1, actualRequests.size());
576 
577     String apiClientHeaderKey =
578         mockService
579             .getRequestHeaders()
580             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
581             .iterator()
582             .next();
583     Assert.assertTrue(
584         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
585             .matcher(apiClientHeaderKey)
586             .matches());
587   }
588 
589   @Test
insertExceptionTest()590   public void insertExceptionTest() throws Exception {
591     ApiException exception =
592         ApiExceptionFactory.createException(
593             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
594     mockService.addException(exception);
595 
596     try {
597       String project = "project-6911";
598       BackendService backendServiceResource = BackendService.newBuilder().build();
599       client.insertAsync(project, backendServiceResource).get();
600       Assert.fail("No exception raised");
601     } catch (ExecutionException e) {
602     }
603   }
604 
605   @Test
listTest()606   public void listTest() throws Exception {
607     BackendService responsesElement = BackendService.newBuilder().build();
608     BackendServiceList expectedResponse =
609         BackendServiceList.newBuilder()
610             .setNextPageToken("")
611             .addAllItems(Arrays.asList(responsesElement))
612             .build();
613     mockService.addResponse(expectedResponse);
614 
615     String project = "project-6911";
616 
617     ListPagedResponse pagedListResponse = client.list(project);
618 
619     List<BackendService> resources = Lists.newArrayList(pagedListResponse.iterateAll());
620 
621     Assert.assertEquals(1, resources.size());
622     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
623 
624     List<String> actualRequests = mockService.getRequestPaths();
625     Assert.assertEquals(1, actualRequests.size());
626 
627     String apiClientHeaderKey =
628         mockService
629             .getRequestHeaders()
630             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
631             .iterator()
632             .next();
633     Assert.assertTrue(
634         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
635             .matcher(apiClientHeaderKey)
636             .matches());
637   }
638 
639   @Test
listExceptionTest()640   public void listExceptionTest() throws Exception {
641     ApiException exception =
642         ApiExceptionFactory.createException(
643             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
644     mockService.addException(exception);
645 
646     try {
647       String project = "project-6911";
648       client.list(project);
649       Assert.fail("No exception raised");
650     } catch (InvalidArgumentException e) {
651       // Expected exception.
652     }
653   }
654 
655   @Test
patchTest()656   public void patchTest() throws Exception {
657     Operation expectedResponse =
658         Operation.newBuilder()
659             .setClientOperationId("clientOperationId-1230366697")
660             .setCreationTimestamp("creationTimestamp-370203401")
661             .setDescription("description-1724546052")
662             .setEndTime("endTime-1607243192")
663             .setError(Error.newBuilder().build())
664             .setHttpErrorMessage("httpErrorMessage1577303431")
665             .setHttpErrorStatusCode(0)
666             .setId(3355)
667             .setInsertTime("insertTime966165798")
668             .setKind("kind3292052")
669             .setName("name3373707")
670             .setOperationGroupId("operationGroupId1716161683")
671             .setOperationType("operationType91999553")
672             .setProgress(-1001078227)
673             .setRegion("region-934795532")
674             .setSelfLink("selfLink1191800166")
675             .setStartTime("startTime-2129294769")
676             .setStatus(Status.DONE)
677             .setStatusMessage("statusMessage-958704715")
678             .setTargetId(-815576439)
679             .setTargetLink("targetLink486368555")
680             .setUser("user3599307")
681             .addAllWarnings(new ArrayList<Warnings>())
682             .setZone("zone3744684")
683             .build();
684     mockService.addResponse(expectedResponse);
685 
686     String project = "project-6911";
687     String backendService = "backendService-8873";
688     BackendService backendServiceResource = BackendService.newBuilder().build();
689 
690     Operation actualResponse =
691         client.patchAsync(project, backendService, backendServiceResource).get();
692     Assert.assertEquals(expectedResponse, actualResponse);
693 
694     List<String> actualRequests = mockService.getRequestPaths();
695     Assert.assertEquals(1, actualRequests.size());
696 
697     String apiClientHeaderKey =
698         mockService
699             .getRequestHeaders()
700             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
701             .iterator()
702             .next();
703     Assert.assertTrue(
704         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
705             .matcher(apiClientHeaderKey)
706             .matches());
707   }
708 
709   @Test
patchExceptionTest()710   public void patchExceptionTest() throws Exception {
711     ApiException exception =
712         ApiExceptionFactory.createException(
713             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
714     mockService.addException(exception);
715 
716     try {
717       String project = "project-6911";
718       String backendService = "backendService-8873";
719       BackendService backendServiceResource = BackendService.newBuilder().build();
720       client.patchAsync(project, backendService, backendServiceResource).get();
721       Assert.fail("No exception raised");
722     } catch (ExecutionException e) {
723     }
724   }
725 
726   @Test
setEdgeSecurityPolicyTest()727   public void setEdgeSecurityPolicyTest() throws Exception {
728     Operation expectedResponse =
729         Operation.newBuilder()
730             .setClientOperationId("clientOperationId-1230366697")
731             .setCreationTimestamp("creationTimestamp-370203401")
732             .setDescription("description-1724546052")
733             .setEndTime("endTime-1607243192")
734             .setError(Error.newBuilder().build())
735             .setHttpErrorMessage("httpErrorMessage1577303431")
736             .setHttpErrorStatusCode(0)
737             .setId(3355)
738             .setInsertTime("insertTime966165798")
739             .setKind("kind3292052")
740             .setName("name3373707")
741             .setOperationGroupId("operationGroupId1716161683")
742             .setOperationType("operationType91999553")
743             .setProgress(-1001078227)
744             .setRegion("region-934795532")
745             .setSelfLink("selfLink1191800166")
746             .setStartTime("startTime-2129294769")
747             .setStatus(Status.DONE)
748             .setStatusMessage("statusMessage-958704715")
749             .setTargetId(-815576439)
750             .setTargetLink("targetLink486368555")
751             .setUser("user3599307")
752             .addAllWarnings(new ArrayList<Warnings>())
753             .setZone("zone3744684")
754             .build();
755     mockService.addResponse(expectedResponse);
756 
757     String project = "project-6911";
758     String backendService = "backendService-8873";
759     SecurityPolicyReference securityPolicyReferenceResource =
760         SecurityPolicyReference.newBuilder().build();
761 
762     Operation actualResponse =
763         client
764             .setEdgeSecurityPolicyAsync(project, backendService, securityPolicyReferenceResource)
765             .get();
766     Assert.assertEquals(expectedResponse, actualResponse);
767 
768     List<String> actualRequests = mockService.getRequestPaths();
769     Assert.assertEquals(1, actualRequests.size());
770 
771     String apiClientHeaderKey =
772         mockService
773             .getRequestHeaders()
774             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
775             .iterator()
776             .next();
777     Assert.assertTrue(
778         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
779             .matcher(apiClientHeaderKey)
780             .matches());
781   }
782 
783   @Test
setEdgeSecurityPolicyExceptionTest()784   public void setEdgeSecurityPolicyExceptionTest() throws Exception {
785     ApiException exception =
786         ApiExceptionFactory.createException(
787             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
788     mockService.addException(exception);
789 
790     try {
791       String project = "project-6911";
792       String backendService = "backendService-8873";
793       SecurityPolicyReference securityPolicyReferenceResource =
794           SecurityPolicyReference.newBuilder().build();
795       client
796           .setEdgeSecurityPolicyAsync(project, backendService, securityPolicyReferenceResource)
797           .get();
798       Assert.fail("No exception raised");
799     } catch (ExecutionException e) {
800     }
801   }
802 
803   @Test
setIamPolicyTest()804   public void setIamPolicyTest() throws Exception {
805     Policy expectedResponse =
806         Policy.newBuilder()
807             .addAllAuditConfigs(new ArrayList<AuditConfig>())
808             .addAllBindings(new ArrayList<Binding>())
809             .setEtag("etag3123477")
810             .setIamOwned(true)
811             .addAllRules(new ArrayList<Rule>())
812             .setVersion(351608024)
813             .build();
814     mockService.addResponse(expectedResponse);
815 
816     String project = "project-6911";
817     String resource = "resource-756";
818     GlobalSetPolicyRequest globalSetPolicyRequestResource =
819         GlobalSetPolicyRequest.newBuilder().build();
820 
821     Policy actualResponse = client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
822     Assert.assertEquals(expectedResponse, actualResponse);
823 
824     List<String> actualRequests = mockService.getRequestPaths();
825     Assert.assertEquals(1, actualRequests.size());
826 
827     String apiClientHeaderKey =
828         mockService
829             .getRequestHeaders()
830             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
831             .iterator()
832             .next();
833     Assert.assertTrue(
834         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
835             .matcher(apiClientHeaderKey)
836             .matches());
837   }
838 
839   @Test
setIamPolicyExceptionTest()840   public void setIamPolicyExceptionTest() throws Exception {
841     ApiException exception =
842         ApiExceptionFactory.createException(
843             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
844     mockService.addException(exception);
845 
846     try {
847       String project = "project-6911";
848       String resource = "resource-756";
849       GlobalSetPolicyRequest globalSetPolicyRequestResource =
850           GlobalSetPolicyRequest.newBuilder().build();
851       client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
852       Assert.fail("No exception raised");
853     } catch (InvalidArgumentException e) {
854       // Expected exception.
855     }
856   }
857 
858   @Test
setSecurityPolicyTest()859   public void setSecurityPolicyTest() throws Exception {
860     Operation expectedResponse =
861         Operation.newBuilder()
862             .setClientOperationId("clientOperationId-1230366697")
863             .setCreationTimestamp("creationTimestamp-370203401")
864             .setDescription("description-1724546052")
865             .setEndTime("endTime-1607243192")
866             .setError(Error.newBuilder().build())
867             .setHttpErrorMessage("httpErrorMessage1577303431")
868             .setHttpErrorStatusCode(0)
869             .setId(3355)
870             .setInsertTime("insertTime966165798")
871             .setKind("kind3292052")
872             .setName("name3373707")
873             .setOperationGroupId("operationGroupId1716161683")
874             .setOperationType("operationType91999553")
875             .setProgress(-1001078227)
876             .setRegion("region-934795532")
877             .setSelfLink("selfLink1191800166")
878             .setStartTime("startTime-2129294769")
879             .setStatus(Status.DONE)
880             .setStatusMessage("statusMessage-958704715")
881             .setTargetId(-815576439)
882             .setTargetLink("targetLink486368555")
883             .setUser("user3599307")
884             .addAllWarnings(new ArrayList<Warnings>())
885             .setZone("zone3744684")
886             .build();
887     mockService.addResponse(expectedResponse);
888 
889     String project = "project-6911";
890     String backendService = "backendService-8873";
891     SecurityPolicyReference securityPolicyReferenceResource =
892         SecurityPolicyReference.newBuilder().build();
893 
894     Operation actualResponse =
895         client
896             .setSecurityPolicyAsync(project, backendService, securityPolicyReferenceResource)
897             .get();
898     Assert.assertEquals(expectedResponse, actualResponse);
899 
900     List<String> actualRequests = mockService.getRequestPaths();
901     Assert.assertEquals(1, actualRequests.size());
902 
903     String apiClientHeaderKey =
904         mockService
905             .getRequestHeaders()
906             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
907             .iterator()
908             .next();
909     Assert.assertTrue(
910         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
911             .matcher(apiClientHeaderKey)
912             .matches());
913   }
914 
915   @Test
setSecurityPolicyExceptionTest()916   public void setSecurityPolicyExceptionTest() throws Exception {
917     ApiException exception =
918         ApiExceptionFactory.createException(
919             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
920     mockService.addException(exception);
921 
922     try {
923       String project = "project-6911";
924       String backendService = "backendService-8873";
925       SecurityPolicyReference securityPolicyReferenceResource =
926           SecurityPolicyReference.newBuilder().build();
927       client.setSecurityPolicyAsync(project, backendService, securityPolicyReferenceResource).get();
928       Assert.fail("No exception raised");
929     } catch (ExecutionException e) {
930     }
931   }
932 
933   @Test
updateTest()934   public void updateTest() throws Exception {
935     Operation expectedResponse =
936         Operation.newBuilder()
937             .setClientOperationId("clientOperationId-1230366697")
938             .setCreationTimestamp("creationTimestamp-370203401")
939             .setDescription("description-1724546052")
940             .setEndTime("endTime-1607243192")
941             .setError(Error.newBuilder().build())
942             .setHttpErrorMessage("httpErrorMessage1577303431")
943             .setHttpErrorStatusCode(0)
944             .setId(3355)
945             .setInsertTime("insertTime966165798")
946             .setKind("kind3292052")
947             .setName("name3373707")
948             .setOperationGroupId("operationGroupId1716161683")
949             .setOperationType("operationType91999553")
950             .setProgress(-1001078227)
951             .setRegion("region-934795532")
952             .setSelfLink("selfLink1191800166")
953             .setStartTime("startTime-2129294769")
954             .setStatus(Status.DONE)
955             .setStatusMessage("statusMessage-958704715")
956             .setTargetId(-815576439)
957             .setTargetLink("targetLink486368555")
958             .setUser("user3599307")
959             .addAllWarnings(new ArrayList<Warnings>())
960             .setZone("zone3744684")
961             .build();
962     mockService.addResponse(expectedResponse);
963 
964     String project = "project-6911";
965     String backendService = "backendService-8873";
966     BackendService backendServiceResource = BackendService.newBuilder().build();
967 
968     Operation actualResponse =
969         client.updateAsync(project, backendService, backendServiceResource).get();
970     Assert.assertEquals(expectedResponse, actualResponse);
971 
972     List<String> actualRequests = mockService.getRequestPaths();
973     Assert.assertEquals(1, actualRequests.size());
974 
975     String apiClientHeaderKey =
976         mockService
977             .getRequestHeaders()
978             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
979             .iterator()
980             .next();
981     Assert.assertTrue(
982         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
983             .matcher(apiClientHeaderKey)
984             .matches());
985   }
986 
987   @Test
updateExceptionTest()988   public void updateExceptionTest() throws Exception {
989     ApiException exception =
990         ApiExceptionFactory.createException(
991             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
992     mockService.addException(exception);
993 
994     try {
995       String project = "project-6911";
996       String backendService = "backendService-8873";
997       BackendService backendServiceResource = BackendService.newBuilder().build();
998       client.updateAsync(project, backendService, backendServiceResource).get();
999       Assert.fail("No exception raised");
1000     } catch (ExecutionException e) {
1001     }
1002   }
1003 }
1004