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  * Modifications Copyright (C) 2018 Samsung Electronics Co., Ltd.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.common.endpoints.http.server.test;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.security.KeyManagementException;
  29 import java.security.NoSuchAlgorithmException;
  30 import java.util.Collections;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Properties;
  34 import javax.ws.rs.client.Entity;
  35 import javax.ws.rs.core.MediaType;
  36 import javax.ws.rs.core.Response;
  37 import org.junit.AfterClass;
  38 import org.junit.Before;
  39 import org.junit.BeforeClass;
  40 import org.junit.Test;
  41 import org.onap.policy.common.endpoints.event.comm.bus.internal.BusTopicParams;
  42 import org.onap.policy.common.endpoints.http.client.HttpClient;
  43 import org.onap.policy.common.endpoints.http.server.HttpServletServer;
  44 import org.onap.policy.common.endpoints.http.server.internal.JettyJerseyServer;
  45 import org.onap.policy.common.endpoints.properties.PolicyEndPointProperties;
  46 import org.onap.policy.common.utils.network.NetworkUtil;
  47
  48 public class HttpClientTest {
  49     private static final String TEST_HTTP_NO_AUTH_CLIENT = "testHttpNoAuthClient";
  50     private static final String TEST_HTTP_AUTH_CLIENT = "testHttpAuthClient";
  51     private static final String LOCALHOST = "localhost";
  52     private static final String JUNIT_ECHO = "junit/echo";
  53     private static final String HELLO = "hello";
  54     private static final String MY_VALUE = "myValue";
  55     private static final String FALSE_STRING = "false";
  56     private static final String ALPHA123 = "alpha123";
  57     private static final String PUT_HELLO = "PUT:hello:{myParameter=myValue}";
  58     private static final String DOT_GSON = "." + "GSON";
  59     private static final String DOT_JACKSON = "." + "JACKSON";
  60     private static final String DOT_PDP = "." + "PDP";
  61     private static final String DOT_PAP = "." + "PAP";
  62
  63     private static final HashMap<String, String> savedValuesMap = new HashMap<>();
  64
  65     /**
  66      * Setup before class method.
  67      *
  68      * @throws InterruptedException can be interrupted
  69      */
  70     @BeforeClass
  71     public static void setUpBeforeClass() throws InterruptedException {
  72         /* echo server - http + no auth */
  73
  74         final HttpServletServer echoServerNoAuth =
  75                 HttpServletServer.factory.build("echo", LOCALHOST, 6666, "/", false, true);
  76         echoServerNoAuth.addServletPackage("/*", HttpClientTest.class.getPackage().getName());
  77         echoServerNoAuth.waitedStart(5000);
  78
  79         if (!NetworkUtil.isTcpPortOpen(LOCALHOST, echoServerNoAuth.getPort(), 5, 10000L)) {
  80             throw new IllegalStateException("cannot connect to port " + echoServerNoAuth.getPort());
  81         }
  82
  83         String keyStoreSystemProperty = System.getProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
  84         if (keyStoreSystemProperty != null) {
  85             savedValuesMap.put(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME, keyStoreSystemProperty);
  86         }
  87
  88         String keyStorePasswordSystemProperty =
  89                 System.getProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
  90         if (keyStorePasswordSystemProperty != null) {
  91             savedValuesMap.put(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME,
  92                     keyStorePasswordSystemProperty);
  93         }
  94
  95         String trustStoreSystemProperty = System.getProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
  96         if (trustStoreSystemProperty != null) {
  97             savedValuesMap.put(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME, trustStoreSystemProperty);
  98         }
  99
 100         String trustStorePasswordSystemProperty =
 101                 System.getProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 102         if (trustStorePasswordSystemProperty != null) {
 103             savedValuesMap.put(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME,
 104                     trustStorePasswordSystemProperty);
 105         }
 106
 107         System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME, "src/test/resources/keystore-test");
 108         System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME, "kstest");
 109
 110         System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME, "src/test/resources/keystore-test");
 111         System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME, "kstest");
 112
 113         /* echo server - https + basic auth */
 114
 115         final HttpServletServer echoServerAuth =
 116                 HttpServletServer.factory.build("echo", true, LOCALHOST, 6667, "/", false, true);
 117         echoServerAuth.setBasicAuthentication("x", "y", null);
 118         echoServerAuth.addServletPackage("/*", HttpClientTest.class.getPackage().getName());
 119         echoServerAuth.addFilterClass("/*", TestFilter.class.getName());
 120         echoServerAuth.addFilterClass("/*", TestAuthorizationFilter.class.getName());
 121         echoServerAuth.addFilterClass("/*", TestAafAuthFilter.class.getName());
 122         echoServerAuth.addFilterClass("/*", TestAafGranularAuthFilter.class.getName());
 123         echoServerAuth.waitedStart(5000);
 124
 125         if (!NetworkUtil.isTcpPortOpen(LOCALHOST, echoServerAuth.getPort(), 5, 10000L)) {
 126             throw new IllegalStateException("cannot connect to port " + echoServerAuth.getPort());
 127         }
 128     }
 129
 130     /**
 131      * Clear https clients and reset providers.
 132      */
 133     @Before
 134     public void setUp() {
 135         HttpClient.factory.destroy();
 136
 137         MyGsonProvider.resetSome();
 138         MyJacksonProvider.resetSome();
 139     }
 140
 141     /**
 142      * After the class is created method.
 143      */
 144     @AfterClass
 145     public static void tearDownAfterClass() {
 146         HttpServletServer.factory.destroy();
 147         HttpClient.factory.destroy();
 148
 149         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME)) {
 150             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME,
 151                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME));
 152             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 153         } else {
 154             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PROPERTY_NAME);
 155         }
 156
 157         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME)) {
 158             System.setProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME,
 159                     savedValuesMap.get(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME));
 160             savedValuesMap.remove(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 161         } else {
 162             System.clearProperty(JettyJerseyServer.SYSTEM_KEYSTORE_PASSWORD_PROPERTY_NAME);
 163         }
 164
 165         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME)) {
 166             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME,
 167                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME));
 168             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 169         } else {
 170             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PROPERTY_NAME);
 171         }
 172
 173         if (savedValuesMap.containsKey(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME)) {
 174             System.setProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME,
 175                     savedValuesMap.get(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME));
 176             savedValuesMap.remove(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 177         } else {
 178             System.clearProperty(JettyJerseyServer.SYSTEM_TRUSTSTORE_PASSWORD_PROPERTY_NAME);
 179         }
 180
 181
 182     }
 183
 184     @Test
 185     public void testHttpGetNoAuthClient() throws Exception {
 186         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 187             6666);
 188         final Response response = client.get(HELLO);
 189         final String body = HttpClient.getBody(response, String.class);
 190
 191         assertEquals(200, response.getStatus());
 192         assertEquals(HELLO, body);
 193     }
 194
 195     @Test
 196     public void testHttpPutNoAuthClient() throws Exception {
 197         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false, 6666);
 198
 199         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 200         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 201         final String body = HttpClient.getBody(response, String.class);
 202
 203         assertEquals(200, response.getStatus());
 204         assertEquals(PUT_HELLO, body);
 205     }
 206
 207     @Test
 208     public void testHttpPostNoAuthClient() throws Exception {
 209         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 210             6666);
 211
 212         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 213         final Response response = client.post(HELLO, entity, Collections.emptyMap());
 214         final String body = HttpClient.getBody(response, String.class);
 215
 216         assertEquals(200, response.getStatus());
 217         assertEquals("POST:hello:{myParameter=myValue}", body);
 218     }
 219
 220     @Test
 221     public void testHttpDeletetNoAuthClient() throws Exception {
 222         final HttpClient client = getNoAuthHttpClient(TEST_HTTP_NO_AUTH_CLIENT, false,
 223             6666);
 224
 225         final Response response = client.delete(HELLO, Collections.emptyMap());
 226         final String body = HttpClient.getBody(response, String.class);
 227
 228         assertEquals(200, response.getStatus());
 229         assertEquals("DELETE:hello", body);
 230     }
 231
 232     @Test
 233     public void testHttpGetAuthClient() throws Exception {
 234         final HttpClient client = getAuthHttpClient();
 235
 236         final Response response = client.get(HELLO);
 237         final String body = HttpClient.getBody(response, String.class);
 238
 239         assertEquals(200, response.getStatus());
 240         assertEquals(HELLO, body);
 241     }
 242
 243     @Test
 244     public void testHttpPutAuthClient() throws Exception {
 245         final HttpClient client = getAuthHttpClient();
 246
 247         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 248         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 249         final String body = HttpClient.getBody(response, String.class);
 250
 251         assertEquals(200, response.getStatus());
 252         assertEquals(PUT_HELLO, body);
 253     }
 254
 255     @Test
 256     public void testHttpPutAuthClient_JacksonProvider() throws Exception {
 257         final HttpClient client = HttpClient.factory.build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT)
 258                         .useHttps(true).allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667)
 259                         .basePath(JUNIT_ECHO).userName("x").password("y").managed(true)
 260                         .serializationProvider(MyJacksonProvider.class.getName()).build());
 261
 262         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 263         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 264         final String body = HttpClient.getBody(response, String.class);
 265
 266         assertEquals(200, response.getStatus());
 267         assertEquals(PUT_HELLO, body);
 268
 269         assertTrue(MyJacksonProvider.hasWrittenSome());
 270
 271         assertFalse(MyGsonProvider.hasWrittenSome());
 272     }
 273
 274     @Test
 275     public void testHttpPutAuthClient_GsonProvider() throws Exception {
 276         final HttpClient client = HttpClient.factory.build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT)
 277                         .useHttps(true).allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667)
 278                         .basePath(JUNIT_ECHO).userName("x").password("y").managed(true)
 279                         .serializationProvider(MyGsonProvider.class.getName()).build());
 280
 281         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 282         final Response response = client.put(HELLO, entity, Collections.emptyMap());
 283         final String body = HttpClient.getBody(response, String.class);
 284
 285         assertEquals(200, response.getStatus());
 286         assertEquals(PUT_HELLO, body);
 287
 288         assertTrue(MyGsonProvider.hasWrittenSome());
 289
 290         assertFalse(MyJacksonProvider.hasWrittenSome());
 291     }
 292
 293     @Test
 294     public void testHttpAuthClient401() throws Exception {
 295         final HttpClient client = getNoAuthHttpClient("testHttpAuthClient401", true,
 296             6667);
 297         final Response response = client.get(HELLO);
 298         assertEquals(401, response.getStatus());
 299     }
 300
 301     @Test
 302     public void testHttpAuthClientProps() throws Exception {
 303         final Properties httpProperties = new Properties();
 304
 305         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES, "PAP,PDP");
 306         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 307                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 308         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 309                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 310         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 311                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 312         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 313                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 314         httpProperties.setProperty(
 315                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 316                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 317                         RestMockHealthCheck.class.getName());
 318         httpProperties.setProperty(
 319                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PAP
 320                                         + PolicyEndPointProperties.PROPERTY_HTTP_FILTER_CLASSES_SUFFIX,
 321                         TestFilter.class.getName());
 322         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 323                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 324
 325         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 326                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 327         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 328                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 329         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 330                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 331         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 332                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 333         httpProperties.setProperty(
 334                         PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + DOT_PDP
 335                                         + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX,
 336                         RestMockHealthCheck.class.getName());
 337         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 338                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 339
 340         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES, "PAP,PDP");
 341         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 342                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 343         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 344                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7777");
 345         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 346                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, "pap/test");
 347         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 348                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 349         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 350                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpap");
 351         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 352                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 353         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PAP
 354                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 355
 356         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 357                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 358         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 359                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "7778");
 360         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 361                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, "pdp");
 362         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 363                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 364         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 365                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX, "testpdp");
 366         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 367                         + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX, ALPHA123);
 368         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_PDP
 369                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 370
 371         final List<HttpServletServer> servers = HttpServletServer.factory.build(httpProperties);
 372         assertEquals(2, servers.size());
 373
 374         final List<HttpClient> clients = HttpClient.factory.build(httpProperties);
 375         assertEquals(2, clients.size());
 376
 377         for (final HttpServletServer server : servers) {
 378             server.waitedStart(10000);
 379         }
 380
 381         final HttpClient clientPap = HttpClient.factory.get("PAP");
 382         final Response response = clientPap.get();
 383         assertEquals(200, response.getStatus());
 384
 385         final HttpClient clientPdp = HttpClient.factory.get("PDP");
 386         final Response response2 = clientPdp.get("test");
 387         assertEquals(500, response2.getStatus());
 388
 389         assertFalse(MyJacksonProvider.hasWrittenSome());
 390         assertFalse(MyGsonProvider.hasWrittenSome());
 391     }
 392
 393     @Test
 394     public void testHttpAuthClientProps_MixedProviders() throws Exception {
 395         final Properties httpProperties = new Properties();
 396
 397         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES, "GSON,JACKSON");
 398         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 399                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 400         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 401                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "6666");
 402         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 403                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, JUNIT_ECHO);
 404         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 405                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 406         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 407                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 408         httpProperties.setProperty(
 409                         PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_GSON
 410                                         + PolicyEndPointProperties.PROPERTY_HTTP_SERIALIZATION_PROVIDER,
 411                         MyGsonProvider.class.getName());
 412
 413         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 414                         + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX, LOCALHOST);
 415         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 416                         + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX, "6666");
 417         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 418                         + PolicyEndPointProperties.PROPERTY_HTTP_URL_SUFFIX, JUNIT_ECHO);
 419         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 420                         + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX, FALSE_STRING);
 421         httpProperties.setProperty(PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 422                         + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX, "true");
 423         httpProperties.setProperty(
 424                         PolicyEndPointProperties.PROPERTY_HTTP_CLIENT_SERVICES + DOT_JACKSON
 425                                         + PolicyEndPointProperties.PROPERTY_HTTP_SERIALIZATION_PROVIDER,
 426                         MyJacksonProvider.class.getName());
 427
 428         final List<HttpClient> clients = HttpClient.factory.build(httpProperties);
 429         assertEquals(2, clients.size());
 430
 431         Entity<MyEntity> entity = Entity.entity(new MyEntity(MY_VALUE), MediaType.APPLICATION_JSON);
 432
 433         // use gson client
 434         MyGsonProvider.resetSome();
 435         MyJacksonProvider.resetSome();
 436         HttpClient client = HttpClient.factory.get("GSON");
 437
 438         Response response = client.put(HELLO, entity, Collections.emptyMap());
 439         String body = HttpClient.getBody(response, String.class);
 440
 441         assertEquals(200, response.getStatus());
 442         assertEquals(PUT_HELLO, body);
 443
 444         assertTrue(MyGsonProvider.hasWrittenSome());
 445         assertFalse(MyJacksonProvider.hasWrittenSome());
 446
 447         // use jackson client
 448         MyGsonProvider.resetSome();
 449         MyJacksonProvider.resetSome();
 450         client = HttpClient.factory.get("JACKSON");
 451
 452         response = client.put(HELLO, entity, Collections.emptyMap());
 453         body = HttpClient.getBody(response, String.class);
 454
 455         assertEquals(200, response.getStatus());
 456         assertEquals(PUT_HELLO, body);
 457
 458         assertTrue(MyJacksonProvider.hasWrittenSome());
 459         assertFalse(MyGsonProvider.hasWrittenSome());
 460     }
 461
 462     private HttpClient getAuthHttpClient()
 463                     throws KeyManagementException, NoSuchAlgorithmException, ClassNotFoundException {
 464         return HttpClient.factory.build(BusTopicParams.builder().clientName(TEST_HTTP_AUTH_CLIENT)
 465             .useHttps(true).allowSelfSignedCerts(true).hostname(LOCALHOST).port(6667).basePath(JUNIT_ECHO)
 466             .userName("x").password("y").managed(true).build());
 467     }
 468
 469     private HttpClient getNoAuthHttpClient(String clientName, boolean https, int port)
 470         throws KeyManagementException, NoSuchAlgorithmException, ClassNotFoundException {
 471         return HttpClient.factory.build(BusTopicParams.builder().clientName(clientName)
 472             .useHttps(https).allowSelfSignedCerts(https).hostname(LOCALHOST).port(port).basePath(JUNIT_ECHO)
 473             .userName(null).password(null).managed(true).build());
 474     }
 475
 476
 477     class MyEntity {
 478
 479         private String myParameter;
 480
 481         public MyEntity(final String myParameter) {
 482             this.myParameter = myParameter;
 483         }
 484
 485         public void setMyParameter(final String myParameter) {
 486             this.myParameter = myParameter;
 487         }
 488
 489         public String getMyParameter() {
 490             return myParameter;
 491         }
 492
 493     }
 494
 495 }