972fc666cffac9475a03bb85ff49e1692d866649
[policy/common.git] /
1 /*-
2  * ============LICENSE_START=======================================================
3  * ONAP
4  * ================================================================================
5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6  * ================================================================================
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  * ============LICENSE_END=========================================================
19  */
20
21 package org.onap.policy.common.endpoints.http.server.test;
22
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertTrue;
26
27 import com.google.gson.Gson;
28 import java.io.BufferedReader;
29 import java.io.IOException;
30 import java.io.InputStreamReader;
31 import java.net.ConnectException;
32 import java.net.HttpURLConnection;
33 import java.net.MalformedURLException;
34 import java.net.URL;
35 import java.net.URLConnection;
36 import java.util.UUID;
37 import org.apache.commons.io.IOUtils;
38 import org.junit.AfterClass;
39 import org.junit.Before;
40 import org.junit.Test;
41 import org.onap.policy.common.endpoints.http.server.HttpServletServer;
42 import org.onap.policy.common.utils.gson.GsonTestUtils;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45
46 /**
47  * HttpServletServer JUNIT tests.
48  */
49 public class HttpServerTest {
50
51     /**
52      * Logger.
53      */
54     private static Logger logger = LoggerFactory.getLogger(HttpServerTest.class);
55
56     private static final String LOCALHOST_PREFIX = "http://localhost:";
57
58     private static final Gson gson = new Gson();
59
60     /**
61      * Server port.  Incremented by 10 with each test.
62      */
63     private static int port = 5608;
64
65     private String portUrl;
66
67     /**
68      * Increments the port number, clears the servers, and resets the providers.
69      */
70     @Before
71     public void setUp() {
72         port += 10;
73         portUrl = LOCALHOST_PREFIX + port;
74
75         HttpServletServer.factory.destroy();
76
77         MyJacksonProvider.resetSome();
78         MyGsonProvider.resetSome();
79     }
80
81     @AfterClass
82     public static void tearDownAfterClass() {
83         HttpServletServer.factory.destroy();
84     }
85
86     @Test
87     public void testDefaultPackageServer() throws Exception {
88         logger.info("-- testDefaultPackageServer() --");
89
90         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
91         server.addServletPackage("/*", this.getClass().getPackage().getName());
92         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
93         server.waitedStart(5000);
94
95         assertTrue(HttpServletServer.factory.get(port).isAlive());
96
97         RestEchoReqResp request = new RestEchoReqResp();
98         request.setRequestId(100);
99         request.setText("some text");
100         String reqText = gson.toJson(request);
101
102         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
103         assertEquals(reqText, response);
104     }
105
106     @Test
107     public void testJacksonPackageServer() throws Exception {
108         logger.info("-- testJacksonPackageServer() --");
109
110         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
111
112         server.setSerializationProvider(MyJacksonProvider.class.getCanonicalName());
113         server.addServletPackage("/*", this.getClass().getPackage().getName());
114         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
115         server.waitedStart(5000);
116
117         assertTrue(HttpServletServer.factory.get(port).isAlive());
118
119         RestEchoReqResp request = new RestEchoReqResp();
120         request.setRequestId(100);
121         request.setText("some text");
122         String reqText = gson.toJson(request);
123
124         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
125         assertEquals(reqText, response);
126
127         assertTrue(MyJacksonProvider.hasReadSome());
128         assertTrue(MyJacksonProvider.hasWrittenSome());
129
130         assertFalse(MyGsonProvider.hasReadSome());
131         assertFalse(MyGsonProvider.hasWrittenSome());
132     }
133
134     @Test
135     public void testGsonPackageServer() throws Exception {
136         logger.info("-- testGsonPackageServer() --");
137
138         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
139
140         server.setSerializationProvider(MyGsonProvider.class.getCanonicalName());
141         server.addServletPackage("/*", this.getClass().getPackage().getName());
142         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
143         server.waitedStart(5000);
144
145         assertTrue(HttpServletServer.factory.get(port).isAlive());
146
147         RestEchoReqResp request = new RestEchoReqResp();
148         request.setRequestId(100);
149         request.setText("some text");
150         String reqText = gson.toJson(request);
151
152         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
153         assertEquals(reqText, response);
154
155         assertTrue(MyGsonProvider.hasReadSome());
156         assertTrue(MyGsonProvider.hasWrittenSome());
157
158         assertFalse(MyJacksonProvider.hasReadSome());
159         assertFalse(MyJacksonProvider.hasWrittenSome());
160     }
161
162     @Test
163     public void testDefaultClassServer() throws Exception {
164         logger.info("-- testDefaultClassServer() --");
165
166         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
167         server.addServletClass("/*", RestEchoService.class.getCanonicalName());
168         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
169         server.waitedStart(5000);
170
171         assertTrue(HttpServletServer.factory.get(port).isAlive());
172
173         RestEchoReqResp request = new RestEchoReqResp();
174         request.setRequestId(100);
175         request.setText("some text");
176         String reqText = gson.toJson(request);
177
178         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
179         assertEquals(reqText, response);
180     }
181
182     @Test
183     public void testJacksonClassServer() throws Exception {
184         logger.info("-- testJacksonClassServer() --");
185
186         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
187         server.setSerializationProvider(MyJacksonProvider.class.getCanonicalName());
188         server.addServletClass("/*", RestEchoService.class.getCanonicalName());
189         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
190         server.waitedStart(5000);
191
192         assertTrue(HttpServletServer.factory.get(port).isAlive());
193
194         RestEchoReqResp request = new RestEchoReqResp();
195         request.setRequestId(100);
196         request.setText("some text");
197         String reqText = gson.toJson(request);
198
199         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
200         assertEquals(reqText, response);
201
202         assertTrue(MyJacksonProvider.hasReadSome());
203         assertTrue(MyJacksonProvider.hasWrittenSome());
204
205         assertFalse(MyGsonProvider.hasReadSome());
206         assertFalse(MyGsonProvider.hasWrittenSome());
207     }
208
209     @Test
210     public void testGsonClassServer() throws Exception {
211         logger.info("-- testGsonClassServer() --");
212
213         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
214         server.setSerializationProvider(MyGsonProvider.class.getCanonicalName());
215         server.addServletClass("/*", RestEchoService.class.getCanonicalName());
216         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
217         server.waitedStart(5000);
218
219         assertTrue(HttpServletServer.factory.get(port).isAlive());
220
221         RestEchoReqResp request = new RestEchoReqResp();
222         request.setRequestId(100);
223         request.setText("some text");
224         String reqText = gson.toJson(request);
225
226         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
227         assertEquals(reqText, response);
228
229         assertTrue(MyGsonProvider.hasReadSome());
230         assertTrue(MyGsonProvider.hasWrittenSome());
231
232         assertFalse(MyJacksonProvider.hasReadSome());
233         assertFalse(MyJacksonProvider.hasWrittenSome());
234     }
235
236     @Test
237     public void testSerialize() {
238         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
239         server.addServletPackage("/*", this.getClass().getPackage().getName());
240         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
241
242         // ensure we can serialize the server
243         new GsonTestUtils().compareGson(server, HttpServerTest.class);
244     }
245
246     @Test
247     public void testSingleServer() throws Exception {
248         logger.info("-- testSingleServer() --");
249
250         HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
251         server.addServletPackage("/*", this.getClass().getPackage().getName());
252         server.addFilterClass("/*", TestFilter.class.getCanonicalName());
253         server.waitedStart(5000);
254
255         assertTrue(HttpServletServer.factory.get(port).isAlive());
256         assertFalse(HttpServletServer.factory.get(port).isAaf());
257
258         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
259         assertTrue("hello".equals(response));
260
261         response = null;
262         try {
263             response = http(HttpServletServer.factory.get(port), portUrl + "/swagger.json");
264         } catch (IOException e) {
265             // Expected
266         }
267         assertTrue(response == null);
268
269         response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello?block=true");
270         assertEquals("FILTERED", response);
271
272         assertTrue(HttpServletServer.factory.get(port).isAlive());
273         assertEquals(1, HttpServletServer.factory.inventory().size());
274
275         server.setAafAuthentication("/*");
276         assertTrue(HttpServletServer.factory.get(port).isAaf());
277
278         HttpServletServer.factory.destroy(port);
279         assertEquals(0, HttpServletServer.factory.inventory().size());
280     }
281
282     @Test
283     public void testMultipleServers() throws Exception {
284         logger.info("-- testMultipleServers() --");
285
286         HttpServletServer server1 = HttpServletServer.factory.build("echo-1", false,"localhost", port, "/", true, true);
287         server1.addServletPackage("/*", this.getClass().getPackage().getName());
288         server1.waitedStart(5000);
289
290         int port2 = port + 1;
291
292         HttpServletServer server2 = HttpServletServer.factory.build("echo-2", "localhost", port2, "/", false, true);
293         server2.addServletPackage("/*", this.getClass().getPackage().getName());
294         server2.waitedStart(5000);
295
296         assertTrue(HttpServletServer.factory.get(port).isAlive());
297         assertTrue(HttpServletServer.factory.get(port2).isAlive());
298
299         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
300         assertTrue("hello".equals(response));
301
302         response = http(HttpServletServer.factory.get(port), portUrl + "/swagger.json");
303         assertTrue(response != null);
304
305         response = http(HttpServletServer.factory.get(port2), LOCALHOST_PREFIX + port2 + "/junit/echo/hello");
306         assertTrue("hello".equals(response));
307
308         response = null;
309         try {
310             response = http(HttpServletServer.factory.get(port2), LOCALHOST_PREFIX + port2 + "/swagger.json");
311         } catch (IOException e) {
312             // Expected
313         }
314         assertTrue(response == null);
315
316         HttpServletServer.factory.destroy();
317         assertTrue(HttpServletServer.factory.inventory().size() == 0);
318     }
319
320     @Test
321     public void testMultiServicePackage() throws Exception {
322         logger.info("-- testMultiServicePackage() --");
323
324         String randomName = UUID.randomUUID().toString();
325
326         HttpServletServer server = HttpServletServer.factory.build(randomName, "localhost", port, "/", false, true);
327         server.addServletPackage("/*", this.getClass().getPackage().getName());
328         server.waitedStart(5000);
329
330         assertTrue(HttpServletServer.factory.get(port).isAlive());
331
332         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
333         assertTrue("hello".equals(response));
334
335         response = http(HttpServletServer.factory.get(port), portUrl + "/junit/endpoints/http/servers");
336         assertTrue(response.contains(randomName));
337
338         HttpServletServer.factory.destroy();
339         assertTrue(HttpServletServer.factory.inventory().size() == 0);
340     }
341
342     @Test
343     public void testServiceClass() throws Exception {
344         logger.info("-- testServiceClass() --");
345         String randomName = UUID.randomUUID().toString();
346
347         HttpServletServer server = HttpServletServer.factory.build(randomName, "localhost", port, "/", false, true);
348         server.addServletClass("/*", RestEchoService.class.getCanonicalName());
349         server.waitedStart(5000);
350
351         assertTrue(HttpServletServer.factory.get(port).isAlive());
352
353         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
354         assertTrue("hello".equals(response));
355
356         HttpServletServer.factory.destroy();
357         assertTrue(HttpServletServer.factory.inventory().size() == 0);
358     }
359
360     @Test
361     public void testMultiServiceClass() throws Exception {
362         logger.info("-- testMultiServiceClass() --");
363
364         String randomName = UUID.randomUUID().toString();
365
366         HttpServletServer server = HttpServletServer.factory.build(randomName, "localhost", port, "/", false, true);
367         server.addServletClass("/*", RestEchoService.class.getCanonicalName());
368         server.addServletClass("/*", RestEndpoints.class.getCanonicalName());
369         server.waitedStart(5000);
370
371         assertTrue(HttpServletServer.factory.get(port).isAlive());
372
373         String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
374         assertTrue("hello".equals(response));
375
376         response = http(HttpServletServer.factory.get(port), portUrl + "/junit/endpoints/http/servers");
377         assertTrue(response.contains(randomName));
378
379         HttpServletServer.factory.destroy();
380         assertTrue(HttpServletServer.factory.inventory().size() == 0);
381     }
382
383     /**
384      * performs an http request.
385      *
386      * @throws MalformedURLException make sure URL is good
387      * @throws IOException thrown is IO exception occurs
388      * @throws InterruptedException thrown if thread interrupted occurs
389      */
390     protected String http(HttpServletServer server, String urlString)
391             throws MalformedURLException, IOException, InterruptedException {
392         URL url = new URL(urlString);
393         String response = null;
394         int numRetries = 1;
395         int maxNumberRetries = 5;
396         while (numRetries <= maxNumberRetries) {
397             try {
398                 URLConnection conn = url.openConnection();
399                 response = response(conn);
400                 break;
401             } catch (ConnectException e) {
402                 logger.warn("http server {} @ {} ({}) - cannot connect yet ..", server, urlString, numRetries, e);
403                 numRetries++;
404                 Thread.sleep(10000L);
405             } catch (Exception e) {
406                 throw e;
407             }
408         }
409
410         return response;
411     }
412
413     /**
414      * Performs an http request.
415      *
416      * @throws MalformedURLException make sure URL is good
417      * @throws IOException thrown is IO exception occurs
418      * @throws InterruptedException thrown if thread interrupted occurs
419      */
420     protected String http(HttpServletServer server, String urlString, String post)
421             throws MalformedURLException, IOException, InterruptedException {
422         URL url = new URL(urlString);
423         String response = null;
424         int numRetries = 1;
425         int maxNumberRetries = 5;
426         while (numRetries <= maxNumberRetries) {
427             try {
428                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
429                 conn.setRequestMethod("POST");
430                 conn.setDoOutput(true);
431                 conn.setRequestProperty("Content-Type", "application/json");
432                 IOUtils.write(post, conn.getOutputStream());
433                 response = response(conn);
434                 break;
435             } catch (ConnectException e) {
436                 logger.warn("http server {} @ {} ({}) - cannot connect yet ..", server, urlString, numRetries, e);
437                 numRetries++;
438                 Thread.sleep(10000L);
439             } catch (Exception e) {
440                 logger.error("http error", e);
441                 throw e;
442             }
443         }
444
445         return response;
446     }
447
448     /**
449      * gets http response.
450      *
451      * @param conn connection from which to read
452      *
453      * @throws IOException if an I/O error occurs
454      */
455     protected String response(URLConnection conn) throws IOException {
456         String response = "";
457         try (BufferedReader ioReader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
458             String line;
459             while ((line = ioReader.readLine()) != null) {
460                 response += line;
461             }
462         }
463         return response;
464     }
465
466 }