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