• 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.RegionAutoscalersClient.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.HttpJsonRegionAutoscalersStub;
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.HashMap;
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 RegionAutoscalersClientTest {
49   private static MockHttpService mockService;
50   private static RegionAutoscalersClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonRegionAutoscalersStub.getMethodDescriptors(),
57             RegionAutoscalersSettings.getDefaultEndpoint());
58     RegionAutoscalersSettings settings =
59         RegionAutoscalersSettings.newBuilder()
60             .setTransportChannelProvider(
61                 RegionAutoscalersSettings.defaultHttpJsonTransportProviderBuilder()
62                     .setHttpTransport(mockService)
63                     .build())
64             .setCredentialsProvider(NoCredentialsProvider.create())
65             .build();
66     client = RegionAutoscalersClient.create(settings);
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     client.close();
72   }
73 
74   @Before
setUp()75   public void setUp() {}
76 
77   @After
tearDown()78   public void tearDown() throws Exception {
79     mockService.reset();
80   }
81 
82   @Test
deleteTest()83   public void deleteTest() throws Exception {
84     Operation expectedResponse =
85         Operation.newBuilder()
86             .setClientOperationId("clientOperationId-1230366697")
87             .setCreationTimestamp("creationTimestamp-370203401")
88             .setDescription("description-1724546052")
89             .setEndTime("endTime-1607243192")
90             .setError(Error.newBuilder().build())
91             .setHttpErrorMessage("httpErrorMessage1577303431")
92             .setHttpErrorStatusCode(0)
93             .setId(3355)
94             .setInsertTime("insertTime966165798")
95             .setKind("kind3292052")
96             .setName("name3373707")
97             .setOperationGroupId("operationGroupId1716161683")
98             .setOperationType("operationType91999553")
99             .setProgress(-1001078227)
100             .setRegion("region-934795532")
101             .setSelfLink("selfLink1191800166")
102             .setStartTime("startTime-2129294769")
103             .setStatus(Status.DONE)
104             .setStatusMessage("statusMessage-958704715")
105             .setTargetId(-815576439)
106             .setTargetLink("targetLink486368555")
107             .setUser("user3599307")
108             .addAllWarnings(new ArrayList<Warnings>())
109             .setZone("zone3744684")
110             .build();
111     mockService.addResponse(expectedResponse);
112 
113     String project = "project-6911";
114     String region = "region-9622";
115     String autoscaler = "autoscaler-1165";
116 
117     Operation actualResponse = client.deleteAsync(project, region, autoscaler).get();
118     Assert.assertEquals(expectedResponse, actualResponse);
119 
120     List<String> actualRequests = mockService.getRequestPaths();
121     Assert.assertEquals(1, actualRequests.size());
122 
123     String apiClientHeaderKey =
124         mockService
125             .getRequestHeaders()
126             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
127             .iterator()
128             .next();
129     Assert.assertTrue(
130         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
131             .matcher(apiClientHeaderKey)
132             .matches());
133   }
134 
135   @Test
deleteExceptionTest()136   public void deleteExceptionTest() throws Exception {
137     ApiException exception =
138         ApiExceptionFactory.createException(
139             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
140     mockService.addException(exception);
141 
142     try {
143       String project = "project-6911";
144       String region = "region-9622";
145       String autoscaler = "autoscaler-1165";
146       client.deleteAsync(project, region, autoscaler).get();
147       Assert.fail("No exception raised");
148     } catch (ExecutionException e) {
149     }
150   }
151 
152   @Test
getTest()153   public void getTest() throws Exception {
154     Autoscaler expectedResponse =
155         Autoscaler.newBuilder()
156             .setAutoscalingPolicy(AutoscalingPolicy.newBuilder().build())
157             .setCreationTimestamp("creationTimestamp-370203401")
158             .setDescription("description-1724546052")
159             .setId(3355)
160             .setKind("kind3292052")
161             .setName("name3373707")
162             .setRecommendedSize(-1889567899)
163             .setRegion("region-934795532")
164             .putAllScalingScheduleStatus(new HashMap<String, ScalingScheduleStatus>())
165             .setSelfLink("selfLink1191800166")
166             .setStatus("status-892481550")
167             .addAllStatusDetails(new ArrayList<AutoscalerStatusDetails>())
168             .setTarget("target-880905839")
169             .setZone("zone3744684")
170             .build();
171     mockService.addResponse(expectedResponse);
172 
173     String project = "project-6911";
174     String region = "region-9622";
175     String autoscaler = "autoscaler-1165";
176 
177     Autoscaler actualResponse = client.get(project, region, autoscaler);
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 autoscaler = "autoscaler-1165";
206       client.get(project, region, autoscaler);
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     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
247 
248     Operation actualResponse = client.insertAsync(project, region, autoscalerResource).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       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
277       client.insertAsync(project, region, autoscalerResource).get();
278       Assert.fail("No exception raised");
279     } catch (ExecutionException e) {
280     }
281   }
282 
283   @Test
listTest()284   public void listTest() throws Exception {
285     Autoscaler responsesElement = Autoscaler.newBuilder().build();
286     RegionAutoscalerList expectedResponse =
287         RegionAutoscalerList.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<Autoscaler> 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     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
369 
370     Operation actualResponse = client.patchAsync(project, region, autoscalerResource).get();
371     Assert.assertEquals(expectedResponse, actualResponse);
372 
373     List<String> actualRequests = mockService.getRequestPaths();
374     Assert.assertEquals(1, actualRequests.size());
375 
376     String apiClientHeaderKey =
377         mockService
378             .getRequestHeaders()
379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
380             .iterator()
381             .next();
382     Assert.assertTrue(
383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
384             .matcher(apiClientHeaderKey)
385             .matches());
386   }
387 
388   @Test
patchExceptionTest()389   public void patchExceptionTest() throws Exception {
390     ApiException exception =
391         ApiExceptionFactory.createException(
392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
393     mockService.addException(exception);
394 
395     try {
396       String project = "project-6911";
397       String region = "region-9622";
398       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
399       client.patchAsync(project, region, autoscalerResource).get();
400       Assert.fail("No exception raised");
401     } catch (ExecutionException e) {
402     }
403   }
404 
405   @Test
updateTest()406   public void updateTest() throws Exception {
407     Operation expectedResponse =
408         Operation.newBuilder()
409             .setClientOperationId("clientOperationId-1230366697")
410             .setCreationTimestamp("creationTimestamp-370203401")
411             .setDescription("description-1724546052")
412             .setEndTime("endTime-1607243192")
413             .setError(Error.newBuilder().build())
414             .setHttpErrorMessage("httpErrorMessage1577303431")
415             .setHttpErrorStatusCode(0)
416             .setId(3355)
417             .setInsertTime("insertTime966165798")
418             .setKind("kind3292052")
419             .setName("name3373707")
420             .setOperationGroupId("operationGroupId1716161683")
421             .setOperationType("operationType91999553")
422             .setProgress(-1001078227)
423             .setRegion("region-934795532")
424             .setSelfLink("selfLink1191800166")
425             .setStartTime("startTime-2129294769")
426             .setStatus(Status.DONE)
427             .setStatusMessage("statusMessage-958704715")
428             .setTargetId(-815576439)
429             .setTargetLink("targetLink486368555")
430             .setUser("user3599307")
431             .addAllWarnings(new ArrayList<Warnings>())
432             .setZone("zone3744684")
433             .build();
434     mockService.addResponse(expectedResponse);
435 
436     String project = "project-6911";
437     String region = "region-9622";
438     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
439 
440     Operation actualResponse = client.updateAsync(project, region, autoscalerResource).get();
441     Assert.assertEquals(expectedResponse, actualResponse);
442 
443     List<String> actualRequests = mockService.getRequestPaths();
444     Assert.assertEquals(1, actualRequests.size());
445 
446     String apiClientHeaderKey =
447         mockService
448             .getRequestHeaders()
449             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
450             .iterator()
451             .next();
452     Assert.assertTrue(
453         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
454             .matcher(apiClientHeaderKey)
455             .matches());
456   }
457 
458   @Test
updateExceptionTest()459   public void updateExceptionTest() throws Exception {
460     ApiException exception =
461         ApiExceptionFactory.createException(
462             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
463     mockService.addException(exception);
464 
465     try {
466       String project = "project-6911";
467       String region = "region-9622";
468       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
469       client.updateAsync(project, region, autoscalerResource).get();
470       Assert.fail("No exception raised");
471     } catch (ExecutionException e) {
472     }
473   }
474 }
475