gerrit.onap Code Review - policy/common.git/blob

   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.HttpURLConnection;
  32 import java.net.MalformedURLException;
  33 import java.net.URL;
  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;
  45
  46 /**
  47  * HttpServletServer JUNIT tests.
  48  */
  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";
  56
  57     /**
  58      * Logger.
  59      */
  60     private static Logger logger = LoggerFactory.getLogger(HttpServerTest.class);
  61
  62     private static final String LOCALHOST_PREFIX = "http://localhost:";
  63
  64     private static final Gson gson = new Gson();
  65
  66     /**
  67      * Server port.  Incremented by 10 with each test.
  68      */
  69     private static int port = 5608;
  70
  71     private String portUrl;
  72
  73     /**
  74      * Increments the port number, clears the servers, and resets the providers.
  75      */
  76     @Before
  77     public void setUp() {
  78         port += 10;
  79         portUrl = LOCALHOST_PREFIX + port;
  80
  81         HttpServletServer.factory.destroy();
  82
  83         MyJacksonProvider.resetSome();
  84         MyGsonProvider.resetSome();
  85     }
  86
  87     @AfterClass
  88     public static void tearDownAfterClass() {
  89         HttpServletServer.factory.destroy();
  90     }
  91
  92     @Test
  93     public void testDefaultPackageServer() throws Exception {
  94         logger.info("-- testDefaultPackageServer() --");
  95
  96         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
  97         server.addServletPackage("/*", this.getClass().getPackage().getName());
  98         server.addFilterClass("/*", TestFilter.class.getName());
  99         server.waitedStart(5000);
 100
 101         assertTrue(HttpServletServer.factory.get(port).isAlive());
 102
 103         RestEchoReqResp request = new RestEchoReqResp();
 104         request.setRequestId(100);
 105         request.setText(SOME_TEXT);
 106         String reqText = gson.toJson(request);
 107
 108         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 109         assertEquals(reqText, response);
 110     }
 111
 112     @Test
 113     public void testJacksonPackageServer() throws Exception {
 114         logger.info("-- testJacksonPackageServer() --");
 115
 116         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 117
 118         server.setSerializationProvider(MyJacksonProvider.class.getName());
 119         server.addServletPackage("/*", this.getClass().getPackage().getName());
 120         server.addFilterClass("/*", TestFilter.class.getName());
 121         server.waitedStart(5000);
 122
 123         assertTrue(HttpServletServer.factory.get(port).isAlive());
 124
 125         RestEchoReqResp request = new RestEchoReqResp();
 126         request.setRequestId(100);
 127         request.setText(SOME_TEXT);
 128         String reqText = gson.toJson(request);
 129
 130         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 131         assertEquals(reqText, response);
 132
 133         assertTrue(MyJacksonProvider.hasReadSome());
 134         assertTrue(MyJacksonProvider.hasWrittenSome());
 135
 136         assertFalse(MyGsonProvider.hasReadSome());
 137         assertFalse(MyGsonProvider.hasWrittenSome());
 138     }
 139
 140     @Test
 141     public void testGsonPackageServer() throws Exception {
 142         logger.info("-- testGsonPackageServer() --");
 143
 144         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 145
 146         server.setSerializationProvider(MyGsonProvider.class.getName());
 147         server.addServletPackage("/*", this.getClass().getPackage().getName());
 148         server.addFilterClass("/*", TestFilter.class.getName());
 149         server.waitedStart(5000);
 150
 151         assertTrue(HttpServletServer.factory.get(port).isAlive());
 152
 153         RestEchoReqResp request = new RestEchoReqResp();
 154         request.setRequestId(100);
 155         request.setText(SOME_TEXT);
 156         String reqText = gson.toJson(request);
 157
 158         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 159         assertEquals(reqText, response);
 160
 161         assertTrue(MyGsonProvider.hasReadSome());
 162         assertTrue(MyGsonProvider.hasWrittenSome());
 163
 164         assertFalse(MyJacksonProvider.hasReadSome());
 165         assertFalse(MyJacksonProvider.hasWrittenSome());
 166     }
 167
 168     @Test
 169     public void testDefaultClassServer() throws Exception {
 170         logger.info("-- testDefaultClassServer() --");
 171
 172         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 173         server.addServletClass("/*", RestEchoService.class.getName());
 174         server.addFilterClass("/*", TestFilter.class.getName());
 175         server.waitedStart(5000);
 176
 177         assertTrue(HttpServletServer.factory.get(port).isAlive());
 178
 179         RestEchoReqResp request = new RestEchoReqResp();
 180         request.setRequestId(100);
 181         request.setText(SOME_TEXT);
 182         String reqText = gson.toJson(request);
 183
 184         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 185         assertEquals(reqText, response);
 186     }
 187
 188     @Test
 189     public void testJacksonClassServer() throws Exception {
 190         logger.info("-- testJacksonClassServer() --");
 191
 192         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 193         server.setSerializationProvider(MyJacksonProvider.class.getName());
 194         server.addServletClass("/*", RestEchoService.class.getName());
 195         server.addFilterClass("/*", TestFilter.class.getName());
 196         server.waitedStart(5000);
 197
 198         assertTrue(HttpServletServer.factory.get(port).isAlive());
 199
 200         RestEchoReqResp request = new RestEchoReqResp();
 201         request.setRequestId(100);
 202         request.setText(SOME_TEXT);
 203         String reqText = gson.toJson(request);
 204
 205         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 206         assertEquals(reqText, response);
 207
 208         assertTrue(MyJacksonProvider.hasReadSome());
 209         assertTrue(MyJacksonProvider.hasWrittenSome());
 210
 211         assertFalse(MyGsonProvider.hasReadSome());
 212         assertFalse(MyGsonProvider.hasWrittenSome());
 213     }
 214
 215     @Test
 216     public void testGsonClassServer() throws Exception {
 217         logger.info("-- testGsonClassServer() --");
 218
 219         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 220         server.setSerializationProvider(MyGsonProvider.class.getName());
 221         server.addServletClass("/*", RestEchoService.class.getName());
 222         server.addFilterClass("/*", TestFilter.class.getName());
 223         server.waitedStart(5000);
 224
 225         assertTrue(HttpServletServer.factory.get(port).isAlive());
 226
 227         RestEchoReqResp request = new RestEchoReqResp();
 228         request.setRequestId(100);
 229         request.setText(SOME_TEXT);
 230         String reqText = gson.toJson(request);
 231
 232         String response = http(portUrl + JUNIT_ECHO_FULL_REQUEST, reqText);
 233         assertEquals(reqText, response);
 234
 235         assertTrue(MyGsonProvider.hasReadSome());
 236         assertTrue(MyGsonProvider.hasWrittenSome());
 237
 238         assertFalse(MyJacksonProvider.hasReadSome());
 239         assertFalse(MyJacksonProvider.hasWrittenSome());
 240     }
 241
 242     @Test
 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.getName());
 247
 248         // ensure we can serialize the server
 249         new GsonTestUtils().compareGson(server, HttpServerTest.class);
 250     }
 251
 252     @Test
 253     public void testSingleServer() throws Exception {
 254         logger.info("-- testSingleServer() --");
 255
 256         HttpServletServer server = HttpServletServer.factory.build("echo", LOCALHOST, port, "/", false, true);
 257         server.addServletPackage("/*", this.getClass().getPackage().getName());
 258         server.addFilterClass("/*", TestFilter.class.getName());
 259         server.waitedStart(5000);
 260
 261         assertTrue(HttpServletServer.factory.get(port).isAlive());
 262         assertFalse(HttpServletServer.factory.get(port).isAaf());
 263
 264         String response = http(portUrl + JUNIT_ECHO_HELLO);
 265         assertEquals(HELLO, response);
 266
 267         response = null;
 268         try {
 269             response = http(portUrl + SWAGGER_JSON);
 270         } catch (IOException e) {
 271             // Expected
 272         }
 273         assertTrue(response == null);
 274
 275         response = http(portUrl + "/junit/echo/hello?block=true");
 276         assertEquals("FILTERED", response);
 277
 278         assertTrue(HttpServletServer.factory.get(port).isAlive());
 279         assertEquals(1, HttpServletServer.factory.inventory().size());
 280
 281         server.setAafAuthentication("/*");
 282         assertTrue(HttpServletServer.factory.get(port).isAaf());
 283
 284         HttpServletServer.factory.destroy(port);
 285         assertEquals(0, HttpServletServer.factory.inventory().size());
 286     }
 287
 288     @Test
 289     public void testMultipleServers() throws Exception {
 290         logger.info("-- testMultipleServers() --");
 291
 292         HttpServletServer server1 = HttpServletServer.factory.build("echo-1", false,LOCALHOST, port, "/", true, true);
 293         server1.addServletPackage("/*", this.getClass().getPackage().getName());
 294         server1.waitedStart(5000);
 295
 296         int port2 = port + 1;
 297
 298         HttpServletServer server2 = HttpServletServer.factory.build("echo-2", LOCALHOST, port2, "/", false, true);
 299         server2.addServletPackage("/*", this.getClass().getPackage().getName());
 300         server2.waitedStart(5000);
 301
 302         assertTrue(HttpServletServer.factory.get(port).isAlive());
 303         assertTrue(HttpServletServer.factory.get(port2).isAlive());
 304
 305         String response = http(portUrl + JUNIT_ECHO_HELLO);
 306         assertTrue(HELLO.equals(response));
 307
 308         response = http(portUrl + SWAGGER_JSON);
 309         assertTrue(response != null);
 310
 311         response = http(LOCALHOST_PREFIX + port2 + JUNIT_ECHO_HELLO);
 312         assertTrue(HELLO.equals(response));
 313
 314         response = null;
 315         try {
 316             response = http(LOCALHOST_PREFIX + port2 + SWAGGER_JSON);
 317         } catch (IOException e) {
 318             // Expected
 319         }
 320         assertTrue(response == null);
 321
 322         HttpServletServer.factory.destroy();
 323         assertTrue(HttpServletServer.factory.inventory().isEmpty());
 324     }
 325
 326     @Test
 327     public void testMultiServicePackage() throws Exception {
 328         logger.info("-- testMultiServicePackage() --");
 329
 330         String randomName = UUID.randomUUID().toString();
 331
 332         HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
 333         server.addServletPackage("/*", this.getClass().getPackage().getName());
 334         server.waitedStart(5000);
 335
 336         assertTrue(HttpServletServer.factory.get(port).isAlive());
 337
 338         String response = http(portUrl + JUNIT_ECHO_HELLO);
 339         assertTrue(HELLO.equals(response));
 340
 341         response = http(portUrl + "/junit/endpoints/http/servers");
 342         assertTrue(response.contains(randomName));
 343
 344         HttpServletServer.factory.destroy();
 345         assertTrue(HttpServletServer.factory.inventory().isEmpty());
 346     }
 347
 348     @Test
 349     public void testServiceClass() throws Exception {
 350         logger.info("-- testServiceClass() --");
 351         String randomName = UUID.randomUUID().toString();
 352
 353         HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
 354         server.addServletClass("/*", RestEchoService.class.getName());
 355         server.waitedStart(5000);
 356
 357         assertTrue(HttpServletServer.factory.get(port).isAlive());
 358
 359         String response = http(portUrl + JUNIT_ECHO_HELLO);
 360         assertTrue(HELLO.equals(response));
 361
 362         HttpServletServer.factory.destroy();
 363         assertTrue(HttpServletServer.factory.inventory().isEmpty());
 364     }
 365
 366     @Test
 367     public void testMultiServiceClass() throws Exception {
 368         logger.info("-- testMultiServiceClass() --");
 369
 370         String randomName = UUID.randomUUID().toString();
 371
 372         HttpServletServer server = HttpServletServer.factory.build(randomName, LOCALHOST, port, "/", false, true);
 373         server.addServletClass("/*", RestEchoService.class.getName());
 374         server.addServletClass("/*", RestEndpoints.class.getName());
 375         server.waitedStart(5000);
 376
 377         assertTrue(HttpServletServer.factory.get(port).isAlive());
 378
 379         String response = http(portUrl + JUNIT_ECHO_HELLO);
 380         assertTrue(HELLO.equals(response));
 381
 382         response = http(portUrl + "/junit/endpoints/http/servers");
 383         assertTrue(response.contains(randomName));
 384
 385         HttpServletServer.factory.destroy();
 386         assertTrue(HttpServletServer.factory.inventory().isEmpty());
 387     }
 388
 389     /**
 390      * performs an http request.
 391      *
 392      * @throws MalformedURLException make sure URL is good
 393      * @throws IOException thrown is IO exception occurs
 394      * @throws InterruptedException thrown if thread interrupted occurs
 395      */
 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);
 401         }
 402         return response(url.openConnection());
 403     }
 404
 405     /**
 406      * Performs an http request.
 407      *
 408      * @throws MalformedURLException make sure URL is good
 409      * @throws IOException thrown is IO exception occurs
 410      * @throws InterruptedException thrown if thread interrupted occurs
 411      */
 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);
 417         }
 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);
 424     }
 425
 426     /**
 427      * gets http response.
 428      *
 429      * @param conn connection from which to read
 430      *
 431      * @throws IOException if an I/O error occurs
 432      */
 433     private String response(URLConnection conn) throws IOException {
 434         StringBuilder response = new StringBuilder();
 435         try (BufferedReader ioReader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
 436             String line;
 437             while ((line = ioReader.readLine()) != null) {
 438                 response.append(line);
 439             }
 440         }
 441         return response.toString();
 442     }
 443
 444 }