• 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.AutoscalersClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.AutoscalersClient.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.HttpJsonAutoscalersStub;
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 AutoscalersClientTest {
52   private static MockHttpService mockService;
53   private static AutoscalersClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonAutoscalersStub.getMethodDescriptors(),
60             AutoscalersSettings.getDefaultEndpoint());
61     AutoscalersSettings settings =
62         AutoscalersSettings.newBuilder()
63             .setTransportChannelProvider(
64                 AutoscalersSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = AutoscalersClient.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
aggregatedListTest()86   public void aggregatedListTest() throws Exception {
87     AutoscalersScopedList responsesElement = AutoscalersScopedList.newBuilder().build();
88     AutoscalerAggregatedList expectedResponse =
89         AutoscalerAggregatedList.newBuilder()
90             .setNextPageToken("")
91             .putAllItems(Collections.singletonMap("items", responsesElement))
92             .build();
93     mockService.addResponse(expectedResponse);
94 
95     String project = "project-6911";
96 
97     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
98 
99     List<Map.Entry<String, AutoscalersScopedList>> resources =
100         Lists.newArrayList(pagedListResponse.iterateAll());
101 
102     Assert.assertEquals(1, resources.size());
103     Assert.assertEquals(
104         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
105 
106     List<String> actualRequests = mockService.getRequestPaths();
107     Assert.assertEquals(1, actualRequests.size());
108 
109     String apiClientHeaderKey =
110         mockService
111             .getRequestHeaders()
112             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
113             .iterator()
114             .next();
115     Assert.assertTrue(
116         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
117             .matcher(apiClientHeaderKey)
118             .matches());
119   }
120 
121   @Test
aggregatedListExceptionTest()122   public void aggregatedListExceptionTest() throws Exception {
123     ApiException exception =
124         ApiExceptionFactory.createException(
125             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
126     mockService.addException(exception);
127 
128     try {
129       String project = "project-6911";
130       client.aggregatedList(project);
131       Assert.fail("No exception raised");
132     } catch (InvalidArgumentException e) {
133       // Expected exception.
134     }
135   }
136 
137   @Test
deleteTest()138   public void deleteTest() throws Exception {
139     Operation expectedResponse =
140         Operation.newBuilder()
141             .setClientOperationId("clientOperationId-1230366697")
142             .setCreationTimestamp("creationTimestamp-370203401")
143             .setDescription("description-1724546052")
144             .setEndTime("endTime-1607243192")
145             .setError(Error.newBuilder().build())
146             .setHttpErrorMessage("httpErrorMessage1577303431")
147             .setHttpErrorStatusCode(0)
148             .setId(3355)
149             .setInsertTime("insertTime966165798")
150             .setKind("kind3292052")
151             .setName("name3373707")
152             .setOperationGroupId("operationGroupId1716161683")
153             .setOperationType("operationType91999553")
154             .setProgress(-1001078227)
155             .setRegion("region-934795532")
156             .setSelfLink("selfLink1191800166")
157             .setStartTime("startTime-2129294769")
158             .setStatus(Status.DONE)
159             .setStatusMessage("statusMessage-958704715")
160             .setTargetId(-815576439)
161             .setTargetLink("targetLink486368555")
162             .setUser("user3599307")
163             .addAllWarnings(new ArrayList<Warnings>())
164             .setZone("zone3744684")
165             .build();
166     mockService.addResponse(expectedResponse);
167 
168     String project = "project-6911";
169     String zone = "zone-5246";
170     String autoscaler = "autoscaler-1165";
171 
172     Operation actualResponse = client.deleteAsync(project, zone, autoscaler).get();
173     Assert.assertEquals(expectedResponse, actualResponse);
174 
175     List<String> actualRequests = mockService.getRequestPaths();
176     Assert.assertEquals(1, actualRequests.size());
177 
178     String apiClientHeaderKey =
179         mockService
180             .getRequestHeaders()
181             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
182             .iterator()
183             .next();
184     Assert.assertTrue(
185         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
186             .matcher(apiClientHeaderKey)
187             .matches());
188   }
189 
190   @Test
deleteExceptionTest()191   public void deleteExceptionTest() throws Exception {
192     ApiException exception =
193         ApiExceptionFactory.createException(
194             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
195     mockService.addException(exception);
196 
197     try {
198       String project = "project-6911";
199       String zone = "zone-5246";
200       String autoscaler = "autoscaler-1165";
201       client.deleteAsync(project, zone, autoscaler).get();
202       Assert.fail("No exception raised");
203     } catch (ExecutionException e) {
204     }
205   }
206 
207   @Test
getTest()208   public void getTest() throws Exception {
209     Autoscaler expectedResponse =
210         Autoscaler.newBuilder()
211             .setAutoscalingPolicy(AutoscalingPolicy.newBuilder().build())
212             .setCreationTimestamp("creationTimestamp-370203401")
213             .setDescription("description-1724546052")
214             .setId(3355)
215             .setKind("kind3292052")
216             .setName("name3373707")
217             .setRecommendedSize(-1889567899)
218             .setRegion("region-934795532")
219             .putAllScalingScheduleStatus(new HashMap<String, ScalingScheduleStatus>())
220             .setSelfLink("selfLink1191800166")
221             .setStatus("status-892481550")
222             .addAllStatusDetails(new ArrayList<AutoscalerStatusDetails>())
223             .setTarget("target-880905839")
224             .setZone("zone3744684")
225             .build();
226     mockService.addResponse(expectedResponse);
227 
228     String project = "project-6911";
229     String zone = "zone-5246";
230     String autoscaler = "autoscaler-1165";
231 
232     Autoscaler actualResponse = client.get(project, zone, autoscaler);
233     Assert.assertEquals(expectedResponse, actualResponse);
234 
235     List<String> actualRequests = mockService.getRequestPaths();
236     Assert.assertEquals(1, actualRequests.size());
237 
238     String apiClientHeaderKey =
239         mockService
240             .getRequestHeaders()
241             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
242             .iterator()
243             .next();
244     Assert.assertTrue(
245         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
246             .matcher(apiClientHeaderKey)
247             .matches());
248   }
249 
250   @Test
getExceptionTest()251   public void getExceptionTest() throws Exception {
252     ApiException exception =
253         ApiExceptionFactory.createException(
254             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
255     mockService.addException(exception);
256 
257     try {
258       String project = "project-6911";
259       String zone = "zone-5246";
260       String autoscaler = "autoscaler-1165";
261       client.get(project, zone, autoscaler);
262       Assert.fail("No exception raised");
263     } catch (InvalidArgumentException e) {
264       // Expected exception.
265     }
266   }
267 
268   @Test
insertTest()269   public void insertTest() throws Exception {
270     Operation expectedResponse =
271         Operation.newBuilder()
272             .setClientOperationId("clientOperationId-1230366697")
273             .setCreationTimestamp("creationTimestamp-370203401")
274             .setDescription("description-1724546052")
275             .setEndTime("endTime-1607243192")
276             .setError(Error.newBuilder().build())
277             .setHttpErrorMessage("httpErrorMessage1577303431")
278             .setHttpErrorStatusCode(0)
279             .setId(3355)
280             .setInsertTime("insertTime966165798")
281             .setKind("kind3292052")
282             .setName("name3373707")
283             .setOperationGroupId("operationGroupId1716161683")
284             .setOperationType("operationType91999553")
285             .setProgress(-1001078227)
286             .setRegion("region-934795532")
287             .setSelfLink("selfLink1191800166")
288             .setStartTime("startTime-2129294769")
289             .setStatus(Status.DONE)
290             .setStatusMessage("statusMessage-958704715")
291             .setTargetId(-815576439)
292             .setTargetLink("targetLink486368555")
293             .setUser("user3599307")
294             .addAllWarnings(new ArrayList<Warnings>())
295             .setZone("zone3744684")
296             .build();
297     mockService.addResponse(expectedResponse);
298 
299     String project = "project-6911";
300     String zone = "zone-5246";
301     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
302 
303     Operation actualResponse = client.insertAsync(project, zone, autoscalerResource).get();
304     Assert.assertEquals(expectedResponse, actualResponse);
305 
306     List<String> actualRequests = mockService.getRequestPaths();
307     Assert.assertEquals(1, actualRequests.size());
308 
309     String apiClientHeaderKey =
310         mockService
311             .getRequestHeaders()
312             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
313             .iterator()
314             .next();
315     Assert.assertTrue(
316         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
317             .matcher(apiClientHeaderKey)
318             .matches());
319   }
320 
321   @Test
insertExceptionTest()322   public void insertExceptionTest() throws Exception {
323     ApiException exception =
324         ApiExceptionFactory.createException(
325             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
326     mockService.addException(exception);
327 
328     try {
329       String project = "project-6911";
330       String zone = "zone-5246";
331       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
332       client.insertAsync(project, zone, autoscalerResource).get();
333       Assert.fail("No exception raised");
334     } catch (ExecutionException e) {
335     }
336   }
337 
338   @Test
listTest()339   public void listTest() throws Exception {
340     Autoscaler responsesElement = Autoscaler.newBuilder().build();
341     AutoscalerList expectedResponse =
342         AutoscalerList.newBuilder()
343             .setNextPageToken("")
344             .addAllItems(Arrays.asList(responsesElement))
345             .build();
346     mockService.addResponse(expectedResponse);
347 
348     String project = "project-6911";
349     String zone = "zone-5246";
350 
351     ListPagedResponse pagedListResponse = client.list(project, zone);
352 
353     List<Autoscaler> resources = Lists.newArrayList(pagedListResponse.iterateAll());
354 
355     Assert.assertEquals(1, resources.size());
356     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
357 
358     List<String> actualRequests = mockService.getRequestPaths();
359     Assert.assertEquals(1, actualRequests.size());
360 
361     String apiClientHeaderKey =
362         mockService
363             .getRequestHeaders()
364             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
365             .iterator()
366             .next();
367     Assert.assertTrue(
368         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
369             .matcher(apiClientHeaderKey)
370             .matches());
371   }
372 
373   @Test
listExceptionTest()374   public void listExceptionTest() throws Exception {
375     ApiException exception =
376         ApiExceptionFactory.createException(
377             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
378     mockService.addException(exception);
379 
380     try {
381       String project = "project-6911";
382       String zone = "zone-5246";
383       client.list(project, zone);
384       Assert.fail("No exception raised");
385     } catch (InvalidArgumentException e) {
386       // Expected exception.
387     }
388   }
389 
390   @Test
patchTest()391   public void patchTest() throws Exception {
392     Operation expectedResponse =
393         Operation.newBuilder()
394             .setClientOperationId("clientOperationId-1230366697")
395             .setCreationTimestamp("creationTimestamp-370203401")
396             .setDescription("description-1724546052")
397             .setEndTime("endTime-1607243192")
398             .setError(Error.newBuilder().build())
399             .setHttpErrorMessage("httpErrorMessage1577303431")
400             .setHttpErrorStatusCode(0)
401             .setId(3355)
402             .setInsertTime("insertTime966165798")
403             .setKind("kind3292052")
404             .setName("name3373707")
405             .setOperationGroupId("operationGroupId1716161683")
406             .setOperationType("operationType91999553")
407             .setProgress(-1001078227)
408             .setRegion("region-934795532")
409             .setSelfLink("selfLink1191800166")
410             .setStartTime("startTime-2129294769")
411             .setStatus(Status.DONE)
412             .setStatusMessage("statusMessage-958704715")
413             .setTargetId(-815576439)
414             .setTargetLink("targetLink486368555")
415             .setUser("user3599307")
416             .addAllWarnings(new ArrayList<Warnings>())
417             .setZone("zone3744684")
418             .build();
419     mockService.addResponse(expectedResponse);
420 
421     String project = "project-6911";
422     String zone = "zone-5246";
423     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
424 
425     Operation actualResponse = client.patchAsync(project, zone, autoscalerResource).get();
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<String> actualRequests = mockService.getRequestPaths();
429     Assert.assertEquals(1, actualRequests.size());
430 
431     String apiClientHeaderKey =
432         mockService
433             .getRequestHeaders()
434             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
435             .iterator()
436             .next();
437     Assert.assertTrue(
438         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
439             .matcher(apiClientHeaderKey)
440             .matches());
441   }
442 
443   @Test
patchExceptionTest()444   public void patchExceptionTest() throws Exception {
445     ApiException exception =
446         ApiExceptionFactory.createException(
447             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
448     mockService.addException(exception);
449 
450     try {
451       String project = "project-6911";
452       String zone = "zone-5246";
453       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
454       client.patchAsync(project, zone, autoscalerResource).get();
455       Assert.fail("No exception raised");
456     } catch (ExecutionException e) {
457     }
458   }
459 
460   @Test
updateTest()461   public void updateTest() throws Exception {
462     Operation expectedResponse =
463         Operation.newBuilder()
464             .setClientOperationId("clientOperationId-1230366697")
465             .setCreationTimestamp("creationTimestamp-370203401")
466             .setDescription("description-1724546052")
467             .setEndTime("endTime-1607243192")
468             .setError(Error.newBuilder().build())
469             .setHttpErrorMessage("httpErrorMessage1577303431")
470             .setHttpErrorStatusCode(0)
471             .setId(3355)
472             .setInsertTime("insertTime966165798")
473             .setKind("kind3292052")
474             .setName("name3373707")
475             .setOperationGroupId("operationGroupId1716161683")
476             .setOperationType("operationType91999553")
477             .setProgress(-1001078227)
478             .setRegion("region-934795532")
479             .setSelfLink("selfLink1191800166")
480             .setStartTime("startTime-2129294769")
481             .setStatus(Status.DONE)
482             .setStatusMessage("statusMessage-958704715")
483             .setTargetId(-815576439)
484             .setTargetLink("targetLink486368555")
485             .setUser("user3599307")
486             .addAllWarnings(new ArrayList<Warnings>())
487             .setZone("zone3744684")
488             .build();
489     mockService.addResponse(expectedResponse);
490 
491     String project = "project-6911";
492     String zone = "zone-5246";
493     Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
494 
495     Operation actualResponse = client.updateAsync(project, zone, autoscalerResource).get();
496     Assert.assertEquals(expectedResponse, actualResponse);
497 
498     List<String> actualRequests = mockService.getRequestPaths();
499     Assert.assertEquals(1, actualRequests.size());
500 
501     String apiClientHeaderKey =
502         mockService
503             .getRequestHeaders()
504             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
505             .iterator()
506             .next();
507     Assert.assertTrue(
508         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
509             .matcher(apiClientHeaderKey)
510             .matches());
511   }
512 
513   @Test
updateExceptionTest()514   public void updateExceptionTest() throws Exception {
515     ApiException exception =
516         ApiExceptionFactory.createException(
517             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
518     mockService.addException(exception);
519 
520     try {
521       String project = "project-6911";
522       String zone = "zone-5246";
523       Autoscaler autoscalerResource = Autoscaler.newBuilder().build();
524       client.updateAsync(project, zone, autoscalerResource).get();
525       Assert.fail("No exception raised");
526     } catch (ExecutionException e) {
527     }
528   }
529 }
530