• 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.appengine.v1;
18 
19 import static com.google.appengine.v1.VersionsClient.ListVersionsPagedResponse;
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.appengine.v1.stub.HttpJsonVersionsStub;
31 import com.google.common.collect.Lists;
32 import com.google.longrunning.Operation;
33 import com.google.protobuf.Any;
34 import com.google.protobuf.Duration;
35 import com.google.protobuf.Empty;
36 import com.google.protobuf.FieldMask;
37 import com.google.protobuf.Timestamp;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.List;
43 import java.util.concurrent.ExecutionException;
44 import javax.annotation.Generated;
45 import org.junit.After;
46 import org.junit.AfterClass;
47 import org.junit.Assert;
48 import org.junit.Before;
49 import org.junit.BeforeClass;
50 import org.junit.Test;
51 
52 @Generated("by gapic-generator-java")
53 public class VersionsClientHttpJsonTest {
54   private static MockHttpService mockService;
55   private static VersionsClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() throws IOException {
59     mockService =
60         new MockHttpService(
61             HttpJsonVersionsStub.getMethodDescriptors(), VersionsSettings.getDefaultEndpoint());
62     VersionsSettings settings =
63         VersionsSettings.newHttpJsonBuilder()
64             .setTransportChannelProvider(
65                 VersionsSettings.defaultHttpJsonTransportProviderBuilder()
66                     .setHttpTransport(mockService)
67                     .build())
68             .setCredentialsProvider(NoCredentialsProvider.create())
69             .build();
70     client = VersionsClient.create(settings);
71   }
72 
73   @AfterClass
stopServer()74   public static void stopServer() {
75     client.close();
76   }
77 
78   @Before
setUp()79   public void setUp() {}
80 
81   @After
tearDown()82   public void tearDown() throws Exception {
83     mockService.reset();
84   }
85 
86   @Test
listVersionsTest()87   public void listVersionsTest() throws Exception {
88     Version responsesElement = Version.newBuilder().build();
89     ListVersionsResponse expectedResponse =
90         ListVersionsResponse.newBuilder()
91             .setNextPageToken("")
92             .addAllVersions(Arrays.asList(responsesElement))
93             .build();
94     mockService.addResponse(expectedResponse);
95 
96     ListVersionsRequest request =
97         ListVersionsRequest.newBuilder()
98             .setParent("apps/app-4783/services/service-4783")
99             .setView(VersionView.forNumber(0))
100             .setPageSize(883849137)
101             .setPageToken("pageToken873572522")
102             .build();
103 
104     ListVersionsPagedResponse pagedListResponse = client.listVersions(request);
105 
106     List<Version> resources = Lists.newArrayList(pagedListResponse.iterateAll());
107 
108     Assert.assertEquals(1, resources.size());
109     Assert.assertEquals(expectedResponse.getVersionsList().get(0), resources.get(0));
110 
111     List<String> actualRequests = mockService.getRequestPaths();
112     Assert.assertEquals(1, actualRequests.size());
113 
114     String apiClientHeaderKey =
115         mockService
116             .getRequestHeaders()
117             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
118             .iterator()
119             .next();
120     Assert.assertTrue(
121         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
122             .matcher(apiClientHeaderKey)
123             .matches());
124   }
125 
126   @Test
listVersionsExceptionTest()127   public void listVersionsExceptionTest() throws Exception {
128     ApiException exception =
129         ApiExceptionFactory.createException(
130             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
131     mockService.addException(exception);
132 
133     try {
134       ListVersionsRequest request =
135           ListVersionsRequest.newBuilder()
136               .setParent("apps/app-4783/services/service-4783")
137               .setView(VersionView.forNumber(0))
138               .setPageSize(883849137)
139               .setPageToken("pageToken873572522")
140               .build();
141       client.listVersions(request);
142       Assert.fail("No exception raised");
143     } catch (InvalidArgumentException e) {
144       // Expected exception.
145     }
146   }
147 
148   @Test
getVersionTest()149   public void getVersionTest() throws Exception {
150     Version expectedResponse =
151         Version.newBuilder()
152             .setName("name3373707")
153             .setId("id3355")
154             .addAllInboundServices(new ArrayList<InboundServiceType>())
155             .setInstanceClass("instanceClass-1408583197")
156             .setNetwork(Network.newBuilder().build())
157             .addAllZones(new ArrayList<String>())
158             .setResources(Resources.newBuilder().build())
159             .setRuntime("runtime1550962648")
160             .setRuntimeChannel("runtimeChannel989413899")
161             .setThreadsafe(true)
162             .setVm(true)
163             .setAppEngineApis(true)
164             .putAllBetaSettings(new HashMap<String, String>())
165             .setEnv("env100589")
166             .setServingStatus(ServingStatus.forNumber(0))
167             .setCreatedBy("createdBy598371679")
168             .setCreateTime(Timestamp.newBuilder().build())
169             .setDiskUsageBytes(1139084459)
170             .setRuntimeApiVersion("runtimeApiVersion-925808810")
171             .setRuntimeMainExecutablePath("runtimeMainExecutablePath454707104")
172             .setServiceAccount("serviceAccount1079137720")
173             .addAllHandlers(new ArrayList<UrlMap>())
174             .addAllErrorHandlers(new ArrayList<ErrorHandler>())
175             .addAllLibraries(new ArrayList<Library>())
176             .setApiConfig(ApiConfigHandler.newBuilder().build())
177             .putAllEnvVariables(new HashMap<String, String>())
178             .putAllBuildEnvVariables(new HashMap<String, String>())
179             .setDefaultExpiration(Duration.newBuilder().build())
180             .setHealthCheck(HealthCheck.newBuilder().build())
181             .setReadinessCheck(ReadinessCheck.newBuilder().build())
182             .setLivenessCheck(LivenessCheck.newBuilder().build())
183             .setNobuildFilesRegex("nobuildFilesRegex1787347261")
184             .setDeployment(Deployment.newBuilder().build())
185             .setVersionUrl("versionUrl-670506633")
186             .setEndpointsApiService(EndpointsApiService.newBuilder().build())
187             .setEntrypoint(Entrypoint.newBuilder().build())
188             .setVpcAccessConnector(VpcAccessConnector.newBuilder().build())
189             .build();
190     mockService.addResponse(expectedResponse);
191 
192     GetVersionRequest request =
193         GetVersionRequest.newBuilder()
194             .setName("apps/app-69/services/service-69/versions/version-69")
195             .setView(VersionView.forNumber(0))
196             .build();
197 
198     Version actualResponse = client.getVersion(request);
199     Assert.assertEquals(expectedResponse, actualResponse);
200 
201     List<String> actualRequests = mockService.getRequestPaths();
202     Assert.assertEquals(1, actualRequests.size());
203 
204     String apiClientHeaderKey =
205         mockService
206             .getRequestHeaders()
207             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
208             .iterator()
209             .next();
210     Assert.assertTrue(
211         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
212             .matcher(apiClientHeaderKey)
213             .matches());
214   }
215 
216   @Test
getVersionExceptionTest()217   public void getVersionExceptionTest() throws Exception {
218     ApiException exception =
219         ApiExceptionFactory.createException(
220             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
221     mockService.addException(exception);
222 
223     try {
224       GetVersionRequest request =
225           GetVersionRequest.newBuilder()
226               .setName("apps/app-69/services/service-69/versions/version-69")
227               .setView(VersionView.forNumber(0))
228               .build();
229       client.getVersion(request);
230       Assert.fail("No exception raised");
231     } catch (InvalidArgumentException e) {
232       // Expected exception.
233     }
234   }
235 
236   @Test
createVersionTest()237   public void createVersionTest() throws Exception {
238     Version expectedResponse =
239         Version.newBuilder()
240             .setName("name3373707")
241             .setId("id3355")
242             .addAllInboundServices(new ArrayList<InboundServiceType>())
243             .setInstanceClass("instanceClass-1408583197")
244             .setNetwork(Network.newBuilder().build())
245             .addAllZones(new ArrayList<String>())
246             .setResources(Resources.newBuilder().build())
247             .setRuntime("runtime1550962648")
248             .setRuntimeChannel("runtimeChannel989413899")
249             .setThreadsafe(true)
250             .setVm(true)
251             .setAppEngineApis(true)
252             .putAllBetaSettings(new HashMap<String, String>())
253             .setEnv("env100589")
254             .setServingStatus(ServingStatus.forNumber(0))
255             .setCreatedBy("createdBy598371679")
256             .setCreateTime(Timestamp.newBuilder().build())
257             .setDiskUsageBytes(1139084459)
258             .setRuntimeApiVersion("runtimeApiVersion-925808810")
259             .setRuntimeMainExecutablePath("runtimeMainExecutablePath454707104")
260             .setServiceAccount("serviceAccount1079137720")
261             .addAllHandlers(new ArrayList<UrlMap>())
262             .addAllErrorHandlers(new ArrayList<ErrorHandler>())
263             .addAllLibraries(new ArrayList<Library>())
264             .setApiConfig(ApiConfigHandler.newBuilder().build())
265             .putAllEnvVariables(new HashMap<String, String>())
266             .putAllBuildEnvVariables(new HashMap<String, String>())
267             .setDefaultExpiration(Duration.newBuilder().build())
268             .setHealthCheck(HealthCheck.newBuilder().build())
269             .setReadinessCheck(ReadinessCheck.newBuilder().build())
270             .setLivenessCheck(LivenessCheck.newBuilder().build())
271             .setNobuildFilesRegex("nobuildFilesRegex1787347261")
272             .setDeployment(Deployment.newBuilder().build())
273             .setVersionUrl("versionUrl-670506633")
274             .setEndpointsApiService(EndpointsApiService.newBuilder().build())
275             .setEntrypoint(Entrypoint.newBuilder().build())
276             .setVpcAccessConnector(VpcAccessConnector.newBuilder().build())
277             .build();
278     Operation resultOperation =
279         Operation.newBuilder()
280             .setName("createVersionTest")
281             .setDone(true)
282             .setResponse(Any.pack(expectedResponse))
283             .build();
284     mockService.addResponse(resultOperation);
285 
286     CreateVersionRequest request =
287         CreateVersionRequest.newBuilder()
288             .setParent("apps/app-4783/services/service-4783")
289             .setVersion(Version.newBuilder().build())
290             .build();
291 
292     Version actualResponse = client.createVersionAsync(request).get();
293     Assert.assertEquals(expectedResponse, actualResponse);
294 
295     List<String> actualRequests = mockService.getRequestPaths();
296     Assert.assertEquals(1, actualRequests.size());
297 
298     String apiClientHeaderKey =
299         mockService
300             .getRequestHeaders()
301             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
302             .iterator()
303             .next();
304     Assert.assertTrue(
305         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
306             .matcher(apiClientHeaderKey)
307             .matches());
308   }
309 
310   @Test
createVersionExceptionTest()311   public void createVersionExceptionTest() throws Exception {
312     ApiException exception =
313         ApiExceptionFactory.createException(
314             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
315     mockService.addException(exception);
316 
317     try {
318       CreateVersionRequest request =
319           CreateVersionRequest.newBuilder()
320               .setParent("apps/app-4783/services/service-4783")
321               .setVersion(Version.newBuilder().build())
322               .build();
323       client.createVersionAsync(request).get();
324       Assert.fail("No exception raised");
325     } catch (ExecutionException e) {
326     }
327   }
328 
329   @Test
updateVersionTest()330   public void updateVersionTest() throws Exception {
331     Version expectedResponse =
332         Version.newBuilder()
333             .setName("name3373707")
334             .setId("id3355")
335             .addAllInboundServices(new ArrayList<InboundServiceType>())
336             .setInstanceClass("instanceClass-1408583197")
337             .setNetwork(Network.newBuilder().build())
338             .addAllZones(new ArrayList<String>())
339             .setResources(Resources.newBuilder().build())
340             .setRuntime("runtime1550962648")
341             .setRuntimeChannel("runtimeChannel989413899")
342             .setThreadsafe(true)
343             .setVm(true)
344             .setAppEngineApis(true)
345             .putAllBetaSettings(new HashMap<String, String>())
346             .setEnv("env100589")
347             .setServingStatus(ServingStatus.forNumber(0))
348             .setCreatedBy("createdBy598371679")
349             .setCreateTime(Timestamp.newBuilder().build())
350             .setDiskUsageBytes(1139084459)
351             .setRuntimeApiVersion("runtimeApiVersion-925808810")
352             .setRuntimeMainExecutablePath("runtimeMainExecutablePath454707104")
353             .setServiceAccount("serviceAccount1079137720")
354             .addAllHandlers(new ArrayList<UrlMap>())
355             .addAllErrorHandlers(new ArrayList<ErrorHandler>())
356             .addAllLibraries(new ArrayList<Library>())
357             .setApiConfig(ApiConfigHandler.newBuilder().build())
358             .putAllEnvVariables(new HashMap<String, String>())
359             .putAllBuildEnvVariables(new HashMap<String, String>())
360             .setDefaultExpiration(Duration.newBuilder().build())
361             .setHealthCheck(HealthCheck.newBuilder().build())
362             .setReadinessCheck(ReadinessCheck.newBuilder().build())
363             .setLivenessCheck(LivenessCheck.newBuilder().build())
364             .setNobuildFilesRegex("nobuildFilesRegex1787347261")
365             .setDeployment(Deployment.newBuilder().build())
366             .setVersionUrl("versionUrl-670506633")
367             .setEndpointsApiService(EndpointsApiService.newBuilder().build())
368             .setEntrypoint(Entrypoint.newBuilder().build())
369             .setVpcAccessConnector(VpcAccessConnector.newBuilder().build())
370             .build();
371     Operation resultOperation =
372         Operation.newBuilder()
373             .setName("updateVersionTest")
374             .setDone(true)
375             .setResponse(Any.pack(expectedResponse))
376             .build();
377     mockService.addResponse(resultOperation);
378 
379     UpdateVersionRequest request =
380         UpdateVersionRequest.newBuilder()
381             .setName("apps/app-69/services/service-69/versions/version-69")
382             .setVersion(Version.newBuilder().build())
383             .setUpdateMask(FieldMask.newBuilder().build())
384             .build();
385 
386     Version actualResponse = client.updateVersionAsync(request).get();
387     Assert.assertEquals(expectedResponse, actualResponse);
388 
389     List<String> actualRequests = mockService.getRequestPaths();
390     Assert.assertEquals(1, actualRequests.size());
391 
392     String apiClientHeaderKey =
393         mockService
394             .getRequestHeaders()
395             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
396             .iterator()
397             .next();
398     Assert.assertTrue(
399         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
400             .matcher(apiClientHeaderKey)
401             .matches());
402   }
403 
404   @Test
updateVersionExceptionTest()405   public void updateVersionExceptionTest() throws Exception {
406     ApiException exception =
407         ApiExceptionFactory.createException(
408             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
409     mockService.addException(exception);
410 
411     try {
412       UpdateVersionRequest request =
413           UpdateVersionRequest.newBuilder()
414               .setName("apps/app-69/services/service-69/versions/version-69")
415               .setVersion(Version.newBuilder().build())
416               .setUpdateMask(FieldMask.newBuilder().build())
417               .build();
418       client.updateVersionAsync(request).get();
419       Assert.fail("No exception raised");
420     } catch (ExecutionException e) {
421     }
422   }
423 
424   @Test
deleteVersionTest()425   public void deleteVersionTest() throws Exception {
426     Empty expectedResponse = Empty.newBuilder().build();
427     Operation resultOperation =
428         Operation.newBuilder()
429             .setName("deleteVersionTest")
430             .setDone(true)
431             .setResponse(Any.pack(expectedResponse))
432             .build();
433     mockService.addResponse(resultOperation);
434 
435     DeleteVersionRequest request =
436         DeleteVersionRequest.newBuilder()
437             .setName("apps/app-69/services/service-69/versions/version-69")
438             .build();
439 
440     client.deleteVersionAsync(request).get();
441 
442     List<String> actualRequests = mockService.getRequestPaths();
443     Assert.assertEquals(1, actualRequests.size());
444 
445     String apiClientHeaderKey =
446         mockService
447             .getRequestHeaders()
448             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
449             .iterator()
450             .next();
451     Assert.assertTrue(
452         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
453             .matcher(apiClientHeaderKey)
454             .matches());
455   }
456 
457   @Test
deleteVersionExceptionTest()458   public void deleteVersionExceptionTest() throws Exception {
459     ApiException exception =
460         ApiExceptionFactory.createException(
461             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
462     mockService.addException(exception);
463 
464     try {
465       DeleteVersionRequest request =
466           DeleteVersionRequest.newBuilder()
467               .setName("apps/app-69/services/service-69/versions/version-69")
468               .build();
469       client.deleteVersionAsync(request).get();
470       Assert.fail("No exception raised");
471     } catch (ExecutionException e) {
472     }
473   }
474 }
475