• 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.RegionHealthChecksClient.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.HttpJsonRegionHealthChecksStub;
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 RegionHealthChecksClientTest {
48   private static MockHttpService mockService;
49   private static RegionHealthChecksClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonRegionHealthChecksStub.getMethodDescriptors(),
56             RegionHealthChecksSettings.getDefaultEndpoint());
57     RegionHealthChecksSettings settings =
58         RegionHealthChecksSettings.newBuilder()
59             .setTransportChannelProvider(
60                 RegionHealthChecksSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = RegionHealthChecksClient.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 healthCheck = "healthCheck-7822";
115 
116     Operation actualResponse = client.deleteAsync(project, region, healthCheck).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 healthCheck = "healthCheck-7822";
145       client.deleteAsync(project, region, healthCheck).get();
146       Assert.fail("No exception raised");
147     } catch (ExecutionException e) {
148     }
149   }
150 
151   @Test
getTest()152   public void getTest() throws Exception {
153     HealthCheck expectedResponse =
154         HealthCheck.newBuilder()
155             .setCheckIntervalSec(345561006)
156             .setCreationTimestamp("creationTimestamp-370203401")
157             .setDescription("description-1724546052")
158             .setGrpcHealthCheck(GRPCHealthCheck.newBuilder().build())
159             .setHealthyThreshold(-133658551)
160             .setHttp2HealthCheck(HTTP2HealthCheck.newBuilder().build())
161             .setHttpHealthCheck(HTTPHealthCheck.newBuilder().build())
162             .setHttpsHealthCheck(HTTPSHealthCheck.newBuilder().build())
163             .setId(3355)
164             .setKind("kind3292052")
165             .setLogConfig(HealthCheckLogConfig.newBuilder().build())
166             .setName("name3373707")
167             .setRegion("region-934795532")
168             .setSelfLink("selfLink1191800166")
169             .setSslHealthCheck(SSLHealthCheck.newBuilder().build())
170             .setTcpHealthCheck(TCPHealthCheck.newBuilder().build())
171             .setTimeoutSec(-2067488653)
172             .setType("type3575610")
173             .setUnhealthyThreshold(1838571216)
174             .build();
175     mockService.addResponse(expectedResponse);
176 
177     String project = "project-6911";
178     String region = "region-9622";
179     String healthCheck = "healthCheck-7822";
180 
181     HealthCheck actualResponse = client.get(project, region, healthCheck);
182     Assert.assertEquals(expectedResponse, actualResponse);
183 
184     List<String> actualRequests = mockService.getRequestPaths();
185     Assert.assertEquals(1, actualRequests.size());
186 
187     String apiClientHeaderKey =
188         mockService
189             .getRequestHeaders()
190             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
191             .iterator()
192             .next();
193     Assert.assertTrue(
194         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
195             .matcher(apiClientHeaderKey)
196             .matches());
197   }
198 
199   @Test
getExceptionTest()200   public void getExceptionTest() throws Exception {
201     ApiException exception =
202         ApiExceptionFactory.createException(
203             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
204     mockService.addException(exception);
205 
206     try {
207       String project = "project-6911";
208       String region = "region-9622";
209       String healthCheck = "healthCheck-7822";
210       client.get(project, region, healthCheck);
211       Assert.fail("No exception raised");
212     } catch (InvalidArgumentException e) {
213       // Expected exception.
214     }
215   }
216 
217   @Test
insertTest()218   public void insertTest() throws Exception {
219     Operation expectedResponse =
220         Operation.newBuilder()
221             .setClientOperationId("clientOperationId-1230366697")
222             .setCreationTimestamp("creationTimestamp-370203401")
223             .setDescription("description-1724546052")
224             .setEndTime("endTime-1607243192")
225             .setError(Error.newBuilder().build())
226             .setHttpErrorMessage("httpErrorMessage1577303431")
227             .setHttpErrorStatusCode(0)
228             .setId(3355)
229             .setInsertTime("insertTime966165798")
230             .setKind("kind3292052")
231             .setName("name3373707")
232             .setOperationGroupId("operationGroupId1716161683")
233             .setOperationType("operationType91999553")
234             .setProgress(-1001078227)
235             .setRegion("region-934795532")
236             .setSelfLink("selfLink1191800166")
237             .setStartTime("startTime-2129294769")
238             .setStatus(Status.DONE)
239             .setStatusMessage("statusMessage-958704715")
240             .setTargetId(-815576439)
241             .setTargetLink("targetLink486368555")
242             .setUser("user3599307")
243             .addAllWarnings(new ArrayList<Warnings>())
244             .setZone("zone3744684")
245             .build();
246     mockService.addResponse(expectedResponse);
247 
248     String project = "project-6911";
249     String region = "region-9622";
250     HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
251 
252     Operation actualResponse = client.insertAsync(project, region, healthCheckResource).get();
253     Assert.assertEquals(expectedResponse, actualResponse);
254 
255     List<String> actualRequests = mockService.getRequestPaths();
256     Assert.assertEquals(1, actualRequests.size());
257 
258     String apiClientHeaderKey =
259         mockService
260             .getRequestHeaders()
261             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
262             .iterator()
263             .next();
264     Assert.assertTrue(
265         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
266             .matcher(apiClientHeaderKey)
267             .matches());
268   }
269 
270   @Test
insertExceptionTest()271   public void insertExceptionTest() throws Exception {
272     ApiException exception =
273         ApiExceptionFactory.createException(
274             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
275     mockService.addException(exception);
276 
277     try {
278       String project = "project-6911";
279       String region = "region-9622";
280       HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
281       client.insertAsync(project, region, healthCheckResource).get();
282       Assert.fail("No exception raised");
283     } catch (ExecutionException e) {
284     }
285   }
286 
287   @Test
listTest()288   public void listTest() throws Exception {
289     HealthCheck responsesElement = HealthCheck.newBuilder().build();
290     HealthCheckList expectedResponse =
291         HealthCheckList.newBuilder()
292             .setNextPageToken("")
293             .addAllItems(Arrays.asList(responsesElement))
294             .build();
295     mockService.addResponse(expectedResponse);
296 
297     String project = "project-6911";
298     String region = "region-9622";
299 
300     ListPagedResponse pagedListResponse = client.list(project, region);
301 
302     List<HealthCheck> resources = Lists.newArrayList(pagedListResponse.iterateAll());
303 
304     Assert.assertEquals(1, resources.size());
305     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
306 
307     List<String> actualRequests = mockService.getRequestPaths();
308     Assert.assertEquals(1, actualRequests.size());
309 
310     String apiClientHeaderKey =
311         mockService
312             .getRequestHeaders()
313             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
314             .iterator()
315             .next();
316     Assert.assertTrue(
317         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
318             .matcher(apiClientHeaderKey)
319             .matches());
320   }
321 
322   @Test
listExceptionTest()323   public void listExceptionTest() throws Exception {
324     ApiException exception =
325         ApiExceptionFactory.createException(
326             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
327     mockService.addException(exception);
328 
329     try {
330       String project = "project-6911";
331       String region = "region-9622";
332       client.list(project, region);
333       Assert.fail("No exception raised");
334     } catch (InvalidArgumentException e) {
335       // Expected exception.
336     }
337   }
338 
339   @Test
patchTest()340   public void patchTest() throws Exception {
341     Operation expectedResponse =
342         Operation.newBuilder()
343             .setClientOperationId("clientOperationId-1230366697")
344             .setCreationTimestamp("creationTimestamp-370203401")
345             .setDescription("description-1724546052")
346             .setEndTime("endTime-1607243192")
347             .setError(Error.newBuilder().build())
348             .setHttpErrorMessage("httpErrorMessage1577303431")
349             .setHttpErrorStatusCode(0)
350             .setId(3355)
351             .setInsertTime("insertTime966165798")
352             .setKind("kind3292052")
353             .setName("name3373707")
354             .setOperationGroupId("operationGroupId1716161683")
355             .setOperationType("operationType91999553")
356             .setProgress(-1001078227)
357             .setRegion("region-934795532")
358             .setSelfLink("selfLink1191800166")
359             .setStartTime("startTime-2129294769")
360             .setStatus(Status.DONE)
361             .setStatusMessage("statusMessage-958704715")
362             .setTargetId(-815576439)
363             .setTargetLink("targetLink486368555")
364             .setUser("user3599307")
365             .addAllWarnings(new ArrayList<Warnings>())
366             .setZone("zone3744684")
367             .build();
368     mockService.addResponse(expectedResponse);
369 
370     String project = "project-6911";
371     String region = "region-9622";
372     String healthCheck = "healthCheck-7822";
373     HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
374 
375     Operation actualResponse =
376         client.patchAsync(project, region, healthCheck, healthCheckResource).get();
377     Assert.assertEquals(expectedResponse, actualResponse);
378 
379     List<String> actualRequests = mockService.getRequestPaths();
380     Assert.assertEquals(1, actualRequests.size());
381 
382     String apiClientHeaderKey =
383         mockService
384             .getRequestHeaders()
385             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
386             .iterator()
387             .next();
388     Assert.assertTrue(
389         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
390             .matcher(apiClientHeaderKey)
391             .matches());
392   }
393 
394   @Test
patchExceptionTest()395   public void patchExceptionTest() throws Exception {
396     ApiException exception =
397         ApiExceptionFactory.createException(
398             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
399     mockService.addException(exception);
400 
401     try {
402       String project = "project-6911";
403       String region = "region-9622";
404       String healthCheck = "healthCheck-7822";
405       HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
406       client.patchAsync(project, region, healthCheck, healthCheckResource).get();
407       Assert.fail("No exception raised");
408     } catch (ExecutionException e) {
409     }
410   }
411 
412   @Test
updateTest()413   public void updateTest() throws Exception {
414     Operation expectedResponse =
415         Operation.newBuilder()
416             .setClientOperationId("clientOperationId-1230366697")
417             .setCreationTimestamp("creationTimestamp-370203401")
418             .setDescription("description-1724546052")
419             .setEndTime("endTime-1607243192")
420             .setError(Error.newBuilder().build())
421             .setHttpErrorMessage("httpErrorMessage1577303431")
422             .setHttpErrorStatusCode(0)
423             .setId(3355)
424             .setInsertTime("insertTime966165798")
425             .setKind("kind3292052")
426             .setName("name3373707")
427             .setOperationGroupId("operationGroupId1716161683")
428             .setOperationType("operationType91999553")
429             .setProgress(-1001078227)
430             .setRegion("region-934795532")
431             .setSelfLink("selfLink1191800166")
432             .setStartTime("startTime-2129294769")
433             .setStatus(Status.DONE)
434             .setStatusMessage("statusMessage-958704715")
435             .setTargetId(-815576439)
436             .setTargetLink("targetLink486368555")
437             .setUser("user3599307")
438             .addAllWarnings(new ArrayList<Warnings>())
439             .setZone("zone3744684")
440             .build();
441     mockService.addResponse(expectedResponse);
442 
443     String project = "project-6911";
444     String region = "region-9622";
445     String healthCheck = "healthCheck-7822";
446     HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
447 
448     Operation actualResponse =
449         client.updateAsync(project, region, healthCheck, healthCheckResource).get();
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
updateExceptionTest()468   public void updateExceptionTest() 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 region = "region-9622";
477       String healthCheck = "healthCheck-7822";
478       HealthCheck healthCheckResource = HealthCheck.newBuilder().build();
479       client.updateAsync(project, region, healthCheck, healthCheckResource).get();
480       Assert.fail("No exception raised");
481     } catch (ExecutionException e) {
482     }
483   }
484 }
485