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