• 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.VpnTunnelsClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.VpnTunnelsClient.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.HttpJsonVpnTunnelsStub;
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.List;
39 import java.util.Map;
40 import java.util.concurrent.ExecutionException;
41 import javax.annotation.Generated;
42 import org.junit.After;
43 import org.junit.AfterClass;
44 import org.junit.Assert;
45 import org.junit.Before;
46 import org.junit.BeforeClass;
47 import org.junit.Test;
48 
49 @Generated("by gapic-generator-java")
50 public class VpnTunnelsClientTest {
51   private static MockHttpService mockService;
52   private static VpnTunnelsClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonVpnTunnelsStub.getMethodDescriptors(), VpnTunnelsSettings.getDefaultEndpoint());
59     VpnTunnelsSettings settings =
60         VpnTunnelsSettings.newBuilder()
61             .setTransportChannelProvider(
62                 VpnTunnelsSettings.defaultHttpJsonTransportProviderBuilder()
63                     .setHttpTransport(mockService)
64                     .build())
65             .setCredentialsProvider(NoCredentialsProvider.create())
66             .build();
67     client = VpnTunnelsClient.create(settings);
68   }
69 
70   @AfterClass
stopServer()71   public static void stopServer() {
72     client.close();
73   }
74 
75   @Before
setUp()76   public void setUp() {}
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     mockService.reset();
81   }
82 
83   @Test
aggregatedListTest()84   public void aggregatedListTest() throws Exception {
85     VpnTunnelsScopedList responsesElement = VpnTunnelsScopedList.newBuilder().build();
86     VpnTunnelAggregatedList expectedResponse =
87         VpnTunnelAggregatedList.newBuilder()
88             .setNextPageToken("")
89             .putAllItems(Collections.singletonMap("items", responsesElement))
90             .build();
91     mockService.addResponse(expectedResponse);
92 
93     String project = "project-6911";
94 
95     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
96 
97     List<Map.Entry<String, VpnTunnelsScopedList>> resources =
98         Lists.newArrayList(pagedListResponse.iterateAll());
99 
100     Assert.assertEquals(1, resources.size());
101     Assert.assertEquals(
102         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
103 
104     List<String> actualRequests = mockService.getRequestPaths();
105     Assert.assertEquals(1, actualRequests.size());
106 
107     String apiClientHeaderKey =
108         mockService
109             .getRequestHeaders()
110             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
111             .iterator()
112             .next();
113     Assert.assertTrue(
114         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
115             .matcher(apiClientHeaderKey)
116             .matches());
117   }
118 
119   @Test
aggregatedListExceptionTest()120   public void aggregatedListExceptionTest() throws Exception {
121     ApiException exception =
122         ApiExceptionFactory.createException(
123             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
124     mockService.addException(exception);
125 
126     try {
127       String project = "project-6911";
128       client.aggregatedList(project);
129       Assert.fail("No exception raised");
130     } catch (InvalidArgumentException e) {
131       // Expected exception.
132     }
133   }
134 
135   @Test
deleteTest()136   public void deleteTest() throws Exception {
137     Operation expectedResponse =
138         Operation.newBuilder()
139             .setClientOperationId("clientOperationId-1230366697")
140             .setCreationTimestamp("creationTimestamp-370203401")
141             .setDescription("description-1724546052")
142             .setEndTime("endTime-1607243192")
143             .setError(Error.newBuilder().build())
144             .setHttpErrorMessage("httpErrorMessage1577303431")
145             .setHttpErrorStatusCode(0)
146             .setId(3355)
147             .setInsertTime("insertTime966165798")
148             .setKind("kind3292052")
149             .setName("name3373707")
150             .setOperationGroupId("operationGroupId1716161683")
151             .setOperationType("operationType91999553")
152             .setProgress(-1001078227)
153             .setRegion("region-934795532")
154             .setSelfLink("selfLink1191800166")
155             .setStartTime("startTime-2129294769")
156             .setStatus(Status.DONE)
157             .setStatusMessage("statusMessage-958704715")
158             .setTargetId(-815576439)
159             .setTargetLink("targetLink486368555")
160             .setUser("user3599307")
161             .addAllWarnings(new ArrayList<Warnings>())
162             .setZone("zone3744684")
163             .build();
164     mockService.addResponse(expectedResponse);
165 
166     String project = "project-6911";
167     String region = "region-9622";
168     String vpnTunnel = "vpnTunnel-5086";
169 
170     Operation actualResponse = client.deleteAsync(project, region, vpnTunnel).get();
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
deleteExceptionTest()189   public void deleteExceptionTest() 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 region = "region-9622";
198       String vpnTunnel = "vpnTunnel-5086";
199       client.deleteAsync(project, region, vpnTunnel).get();
200       Assert.fail("No exception raised");
201     } catch (ExecutionException e) {
202     }
203   }
204 
205   @Test
getTest()206   public void getTest() throws Exception {
207     VpnTunnel expectedResponse =
208         VpnTunnel.newBuilder()
209             .setCreationTimestamp("creationTimestamp-370203401")
210             .setDescription("description-1724546052")
211             .setDetailedStatus("detailedStatus879873218")
212             .setId(3355)
213             .setIkeVersion(1292118044)
214             .setKind("kind3292052")
215             .addAllLocalTrafficSelector(new ArrayList<String>())
216             .setName("name3373707")
217             .setPeerExternalGateway("peerExternalGateway-1595423177")
218             .setPeerExternalGatewayInterface(-620973433)
219             .setPeerGcpGateway("peerGcpGateway586378130")
220             .setPeerIp("peerIp-992105943")
221             .setRegion("region-934795532")
222             .addAllRemoteTrafficSelector(new ArrayList<String>())
223             .setRouter("router-925132983")
224             .setSelfLink("selfLink1191800166")
225             .setSharedSecret("sharedSecret-1054259339")
226             .setSharedSecretHash("sharedSecretHash-205473245")
227             .setStatus("status-892481550")
228             .setTargetVpnGateway("targetVpnGateway935274273")
229             .setVpnGateway("vpnGateway1920916144")
230             .setVpnGatewayInterface(632850035)
231             .build();
232     mockService.addResponse(expectedResponse);
233 
234     String project = "project-6911";
235     String region = "region-9622";
236     String vpnTunnel = "vpnTunnel-5086";
237 
238     VpnTunnel actualResponse = client.get(project, region, vpnTunnel);
239     Assert.assertEquals(expectedResponse, actualResponse);
240 
241     List<String> actualRequests = mockService.getRequestPaths();
242     Assert.assertEquals(1, actualRequests.size());
243 
244     String apiClientHeaderKey =
245         mockService
246             .getRequestHeaders()
247             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
248             .iterator()
249             .next();
250     Assert.assertTrue(
251         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
252             .matcher(apiClientHeaderKey)
253             .matches());
254   }
255 
256   @Test
getExceptionTest()257   public void getExceptionTest() throws Exception {
258     ApiException exception =
259         ApiExceptionFactory.createException(
260             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
261     mockService.addException(exception);
262 
263     try {
264       String project = "project-6911";
265       String region = "region-9622";
266       String vpnTunnel = "vpnTunnel-5086";
267       client.get(project, region, vpnTunnel);
268       Assert.fail("No exception raised");
269     } catch (InvalidArgumentException e) {
270       // Expected exception.
271     }
272   }
273 
274   @Test
insertTest()275   public void insertTest() throws Exception {
276     Operation expectedResponse =
277         Operation.newBuilder()
278             .setClientOperationId("clientOperationId-1230366697")
279             .setCreationTimestamp("creationTimestamp-370203401")
280             .setDescription("description-1724546052")
281             .setEndTime("endTime-1607243192")
282             .setError(Error.newBuilder().build())
283             .setHttpErrorMessage("httpErrorMessage1577303431")
284             .setHttpErrorStatusCode(0)
285             .setId(3355)
286             .setInsertTime("insertTime966165798")
287             .setKind("kind3292052")
288             .setName("name3373707")
289             .setOperationGroupId("operationGroupId1716161683")
290             .setOperationType("operationType91999553")
291             .setProgress(-1001078227)
292             .setRegion("region-934795532")
293             .setSelfLink("selfLink1191800166")
294             .setStartTime("startTime-2129294769")
295             .setStatus(Status.DONE)
296             .setStatusMessage("statusMessage-958704715")
297             .setTargetId(-815576439)
298             .setTargetLink("targetLink486368555")
299             .setUser("user3599307")
300             .addAllWarnings(new ArrayList<Warnings>())
301             .setZone("zone3744684")
302             .build();
303     mockService.addResponse(expectedResponse);
304 
305     String project = "project-6911";
306     String region = "region-9622";
307     VpnTunnel vpnTunnelResource = VpnTunnel.newBuilder().build();
308 
309     Operation actualResponse = client.insertAsync(project, region, vpnTunnelResource).get();
310     Assert.assertEquals(expectedResponse, actualResponse);
311 
312     List<String> actualRequests = mockService.getRequestPaths();
313     Assert.assertEquals(1, actualRequests.size());
314 
315     String apiClientHeaderKey =
316         mockService
317             .getRequestHeaders()
318             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
319             .iterator()
320             .next();
321     Assert.assertTrue(
322         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
323             .matcher(apiClientHeaderKey)
324             .matches());
325   }
326 
327   @Test
insertExceptionTest()328   public void insertExceptionTest() throws Exception {
329     ApiException exception =
330         ApiExceptionFactory.createException(
331             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
332     mockService.addException(exception);
333 
334     try {
335       String project = "project-6911";
336       String region = "region-9622";
337       VpnTunnel vpnTunnelResource = VpnTunnel.newBuilder().build();
338       client.insertAsync(project, region, vpnTunnelResource).get();
339       Assert.fail("No exception raised");
340     } catch (ExecutionException e) {
341     }
342   }
343 
344   @Test
listTest()345   public void listTest() throws Exception {
346     VpnTunnel responsesElement = VpnTunnel.newBuilder().build();
347     VpnTunnelList expectedResponse =
348         VpnTunnelList.newBuilder()
349             .setNextPageToken("")
350             .addAllItems(Arrays.asList(responsesElement))
351             .build();
352     mockService.addResponse(expectedResponse);
353 
354     String project = "project-6911";
355     String region = "region-9622";
356 
357     ListPagedResponse pagedListResponse = client.list(project, region);
358 
359     List<VpnTunnel> resources = Lists.newArrayList(pagedListResponse.iterateAll());
360 
361     Assert.assertEquals(1, resources.size());
362     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
363 
364     List<String> actualRequests = mockService.getRequestPaths();
365     Assert.assertEquals(1, actualRequests.size());
366 
367     String apiClientHeaderKey =
368         mockService
369             .getRequestHeaders()
370             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
371             .iterator()
372             .next();
373     Assert.assertTrue(
374         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
375             .matcher(apiClientHeaderKey)
376             .matches());
377   }
378 
379   @Test
listExceptionTest()380   public void listExceptionTest() throws Exception {
381     ApiException exception =
382         ApiExceptionFactory.createException(
383             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
384     mockService.addException(exception);
385 
386     try {
387       String project = "project-6911";
388       String region = "region-9622";
389       client.list(project, region);
390       Assert.fail("No exception raised");
391     } catch (InvalidArgumentException e) {
392       // Expected exception.
393     }
394   }
395 
396   @Test
setLabelsTest()397   public void setLabelsTest() throws Exception {
398     Operation expectedResponse =
399         Operation.newBuilder()
400             .setClientOperationId("clientOperationId-1230366697")
401             .setCreationTimestamp("creationTimestamp-370203401")
402             .setDescription("description-1724546052")
403             .setEndTime("endTime-1607243192")
404             .setError(Error.newBuilder().build())
405             .setHttpErrorMessage("httpErrorMessage1577303431")
406             .setHttpErrorStatusCode(0)
407             .setId(3355)
408             .setInsertTime("insertTime966165798")
409             .setKind("kind3292052")
410             .setName("name3373707")
411             .setOperationGroupId("operationGroupId1716161683")
412             .setOperationType("operationType91999553")
413             .setProgress(-1001078227)
414             .setRegion("region-934795532")
415             .setSelfLink("selfLink1191800166")
416             .setStartTime("startTime-2129294769")
417             .setStatus(Status.DONE)
418             .setStatusMessage("statusMessage-958704715")
419             .setTargetId(-815576439)
420             .setTargetLink("targetLink486368555")
421             .setUser("user3599307")
422             .addAllWarnings(new ArrayList<Warnings>())
423             .setZone("zone3744684")
424             .build();
425     mockService.addResponse(expectedResponse);
426 
427     String project = "project-6911";
428     String region = "region-9622";
429     String resource = "resource-756";
430     RegionSetLabelsRequest regionSetLabelsRequestResource =
431         RegionSetLabelsRequest.newBuilder().build();
432 
433     Operation actualResponse =
434         client.setLabelsAsync(project, region, resource, regionSetLabelsRequestResource).get();
435     Assert.assertEquals(expectedResponse, actualResponse);
436 
437     List<String> actualRequests = mockService.getRequestPaths();
438     Assert.assertEquals(1, actualRequests.size());
439 
440     String apiClientHeaderKey =
441         mockService
442             .getRequestHeaders()
443             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
444             .iterator()
445             .next();
446     Assert.assertTrue(
447         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
448             .matcher(apiClientHeaderKey)
449             .matches());
450   }
451 
452   @Test
setLabelsExceptionTest()453   public void setLabelsExceptionTest() throws Exception {
454     ApiException exception =
455         ApiExceptionFactory.createException(
456             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
457     mockService.addException(exception);
458 
459     try {
460       String project = "project-6911";
461       String region = "region-9622";
462       String resource = "resource-756";
463       RegionSetLabelsRequest regionSetLabelsRequestResource =
464           RegionSetLabelsRequest.newBuilder().build();
465       client.setLabelsAsync(project, region, resource, regionSetLabelsRequestResource).get();
466       Assert.fail("No exception raised");
467     } catch (ExecutionException e) {
468     }
469   }
470 }
471