2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.onap.policy.common.endpoints.http.server.test;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertTrue;
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.HttpURLConnection;
32 import java.net.MalformedURLException;
34 import java.net.URLConnection;
35 import java.util.UUID;
36 import org.apache.commons.io.IOUtils;
37 import org.junit.AfterClass;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.onap.policy.common.endpoints.http.server.HttpServletServer;
41 import org.onap.policy.common.utils.gson.GsonTestUtils;
42 import org.onap.policy.common.utils.network.NetworkUtil;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
47 * HttpServletServer JUNIT tests.
49 public class HttpServerTest {
50 private static final String LOCALHOST = "localhost";
51 private static final String SWAGGER_JSON = "/swagger.json";
52 private static final String JUNIT_ECHO_HELLO = "/junit/echo/hello";
53 private static final String JUNIT_ECHO_FULL_REQUEST = "/junit/echo/full/request";
54 private static final String SOME_TEXT = "some text";
55 private static final String HELLO = "hello";
60 private static Logger logger = LoggerFactory.getLogger(HttpServerTest.class);
62 private static final String LOCALHOST_PREFIX = "http://localhost:";
64 private static final Gson gson = new Gson();
67 * Server port. Incremented by 10 with each test.
69 private static int port = 5608;
71 private String portUrl;
74 * Increments the port number, clears the servers, and resets the providers.
79 portUrl = LOCALHOST_PREFIX + port;
81 HttpServletServer.factory.destroy();
83 MyJacksonProvider.resetSome();
84 MyGsonProvider.resetSome();
88 public static void tearDownAfterClass() {
89 HttpServletServer.factory.destroy();
93 public void testDefaultPackageServer() throws Exception {
94 logger.info("-- testDefaultPackageServer() --");
96 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
97 server.addServletPackage("/*", this.getClass().getPackage().getName());
98 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
99 server.waitedStart(5000);
101 assertTrue(HttpServletServer.factory.get(port).isAlive());
103 RestEchoReqResp request = new RestEchoReqResp();
104 request.setRequestId(100);
105 request.setText(SOME_TEXT);
106 String reqText = gson.toJson(request);
108 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
109 assertEquals(reqText, response);
113 public void testJacksonPackageServer() throws Exception {
114 logger.info("-- testJacksonPackageServer() --");
116 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
118 server.setSerializationProvider(MyJacksonProvider.class.getCanonicalName());
119 server.addServletPackage("/*", this.getClass().getPackage().getName());
120 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
121 server.waitedStart(5000);
123 assertTrue(HttpServletServer.factory.get(port).isAlive());
125 RestEchoReqResp request = new RestEchoReqResp();
126 request.setRequestId(100);
127 request.setText(SOME_TEXT);
128 String reqText = gson.toJson(request);
130 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
131 assertEquals(reqText, response);
133 assertTrue(MyJacksonProvider.hasReadSome());
134 assertTrue(MyJacksonProvider.hasWrittenSome());
136 assertFalse(MyGsonProvider.hasReadSome());
137 assertFalse(MyGsonProvider.hasWrittenSome());
141 public void testGsonPackageServer() throws Exception {
142 logger.info("-- testGsonPackageServer() --");
144 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
146 server.setSerializationProvider(MyGsonProvider.class.getCanonicalName());
147 server.addServletPackage("/*", this.getClass().getPackage().getName());
148 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
149 server.waitedStart(5000);
151 assertTrue(HttpServletServer.factory.get(port).isAlive());
153 RestEchoReqResp request = new RestEchoReqResp();
154 request.setRequestId(100);
155 request.setText(SOME_TEXT);
156 String reqText = gson.toJson(request);
158 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
159 assertEquals(reqText, response);
161 assertTrue(MyGsonProvider.hasReadSome());
162 assertTrue(MyGsonProvider.hasWrittenSome());
164 assertFalse(MyJacksonProvider.hasReadSome());
165 assertFalse(MyJacksonProvider.hasWrittenSome());
169 public void testDefaultClassServer() throws Exception {
170 logger.info("-- testDefaultClassServer() --");
172 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
173 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
174 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
175 server.waitedStart(5000);
177 assertTrue(HttpServletServer.factory.get(port).isAlive());
179 RestEchoReqResp request = new RestEchoReqResp();
180 request.setRequestId(100);
181 request.setText(SOME_TEXT);
182 String reqText = gson.toJson(request);
184 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
185 assertEquals(reqText, response);
189 public void testJacksonClassServer() throws Exception {
190 logger.info("-- testJacksonClassServer() --");
192 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
193 server.setSerializationProvider(MyJacksonProvider.class.getCanonicalName());
194 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
195 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
196 server.waitedStart(5000);
198 assertTrue(HttpServletServer.factory.get(port).isAlive());
200 RestEchoReqResp request = new RestEchoReqResp();
201 request.setRequestId(100);
202 request.setText(SOME_TEXT);
203 String reqText = gson.toJson(request);
205 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
206 assertEquals(reqText, response);
208 assertTrue(MyJacksonProvider.hasReadSome());
209 assertTrue(MyJacksonProvider.hasWrittenSome());
211 assertFalse(MyGsonProvider.hasReadSome());
212 assertFalse(MyGsonProvider.hasWrittenSome());
216 public void testGsonClassServer() throws Exception {
217 logger.info("-- testGsonClassServer() --");
219 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
220 server.setSerializationProvider(MyGsonProvider.class.getCanonicalName());
221 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
222 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
223 server.waitedStart(5000);
225 assertTrue(HttpServletServer.factory.get(port).isAlive());
227 RestEchoReqResp request = new RestEchoReqResp();
228 request.setRequestId(100);
229 request.setText(SOME_TEXT);
230 String reqText = gson.toJson(request);
232 String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
233 assertEquals(reqText, response);
235 assertTrue(MyGsonProvider.hasReadSome());
236 assertTrue(MyGsonProvider.hasWrittenSome());
238 assertFalse(MyJacksonProvider.hasReadSome());
239 assertFalse(MyJacksonProvider.hasWrittenSome());
243 public void testSerialize() {
244 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
245 server.addServletPackage("/*", this.getClass().getPackage().getName());
246 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
248 // ensure we can serialize the server
249 new GsonTestUtils().compareGson(server, HttpServerTest.class);
253 public void testSingleServer() throws Exception {
254 logger.info("-- testSingleServer() --");
256 HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
257 server.addServletPackage("/*", this.getClass().getPackage().getName());
258 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
259 server.waitedStart(5000);
261 assertTrue(HttpServletServer.factory.get(port).isAlive());
262 assertFalse(HttpServletServer.factory.get(port).isAaf());
264 String response = http(portUrl + JUNIT_ECHO_HELLO);
265 assertEquals(HELLO, response);
269 response = http(portUrl + SWAGGER_JSON);
270 } catch (IOException e) {
273 assertTrue(response == null);
275 response = http(portUrl + "/junit/echo/hello?block=true");
276 assertEquals("FILTERED", response);
278 assertTrue(HttpServletServer.factory.get(port).isAlive());
279 assertEquals(1, HttpServletServer.factory.inventory().size());
281 server.setAafAuthentication("/*");
282 assertTrue(HttpServletServer.factory.get(port).isAaf());
284 HttpServletServer.factory.destroy(port);
285 assertEquals(0, HttpServletServer.factory.inventory().size());
289 public void testMultipleServers() throws Exception {
290 logger.info("-- testMultipleServers() --");
292 HttpServletServer server1 = HttpServletServer.factory.build("echo-1", false,LOCALHOST, port, "/", true, true);
293 server1.addServletPackage("/*", this.getClass().getPackage().getName());
294 server1.waitedStart(5000);
296 int port2 = port + 1;
298 HttpServletServer server2 = HttpServletServer.factory.build("echo-2", LOCALHOST, port2, "/", false, true);
299 server2.addServletPackage("/*", this.getClass().getPackage().getName());
300 server2.waitedStart(5000);
302 assertTrue(HttpServletServer.factory.get(port).isAlive());
303 assertTrue(HttpServletServer.factory.get(port2).isAlive());
305 String response = http(portUrl + JUNIT_ECHO_HELLO);
306 assertTrue(HELLO.equals(response));
308 response = http(portUrl + SWAGGER_JSON);
309 assertTrue(response != null);
311 response = http(LOCALHOST_PREFIX + port2 + JUNIT_ECHO_HELLO);
312 assertTrue(HELLO.equals(response));
316 response = http(LOCALHOST_PREFIX + port2 + SWAGGER_JSON);
317 } catch (IOException e) {
320 assertTrue(response == null);
322 HttpServletServer.factory.destroy();
323 assertTrue(HttpServletServer.factory.inventory().isEmpty());
327 public void testMultiServicePackage() throws Exception {
328 logger.info("-- testMultiServicePackage() --");
330 String randomName = UUID.randomUUID().toString();
332 HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
333 server.addServletPackage("/*", this.getClass().getPackage().getName());
334 server.waitedStart(5000);
336 assertTrue(HttpServletServer.factory.get(port).isAlive());
338 String response = http(portUrl + JUNIT_ECHO_HELLO);
339 assertTrue(HELLO.equals(response));
341 response = http(portUrl + "/junit/endpoints/http/servers");
342 assertTrue(response.contains(randomName));
344 HttpServletServer.factory.destroy();
345 assertTrue(HttpServletServer.factory.inventory().isEmpty());
349 public void testServiceClass() throws Exception {
350 logger.info("-- testServiceClass() --");
351 String randomName = UUID.randomUUID().toString();
353 HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
354 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
355 server.waitedStart(5000);
357 assertTrue(HttpServletServer.factory.get(port).isAlive());
359 String response = http(portUrl + JUNIT_ECHO_HELLO);
360 assertTrue(HELLO.equals(response));
362 HttpServletServer.factory.destroy();
363 assertTrue(HttpServletServer.factory.inventory().isEmpty());
367 public void testMultiServiceClass() throws Exception {
368 logger.info("-- testMultiServiceClass() --");
370 String randomName = UUID.randomUUID().toString();
372 HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
373 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
374 server.addServletClass("/*", RestEndpoints.class.getCanonicalName());
375 server.waitedStart(5000);
377 assertTrue(HttpServletServer.factory.get(port).isAlive());
379 String response = http(portUrl + JUNIT_ECHO_HELLO);
380 assertTrue(HELLO.equals(response));
382 response = http(portUrl + "/junit/endpoints/http/servers");
383 assertTrue(response.contains(randomName));
385 HttpServletServer.factory.destroy();
386 assertTrue(HttpServletServer.factory.inventory().isEmpty());
390 * performs an http request.
392 * @throws MalformedURLException make sure URL is good
393 * @throws IOException thrown is IO exception occurs
394 * @throws InterruptedException thrown if thread interrupted occurs
396 private String http(String urlString)
397 throws IOException, InterruptedException {
398 URL url = new URL(urlString);
399 if (!NetworkUtil.isTcpPortOpen(url.getHost(), url.getPort(), 25, 2)) {
400 throw new IllegalStateException("port never opened: " + url);
402 return response(url.openConnection());
406 * Performs an http request.
408 * @throws MalformedURLException make sure URL is good
409 * @throws IOException thrown is IO exception occurs
410 * @throws InterruptedException thrown if thread interrupted occurs
412 private String http(String urlString, String post)
413 throws IOException, InterruptedException {
414 URL url = new URL(urlString);
415 if (!NetworkUtil.isTcpPortOpen(url.getHost(), url.getPort(), 25, 2)) {
416 throw new IllegalStateException("port never opened: " + url);
418 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
419 conn.setRequestMethod("POST");
420 conn.setDoOutput(true);
421 conn.setRequestProperty("Content-Type", "application/json");
422 IOUtils.write(post, conn.getOutputStream());
423 return response(conn);
427 * gets http response.
429 * @param conn connection from which to read
431 * @throws IOException if an I/O error occurs
433 private String response(URLConnection conn) throws IOException {
434 StringBuilder response = new StringBuilder();
435 try (BufferedReader ioReader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
437 while ((line = ioReader.readLine()) != null) {
438 response.append(line);
441 return response.toString();