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.ConnectException;
32 import java.net.HttpURLConnection;
33 import java.net.MalformedURLException;
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;
47 * HttpServletServer JUNIT tests.
49 public class HttpServerTest {
54 private static Logger logger = LoggerFactory.getLogger(HttpServerTest.class);
56 private static final String LOCALHOST_PREFIX = "http://localhost:";
58 private static final Gson gson = new Gson();
61 * Server port. Incremented by 10 with each test.
63 private static int port = 5608;
65 private String portUrl;
68 * Increments the port number, clears the servers, and resets the providers.
73 portUrl = LOCALHOST_PREFIX + port;
75 HttpServletServer.factory.destroy();
77 MyJacksonProvider.resetSome();
78 MyGsonProvider.resetSome();
82 public static void tearDownAfterClass() {
83 HttpServletServer.factory.destroy();
87 public void testDefaultPackageServer() throws Exception {
88 logger.info("-- testDefaultPackageServer() --");
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);
95 assertTrue(HttpServletServer.factory.get(port).isAlive());
97 RestEchoReqResp request = new RestEchoReqResp();
98 request.setRequestId(100);
99 request.setText("some text");
100 String reqText = gson.toJson(request);
102 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
103 assertEquals(reqText, response);
107 public void testJacksonPackageServer() throws Exception {
108 logger.info("-- testJacksonPackageServer() --");
110 HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
112 server.setSerializationProvider(MyJacksonProvider.class.getCanonicalName());
113 server.addServletPackage("/*", this.getClass().getPackage().getName());
114 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
115 server.waitedStart(5000);
117 assertTrue(HttpServletServer.factory.get(port).isAlive());
119 RestEchoReqResp request = new RestEchoReqResp();
120 request.setRequestId(100);
121 request.setText("some text");
122 String reqText = gson.toJson(request);
124 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
125 assertEquals(reqText, response);
127 assertTrue(MyJacksonProvider.hasReadSome());
128 assertTrue(MyJacksonProvider.hasWrittenSome());
130 assertFalse(MyGsonProvider.hasReadSome());
131 assertFalse(MyGsonProvider.hasWrittenSome());
135 public void testGsonPackageServer() throws Exception {
136 logger.info("-- testGsonPackageServer() --");
138 HttpServletServer server = HttpServletServer.factory.build("echo", "localhost", port, "/", false, true);
140 server.setSerializationProvider(MyGsonProvider.class.getCanonicalName());
141 server.addServletPackage("/*", this.getClass().getPackage().getName());
142 server.addFilterClass("/*", TestFilter.class.getCanonicalName());
143 server.waitedStart(5000);
145 assertTrue(HttpServletServer.factory.get(port).isAlive());
147 RestEchoReqResp request = new RestEchoReqResp();
148 request.setRequestId(100);
149 request.setText("some text");
150 String reqText = gson.toJson(request);
152 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
153 assertEquals(reqText, response);
155 assertTrue(MyGsonProvider.hasReadSome());
156 assertTrue(MyGsonProvider.hasWrittenSome());
158 assertFalse(MyJacksonProvider.hasReadSome());
159 assertFalse(MyJacksonProvider.hasWrittenSome());
163 public void testDefaultClassServer() throws Exception {
164 logger.info("-- testDefaultClassServer() --");
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);
171 assertTrue(HttpServletServer.factory.get(port).isAlive());
173 RestEchoReqResp request = new RestEchoReqResp();
174 request.setRequestId(100);
175 request.setText("some text");
176 String reqText = gson.toJson(request);
178 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
179 assertEquals(reqText, response);
183 public void testJacksonClassServer() throws Exception {
184 logger.info("-- testJacksonClassServer() --");
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);
192 assertTrue(HttpServletServer.factory.get(port).isAlive());
194 RestEchoReqResp request = new RestEchoReqResp();
195 request.setRequestId(100);
196 request.setText("some text");
197 String reqText = gson.toJson(request);
199 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
200 assertEquals(reqText, response);
202 assertTrue(MyJacksonProvider.hasReadSome());
203 assertTrue(MyJacksonProvider.hasWrittenSome());
205 assertFalse(MyGsonProvider.hasReadSome());
206 assertFalse(MyGsonProvider.hasWrittenSome());
210 public void testGsonClassServer() throws Exception {
211 logger.info("-- testGsonClassServer() --");
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);
219 assertTrue(HttpServletServer.factory.get(port).isAlive());
221 RestEchoReqResp request = new RestEchoReqResp();
222 request.setRequestId(100);
223 request.setText("some text");
224 String reqText = gson.toJson(request);
226 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/full/request", reqText);
227 assertEquals(reqText, response);
229 assertTrue(MyGsonProvider.hasReadSome());
230 assertTrue(MyGsonProvider.hasWrittenSome());
232 assertFalse(MyJacksonProvider.hasReadSome());
233 assertFalse(MyJacksonProvider.hasWrittenSome());
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());
242 // ensure we can serialize the server
243 new GsonTestUtils().compareGson(server, HttpServerTest.class);
247 public void testSingleServer() throws Exception {
248 logger.info("-- testSingleServer() --");
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);
255 assertTrue(HttpServletServer.factory.get(port).isAlive());
256 assertFalse(HttpServletServer.factory.get(port).isAaf());
258 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
259 assertTrue("hello".equals(response));
263 response = http(HttpServletServer.factory.get(port), portUrl + "/swagger.json");
264 } catch (IOException e) {
267 assertTrue(response == null);
269 response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello?block=true");
270 assertEquals("FILTERED", response);
272 assertTrue(HttpServletServer.factory.get(port).isAlive());
273 assertEquals(1, HttpServletServer.factory.inventory().size());
275 server.setAafAuthentication("/*");
276 assertTrue(HttpServletServer.factory.get(port).isAaf());
278 HttpServletServer.factory.destroy(port);
279 assertEquals(0, HttpServletServer.factory.inventory().size());
283 public void testMultipleServers() throws Exception {
284 logger.info("-- testMultipleServers() --");
286 HttpServletServer server1 = HttpServletServer.factory.build("echo-1", false,"localhost", port, "/", true, true);
287 server1.addServletPackage("/*", this.getClass().getPackage().getName());
288 server1.waitedStart(5000);
290 int port2 = port + 1;
292 HttpServletServer server2 = HttpServletServer.factory.build("echo-2", "localhost", port2, "/", false, true);
293 server2.addServletPackage("/*", this.getClass().getPackage().getName());
294 server2.waitedStart(5000);
296 assertTrue(HttpServletServer.factory.get(port).isAlive());
297 assertTrue(HttpServletServer.factory.get(port2).isAlive());
299 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
300 assertTrue("hello".equals(response));
302 response = http(HttpServletServer.factory.get(port), portUrl + "/swagger.json");
303 assertTrue(response != null);
305 response = http(HttpServletServer.factory.get(port2), LOCALHOST_PREFIX + port2 + "/junit/echo/hello");
306 assertTrue("hello".equals(response));
310 response = http(HttpServletServer.factory.get(port2), LOCALHOST_PREFIX + port2 + "/swagger.json");
311 } catch (IOException e) {
314 assertTrue(response == null);
316 HttpServletServer.factory.destroy();
317 assertTrue(HttpServletServer.factory.inventory().size() == 0);
321 public void testMultiServicePackage() throws Exception {
322 logger.info("-- testMultiServicePackage() --");
324 String randomName = UUID.randomUUID().toString();
326 HttpServletServer server = HttpServletServer.factory.build(randomName, "localhost", port, "/", false, true);
327 server.addServletPackage("/*", this.getClass().getPackage().getName());
328 server.waitedStart(5000);
330 assertTrue(HttpServletServer.factory.get(port).isAlive());
332 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
333 assertTrue("hello".equals(response));
335 response = http(HttpServletServer.factory.get(port), portUrl + "/junit/endpoints/http/servers");
336 assertTrue(response.contains(randomName));
338 HttpServletServer.factory.destroy();
339 assertTrue(HttpServletServer.factory.inventory().size() == 0);
343 public void testServiceClass() throws Exception {
344 logger.info("-- testServiceClass() --");
345 String randomName = UUID.randomUUID().toString();
347 HttpServletServer server = HttpServletServer.factory.build(randomName, "localhost", port, "/", false, true);
348 server.addServletClass("/*", RestEchoService.class.getCanonicalName());
349 server.waitedStart(5000);
351 assertTrue(HttpServletServer.factory.get(port).isAlive());
353 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
354 assertTrue("hello".equals(response));
356 HttpServletServer.factory.destroy();
357 assertTrue(HttpServletServer.factory.inventory().size() == 0);
361 public void testMultiServiceClass() throws Exception {
362 logger.info("-- testMultiServiceClass() --");
364 String randomName = UUID.randomUUID().toString();
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);
371 assertTrue(HttpServletServer.factory.get(port).isAlive());
373 String response = http(HttpServletServer.factory.get(port), portUrl + "/junit/echo/hello");
374 assertTrue("hello".equals(response));
376 response = http(HttpServletServer.factory.get(port), portUrl + "/junit/endpoints/http/servers");
377 assertTrue(response.contains(randomName));
379 HttpServletServer.factory.destroy();
380 assertTrue(HttpServletServer.factory.inventory().size() == 0);
384 * performs an http request.
386 * @throws MalformedURLException make sure URL is good
387 * @throws IOException thrown is IO exception occurs
388 * @throws InterruptedException thrown if thread interrupted occurs
390 protected String http(HttpServletServer server, String urlString)
391 throws MalformedURLException, IOException, InterruptedException {
392 URL url = new URL(urlString);
393 String response = null;
395 int maxNumberRetries = 5;
396 while (numRetries <= maxNumberRetries) {
398 URLConnection conn = url.openConnection();
399 response = response(conn);
401 } catch (ConnectException e) {
402 logger.warn("http server {} @ {} ({}) - cannot connect yet ..", server, urlString, numRetries, e);
404 Thread.sleep(10000L);
405 } catch (Exception e) {
414 * Performs an http request.
416 * @throws MalformedURLException make sure URL is good
417 * @throws IOException thrown is IO exception occurs
418 * @throws InterruptedException thrown if thread interrupted occurs
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;
425 int maxNumberRetries = 5;
426 while (numRetries <= maxNumberRetries) {
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);
435 } catch (ConnectException e) {
436 logger.warn("http server {} @ {} ({}) - cannot connect yet ..", server, urlString, numRetries, e);
438 Thread.sleep(10000L);
439 } catch (Exception e) {
440 logger.error("http error", e);
449 * gets http response.
451 * @param conn connection from which to read
453 * @throws IOException if an I/O error occurs
455 protected String response(URLConnection conn) throws IOException {
456 String response = "";
457 try (BufferedReader ioReader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
459 while ((line = ioReader.readLine()) != null) {