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