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 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.Assert.assertEquals;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertSame;
  29 import static org.junit.Assert.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.AfterClass;
  45 import org.junit.Before;
  46 import org.junit.BeforeClass;
  47 import org.junit.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 public 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     @BeforeClass
  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.addFilterClass("/*", TestAafAuthFilter.class.getName());
 130         echoServerAuth.addFilterClass("/*", TestAafGranularAuthFilter.class.getName());
 131         echoServerAuth.waitedStart(5000);
 132
 133         if (!NetworkUtil.isTcpPortOpen(LOCALHOST, echoServerAuth.getPort(), 5, 10000L)) {
 134             throw new IllegalStateException("cannot connect to port " + echoServerAuth.getPort());
 135         }
 136     }
 137
 138     /**
 139      * Clear https clients and reset providers.
 140      */
 141     @Before
 142     public void setUp() {
 143         HttpClientFactoryInstance.getClientFactory().destroy();
 144
 145         MyGsonProvider.resetSome();
 146     }
 147
 148     /**
 149      * After the class is created method.
 150      */
 151     @AfterClass
 152     public static void tearDownAfterClass() {
 153         HttpServletServerFactoryInstance.getServerFactory().destroy();
 154         HttpClientFactoryInstance.getClientFactory().destroy();
 155
 156         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME)) {
 157             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME,
 158                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME));
 159             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 160         } else {
 161             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 162         }
 163
 164         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME)) {
 165             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME,
 166                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME));
 167             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 168         } else {
 169             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 170         }
 171
 172         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME)) {
 173             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME,
 174                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME));
 175             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 176         } else {
 177             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 178         }
 179
 180         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME)) {
 181             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME,
 182                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME));
 183             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 184         } else {
 185             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 186         }
 187
 188
 189     }
 190
 191     @Test
 192     public void testHttpGetNoAuthClient() throws Exception {
 193         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 194             6666);
 195         final Response response = client.get(HELLO);
 196         final String body = HttpClient.getBody(response, String.class);
 197
 198         assertEquals(200, response.getStatus());
 199         assertEquals(HELLO, body);
 200     }
 201
 202     @Test
 203     public void testHttpGetNoAuthClientAsync() throws Exception {
 204         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 205             6666);
 206         MyCallback callback = new MyCallback();
 207         final Response response = client.get(callback, HELLO, new TreeMap<>()).get();
 208
 209         verifyCallback("testHttpGetNoAuthClientAsync", callback, response);
 210
 211         final String body = HttpClient.getBody(response, String.class);
 212
 213         assertEquals(200, response.getStatus());
 214         assertEquals(HELLO, body);
 215     }
 216
 217     private void verifyCallback(String testName, MyCallback callback, final Response response)
 218                     throws InterruptedException {
 219         assertTrue(testName, callback.await());
 220         assertNull(testName, callback.getThrowable());
 221         assertSame(testName, response, callback.getResponse());
 222     }
 223
 224     @Test
 225     public void testHttpPutNoAuthClient() throws Exception {
 226         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false, 6666);
 227
 228         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 229         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 230         final String body = HttpClient.getBody(response, String.class);
 231
 232         assertEquals(200, response.getStatus());
 233         assertEquals(PUT_HELLO, body);
 234     }
 235
 236     @Test
 237     public void testHttpPutNoAuthClientAsync() throws Exception {
 238         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false, 6666);
 239
 240         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 241         MyCallback callback = new MyCallback();
 242         final Response response = client.put(callback, HELLO, entity, Collections.emptyMap()).get();
 243
 244         verifyCallback("testHttpPutNoAuthClientAsync", callback, response);
 245
 246         final String body = HttpClient.getBody(response, String.class);
 247
 248         assertEquals(200, response.getStatus());
 249         assertEquals(PUT_HELLO, body);
 250     }
 251
 252     @Test
 253     public void testHttpPostNoAuthClient() throws Exception {
 254         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 255             6666);
 256
 257         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 258         final Response response = client.post(HELLO, entity, Collections.emptyMap());
 259         final String body = HttpClient.getBody(response, String.class);
 260
 261         assertEquals(200, response.getStatus());
 262         assertEquals("POST:hello:{myParameter=myValue}", body);
 263     }
 264
 265     @Test
 266     public void testHttpPostNoAuthClientAsync() throws Exception {
 267         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 268             6666);
 269
 270         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 271         MyCallback callback = new MyCallback();
 272         final Response response = client.post(callback, HELLO, entity, Collections.emptyMap()).get();
 273
 274         verifyCallback("testHttpPostNoAuthClientAsync", callback, response);
 275
 276         final String body = HttpClient.getBody(response, String.class);
 277
 278         assertEquals(200, response.getStatus());
 279         assertEquals("POST:hello:{myParameter=myValue}", body);
 280     }
 281
 282     @Test
 283     public void testHttpDeletetNoAuthClient() throws Exception {
 284         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 285             6666);
 286
 287         final Response response = client.delete(HELLO, Collections.emptyMap());
 288         final String body = HttpClient.getBody(response, String.class);
 289
 290         assertEquals(200, response.getStatus());
 291         assertEquals("DELETE:hello", body);
 292     }
 293
 294     @Test
 295     public void testHttpDeletetNoAuthClientAsync() throws Exception {
 296         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 297             6666);
 298
 299         MyCallback callback = new MyCallback();
 300         final Response response = client.delete(callback, HELLO, Collections.emptyMap()).get();
 301
 302         verifyCallback("testHttpDeletetNoAuthClientAsync", callback, response);
 303
 304         final String body = HttpClient.getBody(response, String.class);
 305
 306         assertEquals(200, response.getStatus());
 307         assertEquals("DELETE:hello", body);
 308     }
 309
 310     /**
 311      * Perform one asynchronous test with auth client; don't need to test every method.
 312      * @throws Exception if an error occurs
 313      */
 314     @Test
 315     public void testHttpAsyncAuthClient() throws Exception {
 316         final HttpClient client = getAuthHttpClient();
 317
 318         MyCallback callback = new MyCallback();
 319         final Response response = client.get(callback, HELLO, null).get();
 320
 321         verifyCallback("testHttpAsyncAuthClient", callback, response);
 322
 323         final String body = HttpClient.getBody(response, String.class);
 324
 325         assertEquals(200, response.getStatus());
 326         assertEquals(HELLO, body);
 327     }
 328
 329     @Test
 330     public void testHttpGetAuthClient() throws Exception {
 331         final HttpClient client = getAuthHttpClient();
 332
 333         final Response response = client.get(HELLO);
 334         final String body = HttpClient.getBody(response, String.class);
 335
 336         assertEquals(200, response.getStatus());
 337         assertEquals(HELLO, body);
 338     }
 339
 340     @Test
 341     public void testHttpPutAuthClient() throws Exception {
 342         final HttpClient client = getAuthHttpClient();
 343
 344         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 345         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 346         final String body = HttpClient.getBody(response, String.class);
 347
 348         assertEquals(200, response.getStatus());
 349         assertEquals(PUT_HELLO, body);
 350     }
 351
 352     @Test
 353     public void testHttpPutAuthClient_GsonProvider() throws Exception {
 354         final HttpClient client = HttpClientFactoryInstance.getClientFactory()
 355                         .build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT).useHttps(true)
 356                                         .allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667).basePath(JUNIT_ECHO)
 357                                         .userName("x").password("y").managed(true)
 358                                         .serializationProvider(MyGsonProvider.class.getName()).build());
 359
 360         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 361         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 362         final String body = HttpClient.getBody(response, String.class);
 363
 364         assertEquals(200, response.getStatus());
 365         assertEquals(PUT_HELLO, body);
 366
 367         assertTrue(MyGsonProvider.hasWrittenSome());
 368     }
 369
 370     @Test
 371     public void testHttpAuthClient401() throws Exception {
 372         final HttpClient client = getNoAuthHttpClient("testHttpAuthClient401", true,
 373             6667);
 374         final Response response = client.get(HELLO);
 375         assertEquals(401, response.getStatus());
 376     }
 377
 378     @Test
 379     public void testHttpAuthClientProps() throws Exception {
 380         final Properties httpProperties = new Properties();
 381
 382         /* PAP and PDP services */
 383
 384         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES, "PAP,PDP");
 385
 386         /* PAP server service configuration */
 387
 388         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 389                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 390         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 391                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 392         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 393                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 394         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 395                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 396         httpProperties.setProperty(
 397                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 398                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 399                         RestMockHealthCheck.class.getName());
 400         httpProperties.setProperty(
 401                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 402                                         + PolicyEndPointProperties.PROPERTY_HTTP_FILTER_CLASSES_SUFFIX,
 403                         TestFilter.class.getName());
 404         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 405                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 406         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 407                         + PolicyEndPointProperties.PROPERTY_HTTP_SERVLET_CLASS_SUFFIX, MetricsServlet.class.getName());
 408         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 409                                            + PolicyEndPointProperties.PROPERTY_HTTP_SERVLET_URIPATH_SUFFIX,
 410                                    "/pap/test/random/metrics");
 411
 412         /* PDP server service configuration */
 413
 414         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 415                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 416         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 417                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 418         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 419                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 420         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 421                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 422         httpProperties.setProperty(
 423                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 424                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 425                         RestMockHealthCheck.class.getName());
 426         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 427                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 428         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 429                                            + PolicyEndPointProperties.PROPERTY_HTTP_SWAGGER_SUFFIX, "true");
 430         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 431             + PolicyEndPointProperties.PROPERTY_HTTP_PROMETHEUS_SUFFIX, "true");
 432
 433         /* PDP and PAP client services */
 434
 435         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES, "PAP,PDP");
 436
 437         /* PAP client service configuration */
 438
 439         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 440                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 441         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 442                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 443         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 444                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, "pap/test");
 445         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 446                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 447         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 448                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 449         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 450                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 451         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 452                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 453
 454         /* PDP client service configuration */
 455
 456         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 457                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 458         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 459                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 460         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 461                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 462         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 463                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 464         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 465                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 466         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 467                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 468
 469         final List<HttpServletServer> servers =
 470                         HttpServletServerFactoryInstance.getServerFactory().build(httpProperties);
 471         assertEquals(2, servers.size());
 472
 473         final List<HttpClient> clients = HttpClientFactoryInstance.getClientFactory().build(httpProperties);
 474         assertEquals(2, clients.size());
 475
 476         for (final HttpServletServer server : servers) {
 477             server.waitedStart(10000);
 478         }
 479
 480         Response response;
 481         final HttpClient clientPap = HttpClientFactoryInstance.getClientFactory().get("PAP");
 482         response = clientPap.get();
 483         assertEquals(200, response.getStatus());
 484
 485         final HttpClient clientPdp = HttpClientFactoryInstance.getClientFactory().get("PDP");
 486
 487         response = clientPdp.get("pdp/test");
 488         assertEquals(500, response.getStatus());
 489
 490         response = clientPdp.get("metrics");
 491         assertEquals(200, response.getStatus());
 492
 493         response = clientPdp.get("openapi.json");
 494         assertEquals(200, response.getStatus());
 495
 496         assertFalse(MyGsonProvider.hasWrittenSome());
 497
 498         // try with empty path
 499         response = clientPap.get("");
 500         assertEquals(200, response.getStatus());
 501
 502         response = clientPap.get("random/metrics");
 503         assertEquals(200, response.getStatus());
 504
 505         response = clientPap.get("metrics");
 506         assertEquals(404, response.getStatus());
 507
 508         // try it asynchronously, too
 509         MyCallback callback = new MyCallback();
 510         response = clientPap.get(callback, null).get();
 511         verifyCallback("testHttpAuthClientProps", callback, response);
 512         assertEquals(200, response.getStatus());
 513
 514         // try it asynchronously, with empty path
 515         callback = new MyCallback();
 516         response = clientPap.get(callback, "", null).get();
 517         verifyCallback("testHttpAuthClientProps - empty path", callback, response);
 518         assertEquals(200, response.getStatus());
 519     }
 520
 521     private HttpClient getAuthHttpClient() throws HttpClientConfigException {
 522         return HttpClientFactoryInstance.getClientFactory()
 523                         .build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT).useHttps(true)
 524                                         .allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667).basePath(JUNIT_ECHO)
 525                                         .userName("x").password("y").managed(true).build());
 526     }
 527
 528     private HttpClient getNoAuthHttpClient(String clientName, boolean https, int port)
 529                     throws HttpClientConfigException {
 530         return HttpClientFactoryInstance.getClientFactory()
 531                         .build(BusTopicParams.builder().clientName(clientName).useHttps(https)
 532                                         .allowSelfSignedCerts(https).hostname(LOCALHOST).port(port).basePath(JUNIT_ECHO)
 533                                         .userName(null).password(null).managed(true).build());
 534     }
 535
 536
 537     static class MyEntity {
 538
 539         private String myParameter;
 540
 541         public MyEntity(final String myParameter) {
 542             this.myParameter = myParameter;
 543         }
 544
 545         public void setMyParameter(final String myParameter) {
 546             this.myParameter = myParameter;
 547         }
 548
 549         public String getMyParameter() {
 550             return myParameter;
 551         }
 552
 553     }
 554
 555     static class MyCallback implements InvocationCallback<Response> {
 556         @Getter
 557         private Response response;
 558
 559         @Getter
 560         private Throwable throwable;
 561
 562         private CountDownLatch latch = new CountDownLatch(1);
 563
 564         @Override
 565         public void completed(Response response) {
 566             this.response = response;
 567             latch.countDown();
 568         }
 569
 570         @Override
 571         public void failed(Throwable throwable) {
 572             this.throwable = throwable;
 573             latch.countDown();
 574         }
 575
 576         public boolean await() throws InterruptedException {
 577             return latch.await(5, TimeUnit.SECONDS);
 578         }
 579     }
 580 }