• 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.RegionUrlMapsClient.ListPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
23 import com.google.api.gax.httpjson.testing.MockHttpService;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.ApiException;
26 import com.google.api.gax.rpc.ApiExceptionFactory;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.api.gax.rpc.testing.FakeStatusCode;
30 import com.google.cloud.compute.v1.Operation.Status;
31 import com.google.cloud.compute.v1.stub.HttpJsonRegionUrlMapsStub;
32 import com.google.common.collect.Lists;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.List;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class RegionUrlMapsClientTest {
48   private static MockHttpService mockService;
49   private static RegionUrlMapsClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonRegionUrlMapsStub.getMethodDescriptors(),
56             RegionUrlMapsSettings.getDefaultEndpoint());
57     RegionUrlMapsSettings settings =
58         RegionUrlMapsSettings.newBuilder()
59             .setTransportChannelProvider(
60                 RegionUrlMapsSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = RegionUrlMapsClient.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
deleteTest()82   public void deleteTest() 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 region = "region-9622";
114     String urlMap = "urlMap-7603";
115 
116     Operation actualResponse = client.deleteAsync(project, region, urlMap).get();
117     Assert.assertEquals(expectedResponse, actualResponse);
118 
119     List<String> actualRequests = mockService.getRequestPaths();
120     Assert.assertEquals(1, actualRequests.size());
121 
122     String apiClientHeaderKey =
123         mockService
124             .getRequestHeaders()
125             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
126             .iterator()
127             .next();
128     Assert.assertTrue(
129         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
130             .matcher(apiClientHeaderKey)
131             .matches());
132   }
133 
134   @Test
deleteExceptionTest()135   public void deleteExceptionTest() throws Exception {
136     ApiException exception =
137         ApiExceptionFactory.createException(
138             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
139     mockService.addException(exception);
140 
141     try {
142       String project = "project-6911";
143       String region = "region-9622";
144       String urlMap = "urlMap-7603";
145       client.deleteAsync(project, region, urlMap).get();
146       Assert.fail("No exception raised");
147     } catch (ExecutionException e) {
148     }
149   }
150 
151   @Test
getTest()152   public void getTest() throws Exception {
153     UrlMap expectedResponse =
154         UrlMap.newBuilder()
155             .setCreationTimestamp("creationTimestamp-370203401")
156             .setDefaultRouteAction(HttpRouteAction.newBuilder().build())
157             .setDefaultService("defaultService-306696908")
158             .setDefaultUrlRedirect(HttpRedirectAction.newBuilder().build())
159             .setDescription("description-1724546052")
160             .setFingerprint("fingerprint-1375934236")
161             .setHeaderAction(HttpHeaderAction.newBuilder().build())
162             .addAllHostRules(new ArrayList<HostRule>())
163             .setId(3355)
164             .setKind("kind3292052")
165             .setName("name3373707")
166             .addAllPathMatchers(new ArrayList<PathMatcher>())
167             .setRegion("region-934795532")
168             .setSelfLink("selfLink1191800166")
169             .addAllTests(new ArrayList<UrlMapTest>())
170             .build();
171     mockService.addResponse(expectedResponse);
172 
173     String project = "project-6911";
174     String region = "region-9622";
175     String urlMap = "urlMap-7603";
176 
177     UrlMap actualResponse = client.get(project, region, urlMap);
178     Assert.assertEquals(expectedResponse, actualResponse);
179 
180     List<String> actualRequests = mockService.getRequestPaths();
181     Assert.assertEquals(1, actualRequests.size());
182 
183     String apiClientHeaderKey =
184         mockService
185             .getRequestHeaders()
186             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
187             .iterator()
188             .next();
189     Assert.assertTrue(
190         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
191             .matcher(apiClientHeaderKey)
192             .matches());
193   }
194 
195   @Test
getExceptionTest()196   public void getExceptionTest() throws Exception {
197     ApiException exception =
198         ApiExceptionFactory.createException(
199             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
200     mockService.addException(exception);
201 
202     try {
203       String project = "project-6911";
204       String region = "region-9622";
205       String urlMap = "urlMap-7603";
206       client.get(project, region, urlMap);
207       Assert.fail("No exception raised");
208     } catch (InvalidArgumentException e) {
209       // Expected exception.
210     }
211   }
212 
213   @Test
insertTest()214   public void insertTest() throws Exception {
215     Operation expectedResponse =
216         Operation.newBuilder()
217             .setClientOperationId("clientOperationId-1230366697")
218             .setCreationTimestamp("creationTimestamp-370203401")
219             .setDescription("description-1724546052")
220             .setEndTime("endTime-1607243192")
221             .setError(Error.newBuilder().build())
222             .setHttpErrorMessage("httpErrorMessage1577303431")
223             .setHttpErrorStatusCode(0)
224             .setId(3355)
225             .setInsertTime("insertTime966165798")
226             .setKind("kind3292052")
227             .setName("name3373707")
228             .setOperationGroupId("operationGroupId1716161683")
229             .setOperationType("operationType91999553")
230             .setProgress(-1001078227)
231             .setRegion("region-934795532")
232             .setSelfLink("selfLink1191800166")
233             .setStartTime("startTime-2129294769")
234             .setStatus(Status.DONE)
235             .setStatusMessage("statusMessage-958704715")
236             .setTargetId(-815576439)
237             .setTargetLink("targetLink486368555")
238             .setUser("user3599307")
239             .addAllWarnings(new ArrayList<Warnings>())
240             .setZone("zone3744684")
241             .build();
242     mockService.addResponse(expectedResponse);
243 
244     String project = "project-6911";
245     String region = "region-9622";
246     UrlMap urlMapResource = UrlMap.newBuilder().build();
247 
248     Operation actualResponse = client.insertAsync(project, region, urlMapResource).get();
249     Assert.assertEquals(expectedResponse, actualResponse);
250 
251     List<String> actualRequests = mockService.getRequestPaths();
252     Assert.assertEquals(1, actualRequests.size());
253 
254     String apiClientHeaderKey =
255         mockService
256             .getRequestHeaders()
257             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
258             .iterator()
259             .next();
260     Assert.assertTrue(
261         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
262             .matcher(apiClientHeaderKey)
263             .matches());
264   }
265 
266   @Test
insertExceptionTest()267   public void insertExceptionTest() throws Exception {
268     ApiException exception =
269         ApiExceptionFactory.createException(
270             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
271     mockService.addException(exception);
272 
273     try {
274       String project = "project-6911";
275       String region = "region-9622";
276       UrlMap urlMapResource = UrlMap.newBuilder().build();
277       client.insertAsync(project, region, urlMapResource).get();
278       Assert.fail("No exception raised");
279     } catch (ExecutionException e) {
280     }
281   }
282 
283   @Test
listTest()284   public void listTest() throws Exception {
285     UrlMap responsesElement = UrlMap.newBuilder().build();
286     UrlMapList expectedResponse =
287         UrlMapList.newBuilder()
288             .setNextPageToken("")
289             .addAllItems(Arrays.asList(responsesElement))
290             .build();
291     mockService.addResponse(expectedResponse);
292 
293     String project = "project-6911";
294     String region = "region-9622";
295 
296     ListPagedResponse pagedListResponse = client.list(project, region);
297 
298     List<UrlMap> resources = Lists.newArrayList(pagedListResponse.iterateAll());
299 
300     Assert.assertEquals(1, resources.size());
301     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
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
listExceptionTest()319   public void listExceptionTest() 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 region = "region-9622";
328       client.list(project, region);
329       Assert.fail("No exception raised");
330     } catch (InvalidArgumentException e) {
331       // Expected exception.
332     }
333   }
334 
335   @Test
patchTest()336   public void patchTest() 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     String region = "region-9622";
368     String urlMap = "urlMap-7603";
369     UrlMap urlMapResource = UrlMap.newBuilder().build();
370 
371     Operation actualResponse = client.patchAsync(project, region, urlMap, urlMapResource).get();
372     Assert.assertEquals(expectedResponse, actualResponse);
373 
374     List<String> actualRequests = mockService.getRequestPaths();
375     Assert.assertEquals(1, actualRequests.size());
376 
377     String apiClientHeaderKey =
378         mockService
379             .getRequestHeaders()
380             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
381             .iterator()
382             .next();
383     Assert.assertTrue(
384         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
385             .matcher(apiClientHeaderKey)
386             .matches());
387   }
388 
389   @Test
patchExceptionTest()390   public void patchExceptionTest() throws Exception {
391     ApiException exception =
392         ApiExceptionFactory.createException(
393             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
394     mockService.addException(exception);
395 
396     try {
397       String project = "project-6911";
398       String region = "region-9622";
399       String urlMap = "urlMap-7603";
400       UrlMap urlMapResource = UrlMap.newBuilder().build();
401       client.patchAsync(project, region, urlMap, urlMapResource).get();
402       Assert.fail("No exception raised");
403     } catch (ExecutionException e) {
404     }
405   }
406 
407   @Test
updateTest()408   public void updateTest() throws Exception {
409     Operation expectedResponse =
410         Operation.newBuilder()
411             .setClientOperationId("clientOperationId-1230366697")
412             .setCreationTimestamp("creationTimestamp-370203401")
413             .setDescription("description-1724546052")
414             .setEndTime("endTime-1607243192")
415             .setError(Error.newBuilder().build())
416             .setHttpErrorMessage("httpErrorMessage1577303431")
417             .setHttpErrorStatusCode(0)
418             .setId(3355)
419             .setInsertTime("insertTime966165798")
420             .setKind("kind3292052")
421             .setName("name3373707")
422             .setOperationGroupId("operationGroupId1716161683")
423             .setOperationType("operationType91999553")
424             .setProgress(-1001078227)
425             .setRegion("region-934795532")
426             .setSelfLink("selfLink1191800166")
427             .setStartTime("startTime-2129294769")
428             .setStatus(Status.DONE)
429             .setStatusMessage("statusMessage-958704715")
430             .setTargetId(-815576439)
431             .setTargetLink("targetLink486368555")
432             .setUser("user3599307")
433             .addAllWarnings(new ArrayList<Warnings>())
434             .setZone("zone3744684")
435             .build();
436     mockService.addResponse(expectedResponse);
437 
438     String project = "project-6911";
439     String region = "region-9622";
440     String urlMap = "urlMap-7603";
441     UrlMap urlMapResource = UrlMap.newBuilder().build();
442 
443     Operation actualResponse = client.updateAsync(project, region, urlMap, urlMapResource).get();
444     Assert.assertEquals(expectedResponse, actualResponse);
445 
446     List<String> actualRequests = mockService.getRequestPaths();
447     Assert.assertEquals(1, actualRequests.size());
448 
449     String apiClientHeaderKey =
450         mockService
451             .getRequestHeaders()
452             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
453             .iterator()
454             .next();
455     Assert.assertTrue(
456         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
457             .matcher(apiClientHeaderKey)
458             .matches());
459   }
460 
461   @Test
updateExceptionTest()462   public void updateExceptionTest() throws Exception {
463     ApiException exception =
464         ApiExceptionFactory.createException(
465             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
466     mockService.addException(exception);
467 
468     try {
469       String project = "project-6911";
470       String region = "region-9622";
471       String urlMap = "urlMap-7603";
472       UrlMap urlMapResource = UrlMap.newBuilder().build();
473       client.updateAsync(project, region, urlMap, urlMapResource).get();
474       Assert.fail("No exception raised");
475     } catch (ExecutionException e) {
476     }
477   }
478 
479   @Test
validateTest()480   public void validateTest() throws Exception {
481     UrlMapsValidateResponse expectedResponse =
482         UrlMapsValidateResponse.newBuilder()
483             .setResult(UrlMapValidationResult.newBuilder().build())
484             .build();
485     mockService.addResponse(expectedResponse);
486 
487     String project = "project-6911";
488     String region = "region-9622";
489     String urlMap = "urlMap-7603";
490     RegionUrlMapsValidateRequest regionUrlMapsValidateRequestResource =
491         RegionUrlMapsValidateRequest.newBuilder().build();
492 
493     UrlMapsValidateResponse actualResponse =
494         client.validate(project, region, urlMap, regionUrlMapsValidateRequestResource);
495     Assert.assertEquals(expectedResponse, actualResponse);
496 
497     List<String> actualRequests = mockService.getRequestPaths();
498     Assert.assertEquals(1, actualRequests.size());
499 
500     String apiClientHeaderKey =
501         mockService
502             .getRequestHeaders()
503             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
504             .iterator()
505             .next();
506     Assert.assertTrue(
507         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
508             .matcher(apiClientHeaderKey)
509             .matches());
510   }
511 
512   @Test
validateExceptionTest()513   public void validateExceptionTest() throws Exception {
514     ApiException exception =
515         ApiExceptionFactory.createException(
516             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
517     mockService.addException(exception);
518 
519     try {
520       String project = "project-6911";
521       String region = "region-9622";
522       String urlMap = "urlMap-7603";
523       RegionUrlMapsValidateRequest regionUrlMapsValidateRequestResource =
524           RegionUrlMapsValidateRequest.newBuilder().build();
525       client.validate(project, region, urlMap, regionUrlMapsValidateRequestResource);
526       Assert.fail("No exception raised");
527     } catch (InvalidArgumentException e) {
528       // Expected exception.
529     }
530   }
531 }
532