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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2017-2021 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2018 Samsung Electronics Co., Ltd.
   7  * Modifications Copyright 2023-2024 Nordix Foundation.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.common.endpoints.http.server.test;
  24
  25 import static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.assertFalse;
  27 import static org.junit.jupiter.api.Assertions.assertNull;
  28 import static org.junit.jupiter.api.Assertions.assertSame;
  29 import static org.junit.jupiter.api.Assertions.assertTrue;
  30
  31 import io.prometheus.client.servlet.jakarta.exporter.MetricsServlet;
  32 import jakarta.ws.rs.client.Entity;
  33 import jakarta.ws.rs.client.InvocationCallback;
  34 import jakarta.ws.rs.core.MediaType;
  35 import jakarta.ws.rs.core.Response;
  36 import java.util.Collections;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Properties;
  40 import java.util.TreeMap;
  41 import java.util.concurrent.CountDownLatch;
  42 import java.util.concurrent.TimeUnit;
  43 import lombok.Getter;
  44 import org.junit.jupiter.api.AfterAll;
  45 import org.junit.jupiter.api.BeforeAll;
  46 import org.junit.jupiter.api.BeforeEach;
  47 import org.junit.jupiter.api.Test;
  48 import org.onap.policy.common.endpoints.event.comm.bus.internal.BusTopicParams;
  49 import org.onap.policy.common.endpoints.http.client.HttpClient;
  50 import org.onap.policy.common.endpoints.http.client.HttpClientConfigException;
  51 import org.onap.policy.common.endpoints.http.client.HttpClientFactoryInstance;
  52 import org.onap.policy.common.endpoints.http.server.HttpServletServer;
  53 import org.onap.policy.common.endpoints.http.server.HttpServletServerFactoryInstance;
  54 import org.onap.policy.common.endpoints.http.server.internal.JettyJerseyServer;
  55 import org.onap.policy.common.endpoints.properties.PolicyEndPointProperties;
  56 import org.onap.policy.common.utils.network.NetworkUtil;
  57
  58 class HttpClientTest {
  59     private static final String TEST_HTTP_NO_AUTH_CLIENT = "testHttpNoAuthClient";
  60     private static final String TEST_HTTP_AUTH_CLIENT = "testHttpAuthClient";
  61     private static final String LOCALHOST = "localhost";
  62     private static final String JUNIT_ECHO = "junit/echo";
  63     private static final String HELLO = "hello";
  64     private static final String MY_VALUE = "myValue";
  65     private static final String FALSE_STRING = "false";
  66     private static final String ALPHA123 = "alpha123";
  67     private static final String PUT_HELLO = "PUT:hello:{myParameter=myValue}";
  68     private static final String DOT_PDP = "." + "PDP";
  69     private static final String DOT_PAP = "." + "PAP";
  70
  71     private static final HashMap<String, String> savedValuesMap = new HashMap<>();
  72
  73     /**
  74      * Setup before class method.
  75      *
  76      * @throws InterruptedException can be interrupted
  77      */
  78     @BeforeAll
  79     public static void setUpBeforeClass() throws InterruptedException {
  80         /* echo server - http + no auth */
  81
  82         final HttpServletServer echoServerNoAuth =
  83                 HttpServletServerFactoryInstance.getServerFactory().build("echo", LOCALHOST, 6666, "/", false, true);
  84         echoServerNoAuth.addServletPackage("/*", HttpClientTest.class.getPackage().getName());
  85         echoServerNoAuth.waitedStart(5000);
  86
  87         if (!NetworkUtil.isTcpPortOpen(LOCALHOST, echoServerNoAuth.getPort(), 5, 10000L)) {
  88             throw new IllegalStateException("cannot connect to port " + echoServerNoAuth.getPort());
  89         }
  90
  91         String keyStoreSystemProperty = System.getProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
  92         if (keyStoreSystemProperty != null) {
  93             savedValuesMap.put(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME, keyStoreSystemProperty);
  94         }
  95
  96         String keyStorePasswordSystemProperty =
  97                 System.getProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
  98         if (keyStorePasswordSystemProperty != null) {
  99             savedValuesMap.put(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME,
 100                     keyStorePasswordSystemProperty);
 101         }
 102
 103         String trustStoreSystemProperty = System.getProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 104         if (trustStoreSystemProperty != null) {
 105             savedValuesMap.put(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME, trustStoreSystemProperty);
 106         }
 107
 108         String trustStorePasswordSystemProperty =
 109                 System.getProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 110         if (trustStorePasswordSystemProperty != null) {
 111             savedValuesMap.put(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME,
 112                     trustStorePasswordSystemProperty);
 113         }
 114
 115         System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME, "src/test/resources/keystore-test");
 116         System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME, "kstest");
 117
 118         System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME, "src/test/resources/keystore-test");
 119         System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME, "kstest");
 120
 121         /* echo server - https + basic auth */
 122
 123         final HttpServletServer echoServerAuth = HttpServletServerFactoryInstance.getServerFactory()
 124                         .build("echo", true, LOCALHOST, 6667, false, "/", false, true);
 125         echoServerAuth.setBasicAuthentication("x", "y", null);
 126         echoServerAuth.addServletPackage("/*", HttpClientTest.class.getPackage().getName());
 127         echoServerAuth.addFilterClass("/*", TestFilter.class.getName());
 128         echoServerAuth.addFilterClass("/*", TestAuthorizationFilter.class.getName());
 129         echoServerAuth.waitedStart(5000);
 130
 131         if (!NetworkUtil.isTcpPortOpen(LOCALHOST, echoServerAuth.getPort(), 5, 10000L)) {
 132             throw new IllegalStateException("cannot connect to port " + echoServerAuth.getPort());
 133         }
 134     }
 135
 136     /**
 137      * Clear https clients and reset providers.
 138      */
 139     @BeforeEach
 140     public void setUp() {
 141         HttpClientFactoryInstance.getClientFactory().destroy();
 142
 143         MyGsonProvider.resetSome();
 144     }
 145
 146     /**
 147      * After the class is created method.
 148      */
 149     @AfterAll
 150     public static void tearDownAfterClass() {
 151         HttpServletServerFactoryInstance.getServerFactory().destroy();
 152         HttpClientFactoryInstance.getClientFactory().destroy();
 153
 154         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME)) {
 155             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME,
 156                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME));
 157             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 158         } else {
 159             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 160         }
 161
 162         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME)) {
 163             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME,
 164                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME));
 165             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 166         } else {
 167             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 168         }
 169
 170         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME)) {
 171             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME,
 172                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME));
 173             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 174         } else {
 175             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 176         }
 177
 178         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME)) {
 179             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME,
 180                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME));
 181             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 182         } else {
 183             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 184         }
 185
 186
 187     }
 188
 189     @Test
 190     void testHttpGetNoAuthClient() throws Exception {
 191         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 192             6666);
 193         final Response response = client.get(HELLO);
 194         final String body = HttpClient.getBody(response, String.class);
 195
 196         assertEquals(200, response.getStatus());
 197         assertEquals(HELLO, body);
 198     }
 199
 200     @Test
 201     void testHttpGetNoAuthClientAsync() throws Exception {
 202         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 203             6666);
 204         MyCallback callback = new MyCallback();
 205         final Response response = client.get(callback, HELLO, new TreeMap<>()).get();
 206
 207         verifyCallback("testHttpGetNoAuthClientAsync", callback, response);
 208
 209         final String body = HttpClient.getBody(response, String.class);
 210
 211         assertEquals(200, response.getStatus());
 212         assertEquals(HELLO, body);
 213     }
 214
 215     private void verifyCallback(String testName, MyCallback callback, final Response response)
 216                     throws InterruptedException {
 217         assertTrue(callback.await(), testName);
 218         assertNull(callback.getThrowable(), testName);
 219         assertSame(response, callback.getResponse(), testName);
 220     }
 221
 222     @Test
 223     void testHttpPutNoAuthClient() throws Exception {
 224         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false, 6666);
 225
 226         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 227         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 228         final String body = HttpClient.getBody(response, String.class);
 229
 230         assertEquals(200, response.getStatus());
 231         assertEquals(PUT_HELLO, body);
 232     }
 233
 234     @Test
 235     void testHttpPutNoAuthClientAsync() throws Exception {
 236         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false, 6666);
 237
 238         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 239         MyCallback callback = new MyCallback();
 240         final Response response = client.put(callback, HELLO, entity, Collections.emptyMap()).get();
 241
 242         verifyCallback("testHttpPutNoAuthClientAsync", callback, response);
 243
 244         final String body = HttpClient.getBody(response, String.class);
 245
 246         assertEquals(200, response.getStatus());
 247         assertEquals(PUT_HELLO, body);
 248     }
 249
 250     @Test
 251     void testHttpPostNoAuthClient() throws Exception {
 252         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 253             6666);
 254
 255         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 256         final Response response = client.post(HELLO, entity, Collections.emptyMap());
 257         final String body = HttpClient.getBody(response, String.class);
 258
 259         assertEquals(200, response.getStatus());
 260         assertEquals("POST:hello:{myParameter=myValue}", body);
 261     }
 262
 263     @Test
 264     void testHttpPostNoAuthClientAsync() throws Exception {
 265         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 266             6666);
 267
 268         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 269         MyCallback callback = new MyCallback();
 270         final Response response = client.post(callback, HELLO, entity, Collections.emptyMap()).get();
 271
 272         verifyCallback("testHttpPostNoAuthClientAsync", callback, response);
 273
 274         final String body = HttpClient.getBody(response, String.class);
 275
 276         assertEquals(200, response.getStatus());
 277         assertEquals("POST:hello:{myParameter=myValue}", body);
 278     }
 279
 280     @Test
 281     void testHttpDeletetNoAuthClient() throws Exception {
 282         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 283             6666);
 284
 285         final Response response = client.delete(HELLO, Collections.emptyMap());
 286         final String body = HttpClient.getBody(response, String.class);
 287
 288         assertEquals(200, response.getStatus());
 289         assertEquals("DELETE:hello", body);
 290     }
 291
 292     @Test
 293     void testHttpDeletetNoAuthClientAsync() throws Exception {
 294         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 295             6666);
 296
 297         MyCallback callback = new MyCallback();
 298         final Response response = client.delete(callback, HELLO, Collections.emptyMap()).get();
 299
 300         verifyCallback("testHttpDeletetNoAuthClientAsync", callback, response);
 301
 302         final String body = HttpClient.getBody(response, String.class);
 303
 304         assertEquals(200, response.getStatus());
 305         assertEquals("DELETE:hello", body);
 306     }
 307
 308     /**
 309      * Perform one asynchronous test with auth client; don't need to test every method.
 310      * @throws Exception if an error occurs
 311      */
 312     @Test
 313     void testHttpAsyncAuthClient() throws Exception {
 314         final HttpClient client = getAuthHttpClient();
 315
 316         MyCallback callback = new MyCallback();
 317         final Response response = client.get(callback, HELLO, null).get();
 318
 319         verifyCallback("testHttpAsyncAuthClient", callback, response);
 320
 321         final String body = HttpClient.getBody(response, String.class);
 322
 323         assertEquals(200, response.getStatus());
 324         assertEquals(HELLO, body);
 325     }
 326
 327     @Test
 328     void testHttpGetAuthClient() throws Exception {
 329         final HttpClient client = getAuthHttpClient();
 330
 331         final Response response = client.get(HELLO);
 332         final String body = HttpClient.getBody(response, String.class);
 333
 334         assertEquals(200, response.getStatus());
 335         assertEquals(HELLO, body);
 336     }
 337
 338     @Test
 339     void testHttpPutAuthClient() throws Exception {
 340         final HttpClient client = getAuthHttpClient();
 341
 342         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 343         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 344         final String body = HttpClient.getBody(response, String.class);
 345
 346         assertEquals(200, response.getStatus());
 347         assertEquals(PUT_HELLO, body);
 348     }
 349
 350     @Test
 351     void testHttpPutAuthClient_GsonProvider() throws Exception {
 352         final HttpClient client = HttpClientFactoryInstance.getClientFactory()
 353                         .build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT).useHttps(true)
 354                                         .allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667).basePath(JUNIT_ECHO)
 355                                         .userName("x").password("y").managed(true)
 356                                         .serializationProvider(MyGsonProvider.class.getName()).build());
 357
 358         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 359         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 360         final String body = HttpClient.getBody(response, String.class);
 361
 362         assertEquals(200, response.getStatus());
 363         assertEquals(PUT_HELLO, body);
 364
 365         assertTrue(MyGsonProvider.hasWrittenSome());
 366     }
 367
 368     @Test
 369     void testHttpAuthClient401() throws Exception {
 370         final HttpClient client = getNoAuthHttpClient("testHttpAuthClient401", true,
 371             6667);
 372         final Response response = client.get(HELLO);
 373         assertEquals(401, response.getStatus());
 374     }
 375
 376     @Test
 377     void testHttpAuthClientProps() throws Exception {
 378         final Properties httpProperties = new Properties();
 379
 380         /* PAP and PDP services */
 381
 382         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES, "PAP,PDP");
 383
 384         /* PAP server service configuration */
 385
 386         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 387                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 388         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 389                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 390         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 391                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 392         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 393                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 394         httpProperties.setProperty(
 395                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 396                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 397                         RestMockHealthCheck.class.getName());
 398         httpProperties.setProperty(
 399                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 400                                         + PolicyEndPointProperties.PROPERTY_HTTP_FILTER_CLASSES_SUFFIX,
 401                         TestFilter.class.getName());
 402         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 403                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 404         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 405                         + PolicyEndPointProperties.PROPERTY_HTTP_SERVLET_CLASS_SUFFIX, MetricsServlet.class.getName());
 406         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 407                                            + PolicyEndPointProperties.PROPERTY_HTTP_SERVLET_URIPATH_SUFFIX,
 408                                    "/pap/test/random/metrics");
 409
 410         /* PDP server service configuration */
 411
 412         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 413                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 414         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 415                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 416         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 417                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 418         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 419                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 420         httpProperties.setProperty(
 421                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 422                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 423                         RestMockHealthCheck.class.getName());
 424         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 425                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 426         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 427                                            + PolicyEndPointProperties.PROPERTY_HTTP_SWAGGER_SUFFIX, "true");
 428         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 429             + PolicyEndPointProperties.PROPERTY_HTTP_PROMETHEUS_SUFFIX, "true");
 430
 431         /* PDP and PAP client services */
 432
 433         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES, "PAP,PDP");
 434
 435         /* PAP client service configuration */
 436
 437         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 438                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 439         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 440                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 441         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 442                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, "pap/test");
 443         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 444                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 445         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 446                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 447         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 448                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 449         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 450                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 451
 452         /* PDP client service configuration */
 453
 454         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 455                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 456         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 457                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 458         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 459                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 460         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 461                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 462         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 463                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 464         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 465                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 466
 467         final List<HttpServletServer> servers =
 468                         HttpServletServerFactoryInstance.getServerFactory().build(httpProperties);
 469         assertEquals(2, servers.size());
 470
 471         final List<HttpClient> clients = HttpClientFactoryInstance.getClientFactory().build(httpProperties);
 472         assertEquals(2, clients.size());
 473
 474         for (final HttpServletServer server : servers) {
 475             server.waitedStart(10000);
 476         }
 477
 478         Response response;
 479         final HttpClient clientPap = HttpClientFactoryInstance.getClientFactory().get("PAP");
 480         response = clientPap.get();
 481         assertEquals(200, response.getStatus());
 482
 483         final HttpClient clientPdp = HttpClientFactoryInstance.getClientFactory().get("PDP");
 484
 485         response = clientPdp.get("pdp/test");
 486         assertEquals(500, response.getStatus());
 487
 488         response = clientPdp.get("metrics");
 489         assertEquals(200, response.getStatus());
 490
 491         response = clientPdp.get("openapi.json");
 492         assertEquals(200, response.getStatus());
 493
 494         assertFalse(MyGsonProvider.hasWrittenSome());
 495
 496         // try with empty path
 497         response = clientPap.get("");
 498         assertEquals(200, response.getStatus());
 499
 500         response = clientPap.get("random/metrics");
 501         assertEquals(200, response.getStatus());
 502
 503         response = clientPap.get("metrics");
 504         assertEquals(404, response.getStatus());
 505
 506         // try it asynchronously, too
 507         MyCallback callback = new MyCallback();
 508         response = clientPap.get(callback, null).get();
 509         verifyCallback("testHttpAuthClientProps", callback, response);
 510         assertEquals(200, response.getStatus());
 511
 512         // try it asynchronously, with empty path
 513         callback = new MyCallback();
 514         response = clientPap.get(callback, "", null).get();
 515         verifyCallback("testHttpAuthClientProps - empty path", callback, response);
 516         assertEquals(200, response.getStatus());
 517     }
 518
 519     private HttpClient getAuthHttpClient() throws HttpClientConfigException {
 520         return HttpClientFactoryInstance.getClientFactory()
 521                         .build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT).useHttps(true)
 522                                         .allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667).basePath(JUNIT_ECHO)
 523                                         .userName("x").password("y").managed(true).build());
 524     }
 525
 526     private HttpClient getNoAuthHttpClient(String clientName, boolean https, int port)
 527                     throws HttpClientConfigException {
 528         return HttpClientFactoryInstance.getClientFactory()
 529                         .build(BusTopicParams.builder().clientName(clientName).useHttps(https)
 530                                         .allowSelfSignedCerts(https).hostname(LOCALHOST).port(port).basePath(JUNIT_ECHO)
 531                                         .userName(null).password(null).managed(true).build());
 532     }
 533
 534
 535     static class MyEntity {
 536
 537         private String myParameter;
 538
 539         public MyEntity(final String myParameter) {
 540             this.myParameter = myParameter;
 541         }
 542
 543         public void setMyParameter(final String myParameter) {
 544             this.myParameter = myParameter;
 545         }
 546
 547         public String getMyParameter() {
 548             return myParameter;
 549         }
 550
 551     }
 552
 553     static class MyCallback implements InvocationCallback<Response> {
 554         @Getter
 555         private Response response;
 556
 557         @Getter
 558         private Throwable throwable;
 559
 560         private CountDownLatch latch = new CountDownLatch(1);
 561
 562         @Override
 563         public void completed(Response response) {
 564             this.response = response;
 565             latch.countDown();
 566         }
 567
 568         @Override
 569         public void failed(Throwable throwable) {
 570             this.throwable = throwable;
 571             latch.countDown();
 572         }
 573
 574         public boolean await() throws InterruptedException {
 575             return latch.await(5, TimeUnit.SECONDS);
 576         }
 577     }
 578 }