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