• 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.DomainMappingsClient.ListDomainMappingsPagedResponse;
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.HttpJsonDomainMappingsStub;
31 import com.google.common.collect.Lists;
32 import com.google.longrunning.Operation;
33 import com.google.protobuf.Any;
34 import com.google.protobuf.Empty;
35 import com.google.protobuf.FieldMask;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
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 DomainMappingsClientHttpJsonTest {
51   private static MockHttpService mockService;
52   private static DomainMappingsClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonDomainMappingsStub.getMethodDescriptors(),
59             DomainMappingsSettings.getDefaultEndpoint());
60     DomainMappingsSettings settings =
61         DomainMappingsSettings.newHttpJsonBuilder()
62             .setTransportChannelProvider(
63                 DomainMappingsSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = DomainMappingsClient.create(settings);
69   }
70 
71   @AfterClass
stopServer()72   public static void stopServer() {
73     client.close();
74   }
75 
76   @Before
setUp()77   public void setUp() {}
78 
79   @After
tearDown()80   public void tearDown() throws Exception {
81     mockService.reset();
82   }
83 
84   @Test
listDomainMappingsTest()85   public void listDomainMappingsTest() throws Exception {
86     DomainMapping responsesElement = DomainMapping.newBuilder().build();
87     ListDomainMappingsResponse expectedResponse =
88         ListDomainMappingsResponse.newBuilder()
89             .setNextPageToken("")
90             .addAllDomainMappings(Arrays.asList(responsesElement))
91             .build();
92     mockService.addResponse(expectedResponse);
93 
94     ListDomainMappingsRequest request =
95         ListDomainMappingsRequest.newBuilder()
96             .setParent("apps/app-3559")
97             .setPageSize(883849137)
98             .setPageToken("pageToken873572522")
99             .build();
100 
101     ListDomainMappingsPagedResponse pagedListResponse = client.listDomainMappings(request);
102 
103     List<DomainMapping> resources = Lists.newArrayList(pagedListResponse.iterateAll());
104 
105     Assert.assertEquals(1, resources.size());
106     Assert.assertEquals(expectedResponse.getDomainMappingsList().get(0), resources.get(0));
107 
108     List<String> actualRequests = mockService.getRequestPaths();
109     Assert.assertEquals(1, actualRequests.size());
110 
111     String apiClientHeaderKey =
112         mockService
113             .getRequestHeaders()
114             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
115             .iterator()
116             .next();
117     Assert.assertTrue(
118         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
119             .matcher(apiClientHeaderKey)
120             .matches());
121   }
122 
123   @Test
listDomainMappingsExceptionTest()124   public void listDomainMappingsExceptionTest() throws Exception {
125     ApiException exception =
126         ApiExceptionFactory.createException(
127             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
128     mockService.addException(exception);
129 
130     try {
131       ListDomainMappingsRequest request =
132           ListDomainMappingsRequest.newBuilder()
133               .setParent("apps/app-3559")
134               .setPageSize(883849137)
135               .setPageToken("pageToken873572522")
136               .build();
137       client.listDomainMappings(request);
138       Assert.fail("No exception raised");
139     } catch (InvalidArgumentException e) {
140       // Expected exception.
141     }
142   }
143 
144   @Test
getDomainMappingTest()145   public void getDomainMappingTest() throws Exception {
146     DomainMapping expectedResponse =
147         DomainMapping.newBuilder()
148             .setName("name3373707")
149             .setId("id3355")
150             .setSslSettings(SslSettings.newBuilder().build())
151             .addAllResourceRecords(new ArrayList<ResourceRecord>())
152             .build();
153     mockService.addResponse(expectedResponse);
154 
155     GetDomainMappingRequest request =
156         GetDomainMappingRequest.newBuilder()
157             .setName("apps/app-1227/domainMappings/domainMapping-1227")
158             .build();
159 
160     DomainMapping actualResponse = client.getDomainMapping(request);
161     Assert.assertEquals(expectedResponse, actualResponse);
162 
163     List<String> actualRequests = mockService.getRequestPaths();
164     Assert.assertEquals(1, actualRequests.size());
165 
166     String apiClientHeaderKey =
167         mockService
168             .getRequestHeaders()
169             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
170             .iterator()
171             .next();
172     Assert.assertTrue(
173         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
174             .matcher(apiClientHeaderKey)
175             .matches());
176   }
177 
178   @Test
getDomainMappingExceptionTest()179   public void getDomainMappingExceptionTest() throws Exception {
180     ApiException exception =
181         ApiExceptionFactory.createException(
182             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
183     mockService.addException(exception);
184 
185     try {
186       GetDomainMappingRequest request =
187           GetDomainMappingRequest.newBuilder()
188               .setName("apps/app-1227/domainMappings/domainMapping-1227")
189               .build();
190       client.getDomainMapping(request);
191       Assert.fail("No exception raised");
192     } catch (InvalidArgumentException e) {
193       // Expected exception.
194     }
195   }
196 
197   @Test
createDomainMappingTest()198   public void createDomainMappingTest() throws Exception {
199     DomainMapping expectedResponse =
200         DomainMapping.newBuilder()
201             .setName("name3373707")
202             .setId("id3355")
203             .setSslSettings(SslSettings.newBuilder().build())
204             .addAllResourceRecords(new ArrayList<ResourceRecord>())
205             .build();
206     Operation resultOperation =
207         Operation.newBuilder()
208             .setName("createDomainMappingTest")
209             .setDone(true)
210             .setResponse(Any.pack(expectedResponse))
211             .build();
212     mockService.addResponse(resultOperation);
213 
214     CreateDomainMappingRequest request =
215         CreateDomainMappingRequest.newBuilder()
216             .setParent("apps/app-3559")
217             .setDomainMapping(DomainMapping.newBuilder().build())
218             .setOverrideStrategy(DomainOverrideStrategy.forNumber(0))
219             .build();
220 
221     DomainMapping actualResponse = client.createDomainMappingAsync(request).get();
222     Assert.assertEquals(expectedResponse, actualResponse);
223 
224     List<String> actualRequests = mockService.getRequestPaths();
225     Assert.assertEquals(1, actualRequests.size());
226 
227     String apiClientHeaderKey =
228         mockService
229             .getRequestHeaders()
230             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
231             .iterator()
232             .next();
233     Assert.assertTrue(
234         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
235             .matcher(apiClientHeaderKey)
236             .matches());
237   }
238 
239   @Test
createDomainMappingExceptionTest()240   public void createDomainMappingExceptionTest() throws Exception {
241     ApiException exception =
242         ApiExceptionFactory.createException(
243             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
244     mockService.addException(exception);
245 
246     try {
247       CreateDomainMappingRequest request =
248           CreateDomainMappingRequest.newBuilder()
249               .setParent("apps/app-3559")
250               .setDomainMapping(DomainMapping.newBuilder().build())
251               .setOverrideStrategy(DomainOverrideStrategy.forNumber(0))
252               .build();
253       client.createDomainMappingAsync(request).get();
254       Assert.fail("No exception raised");
255     } catch (ExecutionException e) {
256     }
257   }
258 
259   @Test
updateDomainMappingTest()260   public void updateDomainMappingTest() throws Exception {
261     DomainMapping expectedResponse =
262         DomainMapping.newBuilder()
263             .setName("name3373707")
264             .setId("id3355")
265             .setSslSettings(SslSettings.newBuilder().build())
266             .addAllResourceRecords(new ArrayList<ResourceRecord>())
267             .build();
268     Operation resultOperation =
269         Operation.newBuilder()
270             .setName("updateDomainMappingTest")
271             .setDone(true)
272             .setResponse(Any.pack(expectedResponse))
273             .build();
274     mockService.addResponse(resultOperation);
275 
276     UpdateDomainMappingRequest request =
277         UpdateDomainMappingRequest.newBuilder()
278             .setName("apps/app-1227/domainMappings/domainMapping-1227")
279             .setDomainMapping(DomainMapping.newBuilder().build())
280             .setUpdateMask(FieldMask.newBuilder().build())
281             .build();
282 
283     DomainMapping actualResponse = client.updateDomainMappingAsync(request).get();
284     Assert.assertEquals(expectedResponse, actualResponse);
285 
286     List<String> actualRequests = mockService.getRequestPaths();
287     Assert.assertEquals(1, actualRequests.size());
288 
289     String apiClientHeaderKey =
290         mockService
291             .getRequestHeaders()
292             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
293             .iterator()
294             .next();
295     Assert.assertTrue(
296         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
297             .matcher(apiClientHeaderKey)
298             .matches());
299   }
300 
301   @Test
updateDomainMappingExceptionTest()302   public void updateDomainMappingExceptionTest() throws Exception {
303     ApiException exception =
304         ApiExceptionFactory.createException(
305             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
306     mockService.addException(exception);
307 
308     try {
309       UpdateDomainMappingRequest request =
310           UpdateDomainMappingRequest.newBuilder()
311               .setName("apps/app-1227/domainMappings/domainMapping-1227")
312               .setDomainMapping(DomainMapping.newBuilder().build())
313               .setUpdateMask(FieldMask.newBuilder().build())
314               .build();
315       client.updateDomainMappingAsync(request).get();
316       Assert.fail("No exception raised");
317     } catch (ExecutionException e) {
318     }
319   }
320 
321   @Test
deleteDomainMappingTest()322   public void deleteDomainMappingTest() throws Exception {
323     Empty expectedResponse = Empty.newBuilder().build();
324     Operation resultOperation =
325         Operation.newBuilder()
326             .setName("deleteDomainMappingTest")
327             .setDone(true)
328             .setResponse(Any.pack(expectedResponse))
329             .build();
330     mockService.addResponse(resultOperation);
331 
332     DeleteDomainMappingRequest request =
333         DeleteDomainMappingRequest.newBuilder()
334             .setName("apps/app-1227/domainMappings/domainMapping-1227")
335             .build();
336 
337     client.deleteDomainMappingAsync(request).get();
338 
339     List<String> actualRequests = mockService.getRequestPaths();
340     Assert.assertEquals(1, actualRequests.size());
341 
342     String apiClientHeaderKey =
343         mockService
344             .getRequestHeaders()
345             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
346             .iterator()
347             .next();
348     Assert.assertTrue(
349         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
350             .matcher(apiClientHeaderKey)
351             .matches());
352   }
353 
354   @Test
deleteDomainMappingExceptionTest()355   public void deleteDomainMappingExceptionTest() throws Exception {
356     ApiException exception =
357         ApiExceptionFactory.createException(
358             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
359     mockService.addException(exception);
360 
361     try {
362       DeleteDomainMappingRequest request =
363           DeleteDomainMappingRequest.newBuilder()
364               .setName("apps/app-1227/domainMappings/domainMapping-1227")
365               .build();
366       client.deleteDomainMappingAsync(request).get();
367       Assert.fail("No exception raised");
368     } catch (ExecutionException e) {
369     }
370   }
371 }
372