src/test/java/org/onap/aai/restclient/client/RestfulClientTest.java

   1 /*
   2  * ============LICENSE_START===========================================================================================
   3  * Copyright (c) 2017 AT&T Intellectual Property.
   4  * Copyright (c) 2017 Amdocs
   5  * All rights reserved.
   6  * =====================================================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  13  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  14  * specific language governing permissions and limitations under the License.
  15  * ============LICENSE_END================================================== ===========================================
  16  *
  17  * ECOMP and OpenECOMP are trademarks and service marks of AT&T Intellectual Property.
  18  */
  19 package org.onap.aai.restclient.client;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertNotNull;
  23 import static org.junit.Assert.assertNull;
  24
  25 import javax.ws.rs.core.MediaType;
  26 import javax.ws.rs.core.Response;
  27 import javax.ws.rs.core.Response.Status;
  28
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.mockito.ArgumentCaptor;
  32 import org.mockito.Mockito;
  33 import org.onap.aai.restclient.client.OperationResult;
  34 import org.onap.aai.restclient.client.RestClient;
  35 import org.onap.aai.restclient.enums.RestAuthenticationMode;
  36 import org.onap.aai.restclient.rest.RestClientBuilder;
  37
  38 import com.sun.jersey.api.client.Client;
  39 import com.sun.jersey.api.client.ClientResponse;
  40 import com.sun.jersey.api.client.UniformInterfaceException;
  41 import com.sun.jersey.api.client.WebResource;
  42 import com.sun.jersey.api.client.WebResource.Builder;
  43 import com.sun.jersey.core.util.MultivaluedMapImpl;
  44
  45 public class RestfulClientTest {
  46
  47     private static final String TEST_URL = "http://localhost:9000/aai/v7";
  48
  49     private final MultivaluedMapImpl emptyMap = new MultivaluedMapImpl();
  50
  51     private RestClientBuilder mockClientBuilder;
  52     private Client mockedClient;
  53     private WebResource mockedWebResource;
  54     private Builder mockedBuilder;
  55     private ClientResponse mockedClientResponse;
  56
  57     /**
  58      * Test case initialization
  59      *
  60      * @throws Exception the exception
  61      */
  62     @SuppressWarnings("unchecked")
  63     @Before
  64     public void init() throws Exception {
  65         mockedClientResponse = Mockito.mock(ClientResponse.class);
  66         setResponseStatus(Response.Status.OK);
  67         Mockito.when(mockedClientResponse.getHeaders()).thenReturn(emptyMap);
  68         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("hello");
  69
  70         mockedBuilder = Mockito.mock(Builder.class);
  71         Mockito.when(mockedBuilder.get(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  72         Mockito.when(mockedBuilder.post(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  73         Mockito.when(mockedBuilder.put(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  74         Mockito.when(mockedBuilder.delete(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  75         Mockito.when(mockedBuilder.head()).thenReturn(mockedClientResponse);
  76
  77         mockedWebResource = Mockito.mock(WebResource.class);
  78         Mockito.when(mockedWebResource.accept(Mockito.<MediaType>anyVararg())).thenReturn(mockedBuilder);
  79
  80         mockedClient = Mockito.mock(Client.class);
  81         Mockito.when(mockedClient.resource(Mockito.anyString())).thenReturn(mockedWebResource);
  82
  83         mockClientBuilder = Mockito.mock(RestClientBuilder.class);
  84         Mockito.when(mockClientBuilder.getClient()).thenReturn(mockedClient);
  85     }
  86
  87     @Test
  88     public void validateConstructors() {
  89         RestClient restClient = new RestClient();
  90         assertNotNull(restClient);
  91         restClient = new RestClient(mockClientBuilder);
  92         assertNotNull(restClient);
  93     }
  94
  95     @Test
  96     public void validateBasicClientConstruction() throws Exception {
  97         Client client = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.HTTP_NOAUTH)
  98                 .connectTimeoutMs(1000).readTimeoutMs(500).getClient();
  99         assertNotNull(client);
 100     }
 101
 102     @Test
 103     public void validateClientWithSslBasicAuthConstruction() throws Exception {
 104         Client client = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_BASIC)
 105                 .connectTimeoutMs(1000).readTimeoutMs(500).basicAuthPassword("password").basicAuthUsername("username")
 106                 .getClient();
 107         assertNotNull(client);
 108     }
 109
 110     @Test
 111     public void validateClientWithSslCertConstruction() throws Exception {
 112         // This test covers the standard SSL settings, i.e. no validation
 113         assertNotNull(buildClient());
 114
 115         RestClient restClient = new RestClient(mockClientBuilder);
 116
 117         // Test with validation enabled
 118         Client client = restClient.authenticationMode(RestAuthenticationMode.SSL_CERT).connectTimeoutMs(1000)
 119                 .readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password").validateServerCertChain(true)
 120                 .validateServerHostname(true).getClient();
 121         assertNotNull(client);
 122
 123         // Test with a trust store
 124         client = restClient.authenticationMode(RestAuthenticationMode.SSL_CERT).connectTimeoutMs(1000)
 125                 .readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password").trustStore("truststore")
 126                 .getClient();
 127         assertNotNull(client);
 128     }
 129
 130     @Test
 131     public void validateSuccessfulPut() throws Exception {
 132         RestClient restClient = buildClient();
 133
 134         OperationResult result = restClient.put(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 135                 MediaType.APPLICATION_JSON_TYPE);
 136
 137         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 138         assertNotNull(result.getResult());
 139         assertNull(result.getFailureCause());
 140
 141         // Repeat the PUT operation, this time with a return code of 204
 142         setResponseToNoContent();
 143         result = restClient.put(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 144                 MediaType.APPLICATION_JSON_TYPE);
 145
 146         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 147         assertNull(result.getResult());
 148         assertNull(result.getFailureCause());
 149     }
 150
 151     @Test
 152     public void validateSuccessfulPost() throws Exception {
 153         RestClient restClient = buildClient();
 154
 155         OperationResult result = restClient.post(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 156                 MediaType.APPLICATION_JSON_TYPE);
 157
 158         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 159         assertNotNull(result.getResult());
 160         assertNull(result.getFailureCause());
 161
 162         // Repeat the POST operation, this time with a return code of 204
 163         setResponseToNoContent();
 164         result = restClient.post(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 165                 MediaType.APPLICATION_JSON_TYPE);
 166
 167         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 168         assertNull(result.getResult());
 169         assertNull(result.getFailureCause());
 170     }
 171
 172     @Test
 173     public void validateSuccessfulPost_withMultivaluedHeader() throws Exception {
 174         RestClient restClient = buildClient();
 175
 176         MultivaluedMapImpl headerMap = new MultivaluedMapImpl();
 177
 178         headerMap.add("txnId", "123");
 179         headerMap.add("txnId", "456");
 180         headerMap.add("txnId", "789");
 181
 182         OperationResult result = restClient.post(TEST_URL, "", headerMap, MediaType.APPLICATION_JSON_TYPE,
 183             MediaType.APPLICATION_JSON_TYPE);
 184
 185         // capture the txnId header from the outgoing request
 186         ArgumentCaptor<String> txnIdHeaderName = ArgumentCaptor.forClass(String.class);
 187         ArgumentCaptor<String> txnIdHeaderValue = ArgumentCaptor.forClass(String.class);
 188
 189         Mockito.verify(mockedBuilder, Mockito.atLeast(1)).header(txnIdHeaderName.capture(), txnIdHeaderValue.capture());
 190         assertEquals("123;456;789", txnIdHeaderValue.getValue());
 191
 192         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 193         assertNotNull(result.getResult());
 194         assertNull(result.getFailureCause());
 195     }
 196
 197     @Test
 198     public void validateSuccessfulGet() throws Exception {
 199         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 200
 201         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 202         assertNotNull(result.getResult());
 203         assertNull(result.getFailureCause());
 204     }
 205
 206     @Test
 207     public void validateSuccessfulGetWithBasicAuth() throws Exception {
 208         RestClient restClient = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_BASIC)
 209                 .connectTimeoutMs(1000).readTimeoutMs(500).basicAuthUsername("username").basicAuthUsername("password");
 210
 211         OperationResult result = restClient.get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 212
 213         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 214         assertNotNull(result.getResult());
 215         assertNull(result.getFailureCause());
 216     }
 217
 218     @Test
 219     public void validateResourceNotFoundGet() throws Exception {
 220         setResponseStatus(Response.Status.NOT_FOUND);
 221         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("RNF");
 222
 223         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 224
 225         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), result.getResultCode());
 226         assertNull(result.getResult());
 227         assertNotNull(result.getFailureCause());
 228     }
 229
 230     @Test
 231     public void validateHealthCheck() throws Exception {
 232         boolean targetServiceHealthy =
 233                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 234
 235         assertEquals(true, targetServiceHealthy);
 236     }
 237
 238     @Test
 239     public void validateHealthCheckFailureWith403() throws Exception {
 240         Mockito.when(mockedClientResponse.getStatus()).thenReturn(Response.Status.FORBIDDEN.getStatusCode());
 241
 242         boolean targetServiceHealthy =
 243                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 244
 245         assertEquals(false, targetServiceHealthy);
 246     }
 247
 248     @Test
 249     public void validateHealthCheckFailureWithThrownException() throws Exception {
 250         Mockito.when(mockedBuilder.get(Mockito.any(Class.class))).thenThrow(new IllegalArgumentException("error"));
 251
 252         boolean targetServiceHealthy =
 253                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 254
 255         assertEquals(false, targetServiceHealthy);
 256     }
 257
 258     @Test
 259     public void validateSuccessfulGetWithRetries() throws Exception {
 260         Mockito.when(mockedClientResponse.getStatus()).thenReturn(408).thenReturn(Response.Status.OK.getStatusCode());
 261         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error").thenReturn("ok");
 262
 263         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 264
 265         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 266         assertNotNull(result.getResult());
 267         assertNull(result.getFailureCause());
 268
 269     }
 270
 271     @Test
 272     public void validateFailedGetWithRetriesCausedByResourceNotFound() throws Exception {
 273         setResponseStatus(Response.Status.NOT_FOUND);
 274         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error").thenReturn("ok");
 275
 276         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 277
 278         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), result.getResultCode());
 279         assertNull(result.getResult());
 280         assertNotNull(result.getFailureCause());
 281
 282     }
 283
 284     @Test
 285     public void validateFailedGetAfterMaxRetries() throws Exception {
 286         setResponseStatus(Response.Status.INTERNAL_SERVER_ERROR);
 287         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error");
 288
 289         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 290
 291         assertEquals(504, result.getResultCode());
 292         assertNull(result.getResult());
 293         assertNotNull(result.getFailureCause());
 294
 295     }
 296
 297     @Test
 298     public void validateSuccessfulDelete() throws Exception {
 299         RestClient restClient = buildClient();
 300
 301         OperationResult result = restClient.delete(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 302
 303         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 304         assertNotNull(result.getResult());
 305         assertNull(result.getFailureCause());
 306
 307         // Repeat the DELETE operation, this time with a return code of 204
 308         setResponseToNoContent();
 309         result = restClient.delete(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 310
 311         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 312         assertNull(result.getResult());
 313         assertNull(result.getFailureCause());
 314     }
 315
 316
 317     @Test
 318     public void validateSuccessfulHead() throws Exception {
 319         OperationResult result = buildClient().head(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 320
 321         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 322         assertNotNull(result.getResult());
 323         assertNull(result.getFailureCause());
 324
 325     }
 326
 327     @Test
 328     public void validateSuccessfulPatch() throws Exception {
 329         Mockito.when(mockedBuilder.header("X-HTTP-Method-Override", "PATCH")).thenReturn(mockedBuilder);
 330         OperationResult result = buildClient().patch(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 331                 MediaType.APPLICATION_JSON_TYPE);
 332
 333         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 334         assertNotNull(result.getResult());
 335         assertNull(result.getFailureCause());
 336
 337     }
 338
 339     /**
 340      * Specify the status code of the response object returned by the mocked client
 341      *
 342      * @param status object storing the status code to mock in the ClientResponse
 343      */
 344     private void setResponseStatus(Status status) {
 345         Mockito.when(mockedClientResponse.getStatus()).thenReturn(status.getStatusCode());
 346     }
 347
 348     /**
 349      * Set the mocked client to return a response of "204 No Content"
 350      */
 351     private void setResponseToNoContent() {
 352         setResponseStatus(Response.Status.NO_CONTENT);
 353         // The Jersey client throws an exception when getEntity() is called following a 204 response
 354         UniformInterfaceException uniformInterfaceException = new UniformInterfaceException(mockedClientResponse);
 355         Mockito.when(mockedClientResponse.getEntity(String.class)).thenThrow(uniformInterfaceException);
 356     }
 357
 358     /**
 359      * @return a mocked Rest Client object using standard SSL settings
 360      */
 361     private RestClient buildClient() {
 362         return new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_CERT)
 363                 .connectTimeoutMs(1000).readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password");
 364     }
 365
 366 }