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