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