• 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.RoutesClient.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.HttpJsonRoutesStub;
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 RoutesClientTest {
48   private static MockHttpService mockService;
49   private static RoutesClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonRoutesStub.getMethodDescriptors(), RoutesSettings.getDefaultEndpoint());
56     RoutesSettings settings =
57         RoutesSettings.newBuilder()
58             .setTransportChannelProvider(
59                 RoutesSettings.defaultHttpJsonTransportProviderBuilder()
60                     .setHttpTransport(mockService)
61                     .build())
62             .setCredentialsProvider(NoCredentialsProvider.create())
63             .build();
64     client = RoutesClient.create(settings);
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     client.close();
70   }
71 
72   @Before
setUp()73   public void setUp() {}
74 
75   @After
tearDown()76   public void tearDown() throws Exception {
77     mockService.reset();
78   }
79 
80   @Test
deleteTest()81   public void deleteTest() throws Exception {
82     Operation expectedResponse =
83         Operation.newBuilder()
84             .setClientOperationId("clientOperationId-1230366697")
85             .setCreationTimestamp("creationTimestamp-370203401")
86             .setDescription("description-1724546052")
87             .setEndTime("endTime-1607243192")
88             .setError(Error.newBuilder().build())
89             .setHttpErrorMessage("httpErrorMessage1577303431")
90             .setHttpErrorStatusCode(0)
91             .setId(3355)
92             .setInsertTime("insertTime966165798")
93             .setKind("kind3292052")
94             .setName("name3373707")
95             .setOperationGroupId("operationGroupId1716161683")
96             .setOperationType("operationType91999553")
97             .setProgress(-1001078227)
98             .setRegion("region-934795532")
99             .setSelfLink("selfLink1191800166")
100             .setStartTime("startTime-2129294769")
101             .setStatus(Status.DONE)
102             .setStatusMessage("statusMessage-958704715")
103             .setTargetId(-815576439)
104             .setTargetLink("targetLink486368555")
105             .setUser("user3599307")
106             .addAllWarnings(new ArrayList<Warnings>())
107             .setZone("zone3744684")
108             .build();
109     mockService.addResponse(expectedResponse);
110 
111     String project = "project-6911";
112     String route = "route-3055";
113 
114     Operation actualResponse = client.deleteAsync(project, route).get();
115     Assert.assertEquals(expectedResponse, actualResponse);
116 
117     List<String> actualRequests = mockService.getRequestPaths();
118     Assert.assertEquals(1, actualRequests.size());
119 
120     String apiClientHeaderKey =
121         mockService
122             .getRequestHeaders()
123             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
124             .iterator()
125             .next();
126     Assert.assertTrue(
127         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
128             .matcher(apiClientHeaderKey)
129             .matches());
130   }
131 
132   @Test
deleteExceptionTest()133   public void deleteExceptionTest() throws Exception {
134     ApiException exception =
135         ApiExceptionFactory.createException(
136             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
137     mockService.addException(exception);
138 
139     try {
140       String project = "project-6911";
141       String route = "route-3055";
142       client.deleteAsync(project, route).get();
143       Assert.fail("No exception raised");
144     } catch (ExecutionException e) {
145     }
146   }
147 
148   @Test
getTest()149   public void getTest() throws Exception {
150     Route expectedResponse =
151         Route.newBuilder()
152             .addAllAsPaths(new ArrayList<RouteAsPath>())
153             .setCreationTimestamp("creationTimestamp-370203401")
154             .setDescription("description-1724546052")
155             .setDestRange("destRange1956782011")
156             .setId(3355)
157             .setKind("kind3292052")
158             .setName("name3373707")
159             .setNetwork("network1843485230")
160             .setNextHopGateway("nextHopGateway45033742")
161             .setNextHopIlb("nextHopIlb-1583648919")
162             .setNextHopInstance("nextHopInstance-776074485")
163             .setNextHopIp("nextHopIp1195840541")
164             .setNextHopNetwork("nextHopNetwork2077637880")
165             .setNextHopPeering("nextHopPeering-456329718")
166             .setNextHopVpnTunnel("nextHopVpnTunnel2134841030")
167             .setPriority(-1165461084)
168             .setRouteStatus("routeStatus-2113481829")
169             .setRouteType("routeType167668003")
170             .setSelfLink("selfLink1191800166")
171             .addAllTags(new ArrayList<String>())
172             .addAllWarnings(new ArrayList<Warnings>())
173             .build();
174     mockService.addResponse(expectedResponse);
175 
176     String project = "project-6911";
177     String route = "route-3055";
178 
179     Route actualResponse = client.get(project, route);
180     Assert.assertEquals(expectedResponse, actualResponse);
181 
182     List<String> actualRequests = mockService.getRequestPaths();
183     Assert.assertEquals(1, actualRequests.size());
184 
185     String apiClientHeaderKey =
186         mockService
187             .getRequestHeaders()
188             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
189             .iterator()
190             .next();
191     Assert.assertTrue(
192         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
193             .matcher(apiClientHeaderKey)
194             .matches());
195   }
196 
197   @Test
getExceptionTest()198   public void getExceptionTest() throws Exception {
199     ApiException exception =
200         ApiExceptionFactory.createException(
201             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
202     mockService.addException(exception);
203 
204     try {
205       String project = "project-6911";
206       String route = "route-3055";
207       client.get(project, route);
208       Assert.fail("No exception raised");
209     } catch (InvalidArgumentException e) {
210       // Expected exception.
211     }
212   }
213 
214   @Test
insertTest()215   public void insertTest() throws Exception {
216     Operation expectedResponse =
217         Operation.newBuilder()
218             .setClientOperationId("clientOperationId-1230366697")
219             .setCreationTimestamp("creationTimestamp-370203401")
220             .setDescription("description-1724546052")
221             .setEndTime("endTime-1607243192")
222             .setError(Error.newBuilder().build())
223             .setHttpErrorMessage("httpErrorMessage1577303431")
224             .setHttpErrorStatusCode(0)
225             .setId(3355)
226             .setInsertTime("insertTime966165798")
227             .setKind("kind3292052")
228             .setName("name3373707")
229             .setOperationGroupId("operationGroupId1716161683")
230             .setOperationType("operationType91999553")
231             .setProgress(-1001078227)
232             .setRegion("region-934795532")
233             .setSelfLink("selfLink1191800166")
234             .setStartTime("startTime-2129294769")
235             .setStatus(Status.DONE)
236             .setStatusMessage("statusMessage-958704715")
237             .setTargetId(-815576439)
238             .setTargetLink("targetLink486368555")
239             .setUser("user3599307")
240             .addAllWarnings(new ArrayList<Warnings>())
241             .setZone("zone3744684")
242             .build();
243     mockService.addResponse(expectedResponse);
244 
245     String project = "project-6911";
246     Route routeResource = Route.newBuilder().build();
247 
248     Operation actualResponse = client.insertAsync(project, routeResource).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       Route routeResource = Route.newBuilder().build();
276       client.insertAsync(project, routeResource).get();
277       Assert.fail("No exception raised");
278     } catch (ExecutionException e) {
279     }
280   }
281 
282   @Test
listTest()283   public void listTest() throws Exception {
284     Route responsesElement = Route.newBuilder().build();
285     RouteList expectedResponse =
286         RouteList.newBuilder()
287             .setNextPageToken("")
288             .addAllItems(Arrays.asList(responsesElement))
289             .build();
290     mockService.addResponse(expectedResponse);
291 
292     String project = "project-6911";
293 
294     ListPagedResponse pagedListResponse = client.list(project);
295 
296     List<Route> resources = Lists.newArrayList(pagedListResponse.iterateAll());
297 
298     Assert.assertEquals(1, resources.size());
299     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
300 
301     List<String> actualRequests = mockService.getRequestPaths();
302     Assert.assertEquals(1, actualRequests.size());
303 
304     String apiClientHeaderKey =
305         mockService
306             .getRequestHeaders()
307             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
308             .iterator()
309             .next();
310     Assert.assertTrue(
311         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
312             .matcher(apiClientHeaderKey)
313             .matches());
314   }
315 
316   @Test
listExceptionTest()317   public void listExceptionTest() throws Exception {
318     ApiException exception =
319         ApiExceptionFactory.createException(
320             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
321     mockService.addException(exception);
322 
323     try {
324       String project = "project-6911";
325       client.list(project);
326       Assert.fail("No exception raised");
327     } catch (InvalidArgumentException e) {
328       // Expected exception.
329     }
330   }
331 }
332