• 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 com.google.api.gax.core.NoCredentialsProvider;
20 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
21 import com.google.api.gax.httpjson.testing.MockHttpService;
22 import com.google.api.gax.rpc.ApiClientHeaderProvider;
23 import com.google.api.gax.rpc.ApiException;
24 import com.google.api.gax.rpc.ApiExceptionFactory;
25 import com.google.api.gax.rpc.InvalidArgumentException;
26 import com.google.api.gax.rpc.StatusCode;
27 import com.google.api.gax.rpc.testing.FakeStatusCode;
28 import com.google.appengine.v1.stub.HttpJsonApplicationsStub;
29 import com.google.longrunning.Operation;
30 import com.google.protobuf.Any;
31 import com.google.protobuf.Duration;
32 import com.google.protobuf.FieldMask;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.List;
36 import java.util.concurrent.ExecutionException;
37 import javax.annotation.Generated;
38 import org.junit.After;
39 import org.junit.AfterClass;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.BeforeClass;
43 import org.junit.Test;
44 
45 @Generated("by gapic-generator-java")
46 public class ApplicationsClientHttpJsonTest {
47   private static MockHttpService mockService;
48   private static ApplicationsClient client;
49 
50   @BeforeClass
startStaticServer()51   public static void startStaticServer() throws IOException {
52     mockService =
53         new MockHttpService(
54             HttpJsonApplicationsStub.getMethodDescriptors(),
55             ApplicationsSettings.getDefaultEndpoint());
56     ApplicationsSettings settings =
57         ApplicationsSettings.newHttpJsonBuilder()
58             .setTransportChannelProvider(
59                 ApplicationsSettings.defaultHttpJsonTransportProviderBuilder()
60                     .setHttpTransport(mockService)
61                     .build())
62             .setCredentialsProvider(NoCredentialsProvider.create())
63             .build();
64     client = ApplicationsClient.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
getApplicationTest()81   public void getApplicationTest() throws Exception {
82     Application expectedResponse =
83         Application.newBuilder()
84             .setName("name3373707")
85             .setId("id3355")
86             .addAllDispatchRules(new ArrayList<UrlDispatchRule>())
87             .setAuthDomain("authDomain1560526988")
88             .setLocationId("locationId1541836720")
89             .setCodeBucket("codeBucket-1407386057")
90             .setDefaultCookieExpiration(Duration.newBuilder().build())
91             .setDefaultHostname("defaultHostname1698284948")
92             .setDefaultBucket("defaultBucket487561099")
93             .setServiceAccount("serviceAccount1079137720")
94             .setIap(Application.IdentityAwareProxy.newBuilder().build())
95             .setGcrDomain("gcrDomain-595843206")
96             .setFeatureSettings(Application.FeatureSettings.newBuilder().build())
97             .build();
98     mockService.addResponse(expectedResponse);
99 
100     String name = "apps/app-5480";
101 
102     Application actualResponse = client.getApplication(name);
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<String> actualRequests = mockService.getRequestPaths();
106     Assert.assertEquals(1, actualRequests.size());
107 
108     String apiClientHeaderKey =
109         mockService
110             .getRequestHeaders()
111             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
112             .iterator()
113             .next();
114     Assert.assertTrue(
115         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
116             .matcher(apiClientHeaderKey)
117             .matches());
118   }
119 
120   @Test
getApplicationExceptionTest()121   public void getApplicationExceptionTest() throws Exception {
122     ApiException exception =
123         ApiExceptionFactory.createException(
124             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
125     mockService.addException(exception);
126 
127     try {
128       String name = "apps/app-5480";
129       client.getApplication(name);
130       Assert.fail("No exception raised");
131     } catch (InvalidArgumentException e) {
132       // Expected exception.
133     }
134   }
135 
136   @Test
createApplicationTest()137   public void createApplicationTest() throws Exception {
138     Application expectedResponse =
139         Application.newBuilder()
140             .setName("name3373707")
141             .setId("id3355")
142             .addAllDispatchRules(new ArrayList<UrlDispatchRule>())
143             .setAuthDomain("authDomain1560526988")
144             .setLocationId("locationId1541836720")
145             .setCodeBucket("codeBucket-1407386057")
146             .setDefaultCookieExpiration(Duration.newBuilder().build())
147             .setDefaultHostname("defaultHostname1698284948")
148             .setDefaultBucket("defaultBucket487561099")
149             .setServiceAccount("serviceAccount1079137720")
150             .setIap(Application.IdentityAwareProxy.newBuilder().build())
151             .setGcrDomain("gcrDomain-595843206")
152             .setFeatureSettings(Application.FeatureSettings.newBuilder().build())
153             .build();
154     Operation resultOperation =
155         Operation.newBuilder()
156             .setName("createApplicationTest")
157             .setDone(true)
158             .setResponse(Any.pack(expectedResponse))
159             .build();
160     mockService.addResponse(resultOperation);
161 
162     CreateApplicationRequest request =
163         CreateApplicationRequest.newBuilder()
164             .setApplication(Application.newBuilder().build())
165             .build();
166 
167     Application actualResponse = client.createApplicationAsync(request).get();
168     Assert.assertEquals(expectedResponse, actualResponse);
169 
170     List<String> actualRequests = mockService.getRequestPaths();
171     Assert.assertEquals(1, actualRequests.size());
172 
173     String apiClientHeaderKey =
174         mockService
175             .getRequestHeaders()
176             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
177             .iterator()
178             .next();
179     Assert.assertTrue(
180         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
181             .matcher(apiClientHeaderKey)
182             .matches());
183   }
184 
185   @Test
createApplicationExceptionTest()186   public void createApplicationExceptionTest() throws Exception {
187     ApiException exception =
188         ApiExceptionFactory.createException(
189             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
190     mockService.addException(exception);
191 
192     try {
193       CreateApplicationRequest request =
194           CreateApplicationRequest.newBuilder()
195               .setApplication(Application.newBuilder().build())
196               .build();
197       client.createApplicationAsync(request).get();
198       Assert.fail("No exception raised");
199     } catch (ExecutionException e) {
200     }
201   }
202 
203   @Test
updateApplicationTest()204   public void updateApplicationTest() throws Exception {
205     Application expectedResponse =
206         Application.newBuilder()
207             .setName("name3373707")
208             .setId("id3355")
209             .addAllDispatchRules(new ArrayList<UrlDispatchRule>())
210             .setAuthDomain("authDomain1560526988")
211             .setLocationId("locationId1541836720")
212             .setCodeBucket("codeBucket-1407386057")
213             .setDefaultCookieExpiration(Duration.newBuilder().build())
214             .setDefaultHostname("defaultHostname1698284948")
215             .setDefaultBucket("defaultBucket487561099")
216             .setServiceAccount("serviceAccount1079137720")
217             .setIap(Application.IdentityAwareProxy.newBuilder().build())
218             .setGcrDomain("gcrDomain-595843206")
219             .setFeatureSettings(Application.FeatureSettings.newBuilder().build())
220             .build();
221     Operation resultOperation =
222         Operation.newBuilder()
223             .setName("updateApplicationTest")
224             .setDone(true)
225             .setResponse(Any.pack(expectedResponse))
226             .build();
227     mockService.addResponse(resultOperation);
228 
229     UpdateApplicationRequest request =
230         UpdateApplicationRequest.newBuilder()
231             .setName("apps/app-5480")
232             .setApplication(Application.newBuilder().build())
233             .setUpdateMask(FieldMask.newBuilder().build())
234             .build();
235 
236     Application actualResponse = client.updateApplicationAsync(request).get();
237     Assert.assertEquals(expectedResponse, actualResponse);
238 
239     List<String> actualRequests = mockService.getRequestPaths();
240     Assert.assertEquals(1, actualRequests.size());
241 
242     String apiClientHeaderKey =
243         mockService
244             .getRequestHeaders()
245             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
246             .iterator()
247             .next();
248     Assert.assertTrue(
249         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
250             .matcher(apiClientHeaderKey)
251             .matches());
252   }
253 
254   @Test
updateApplicationExceptionTest()255   public void updateApplicationExceptionTest() throws Exception {
256     ApiException exception =
257         ApiExceptionFactory.createException(
258             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
259     mockService.addException(exception);
260 
261     try {
262       UpdateApplicationRequest request =
263           UpdateApplicationRequest.newBuilder()
264               .setName("apps/app-5480")
265               .setApplication(Application.newBuilder().build())
266               .setUpdateMask(FieldMask.newBuilder().build())
267               .build();
268       client.updateApplicationAsync(request).get();
269       Assert.fail("No exception raised");
270     } catch (ExecutionException e) {
271     }
272   }
273 
274   @Test
repairApplicationTest()275   public void repairApplicationTest() throws Exception {
276     Application expectedResponse =
277         Application.newBuilder()
278             .setName("name3373707")
279             .setId("id3355")
280             .addAllDispatchRules(new ArrayList<UrlDispatchRule>())
281             .setAuthDomain("authDomain1560526988")
282             .setLocationId("locationId1541836720")
283             .setCodeBucket("codeBucket-1407386057")
284             .setDefaultCookieExpiration(Duration.newBuilder().build())
285             .setDefaultHostname("defaultHostname1698284948")
286             .setDefaultBucket("defaultBucket487561099")
287             .setServiceAccount("serviceAccount1079137720")
288             .setIap(Application.IdentityAwareProxy.newBuilder().build())
289             .setGcrDomain("gcrDomain-595843206")
290             .setFeatureSettings(Application.FeatureSettings.newBuilder().build())
291             .build();
292     Operation resultOperation =
293         Operation.newBuilder()
294             .setName("repairApplicationTest")
295             .setDone(true)
296             .setResponse(Any.pack(expectedResponse))
297             .build();
298     mockService.addResponse(resultOperation);
299 
300     RepairApplicationRequest request =
301         RepairApplicationRequest.newBuilder().setName("apps/app-5480").build();
302 
303     Application actualResponse = client.repairApplicationAsync(request).get();
304     Assert.assertEquals(expectedResponse, actualResponse);
305 
306     List<String> actualRequests = mockService.getRequestPaths();
307     Assert.assertEquals(1, actualRequests.size());
308 
309     String apiClientHeaderKey =
310         mockService
311             .getRequestHeaders()
312             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
313             .iterator()
314             .next();
315     Assert.assertTrue(
316         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
317             .matcher(apiClientHeaderKey)
318             .matches());
319   }
320 
321   @Test
repairApplicationExceptionTest()322   public void repairApplicationExceptionTest() throws Exception {
323     ApiException exception =
324         ApiExceptionFactory.createException(
325             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
326     mockService.addException(exception);
327 
328     try {
329       RepairApplicationRequest request =
330           RepairApplicationRequest.newBuilder().setName("apps/app-5480").build();
331       client.repairApplicationAsync(request).get();
332       Assert.fail("No exception raised");
333     } catch (ExecutionException e) {
334     }
335   }
336 }
337