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