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