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.Mockito;
  32 import org.onap.aai.restclient.client.OperationResult;
  33 import org.onap.aai.restclient.client.RestClient;
  34 import org.onap.aai.restclient.enums.RestAuthenticationMode;
  35 import org.onap.aai.restclient.rest.RestClientBuilder;
  36
  37 import com.sun.jersey.api.client.Client;
  38 import com.sun.jersey.api.client.ClientResponse;
  39 import com.sun.jersey.api.client.UniformInterfaceException;
  40 import com.sun.jersey.api.client.WebResource;
  41 import com.sun.jersey.api.client.WebResource.Builder;
  42 import com.sun.jersey.core.util.MultivaluedMapImpl;
  43
  44 public class RestfulClientTest {
  45
  46     private static final String TEST_URL = "http://localhost:9000/aai/v7";
  47
  48     private final MultivaluedMapImpl emptyMap = new MultivaluedMapImpl();
  49
  50     private RestClientBuilder mockClientBuilder;
  51     private Client mockedClient;
  52     private WebResource mockedWebResource;
  53     private Builder mockedBuilder;
  54     private ClientResponse mockedClientResponse;
  55
  56     /**
  57      * Test case initialization
  58      *
  59      * @throws Exception the exception
  60      */
  61     @SuppressWarnings("unchecked")
  62     @Before
  63     public void init() throws Exception {
  64         mockedClientResponse = Mockito.mock(ClientResponse.class);
  65         setResponseStatus(Response.Status.OK);
  66         Mockito.when(mockedClientResponse.getHeaders()).thenReturn(emptyMap);
  67         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("hello");
  68
  69         mockedBuilder = Mockito.mock(Builder.class);
  70         Mockito.when(mockedBuilder.get(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  71         Mockito.when(mockedBuilder.post(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  72         Mockito.when(mockedBuilder.put(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  73         Mockito.when(mockedBuilder.delete(Mockito.any(Class.class))).thenReturn(mockedClientResponse);
  74         Mockito.when(mockedBuilder.head()).thenReturn(mockedClientResponse);
  75
  76         mockedWebResource = Mockito.mock(WebResource.class);
  77         Mockito.when(mockedWebResource.accept(Mockito.<MediaType>anyVararg())).thenReturn(mockedBuilder);
  78
  79         mockedClient = Mockito.mock(Client.class);
  80         Mockito.when(mockedClient.resource(Mockito.anyString())).thenReturn(mockedWebResource);
  81
  82         mockClientBuilder = Mockito.mock(RestClientBuilder.class);
  83         Mockito.when(mockClientBuilder.getClient()).thenReturn(mockedClient);
  84     }
  85
  86     @Test
  87     public void validateConstructors() {
  88         RestClient restClient = new RestClient();
  89         assertNotNull(restClient);
  90         restClient = new RestClient(mockClientBuilder);
  91         assertNotNull(restClient);
  92     }
  93
  94     @Test
  95     public void validateBasicClientConstruction() throws Exception {
  96         Client client = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.HTTP_NOAUTH)
  97                 .connectTimeoutMs(1000).readTimeoutMs(500).getClient();
  98         assertNotNull(client);
  99     }
 100
 101     @Test
 102     public void validateClientWithSslBasicAuthConstruction() throws Exception {
 103         Client client = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_BASIC)
 104                 .connectTimeoutMs(1000).readTimeoutMs(500).basicAuthPassword("password").basicAuthUsername("username")
 105                 .getClient();
 106         assertNotNull(client);
 107     }
 108
 109     @Test
 110     public void validateClientWithSslCertConstruction() throws Exception {
 111         // This test covers the standard SSL settings, i.e. no validation
 112         assertNotNull(buildClient());
 113
 114         RestClient restClient = new RestClient(mockClientBuilder);
 115
 116         // Test with validation enabled
 117         Client client = restClient.authenticationMode(RestAuthenticationMode.SSL_CERT).connectTimeoutMs(1000)
 118                 .readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password").validateServerCertChain(true)
 119                 .validateServerHostname(true).getClient();
 120         assertNotNull(client);
 121
 122         // Test with a trust store
 123         client = restClient.authenticationMode(RestAuthenticationMode.SSL_CERT).connectTimeoutMs(1000)
 124                 .readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password").trustStore("truststore")
 125                 .getClient();
 126         assertNotNull(client);
 127     }
 128
 129     @Test
 130     public void validateSuccessfulPut() throws Exception {
 131         RestClient restClient = buildClient();
 132
 133         OperationResult result = restClient.put(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 134                 MediaType.APPLICATION_JSON_TYPE);
 135
 136         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 137         assertNotNull(result.getResult());
 138         assertNull(result.getFailureCause());
 139
 140         // Repeat the PUT operation, this time with a return code of 204
 141         setResponseToNoContent();
 142         result = restClient.put(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 143                 MediaType.APPLICATION_JSON_TYPE);
 144
 145         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 146         assertNull(result.getResult());
 147         assertNull(result.getFailureCause());
 148     }
 149
 150     @Test
 151     public void validateSuccessfulPost() throws Exception {
 152         RestClient restClient = buildClient();
 153
 154         OperationResult result = restClient.post(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 155                 MediaType.APPLICATION_JSON_TYPE);
 156
 157         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 158         assertNotNull(result.getResult());
 159         assertNull(result.getFailureCause());
 160
 161         // Repeat the POST operation, this time with a return code of 204
 162         setResponseToNoContent();
 163         result = restClient.post(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 164                 MediaType.APPLICATION_JSON_TYPE);
 165
 166         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 167         assertNull(result.getResult());
 168         assertNull(result.getFailureCause());
 169     }
 170
 171     @Test
 172     public void validateSuccessfulGet() throws Exception {
 173         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 174
 175         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 176         assertNotNull(result.getResult());
 177         assertNull(result.getFailureCause());
 178     }
 179
 180     @Test
 181     public void validateSuccessfulGetWithBasicAuth() throws Exception {
 182         RestClient restClient = new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_BASIC)
 183                 .connectTimeoutMs(1000).readTimeoutMs(500).basicAuthUsername("username").basicAuthUsername("password");
 184
 185         OperationResult result = restClient.get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 186
 187         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 188         assertNotNull(result.getResult());
 189         assertNull(result.getFailureCause());
 190     }
 191
 192     @Test
 193     public void validateResourceNotFoundGet() throws Exception {
 194         setResponseStatus(Response.Status.NOT_FOUND);
 195         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("RNF");
 196
 197         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 198
 199         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), result.getResultCode());
 200         assertNull(result.getResult());
 201         assertNotNull(result.getFailureCause());
 202     }
 203
 204     @Test
 205     public void validateHealthCheck() throws Exception {
 206         boolean targetServiceHealthy =
 207                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 208
 209         assertEquals(true, targetServiceHealthy);
 210     }
 211
 212     @Test
 213     public void validateHealthCheckFailureWith403() throws Exception {
 214         Mockito.when(mockedClientResponse.getStatus()).thenReturn(Response.Status.FORBIDDEN.getStatusCode());
 215
 216         boolean targetServiceHealthy =
 217                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 218
 219         assertEquals(false, targetServiceHealthy);
 220     }
 221
 222     @Test
 223     public void validateHealthCheckFailureWithThrownException() throws Exception {
 224         Mockito.when(mockedBuilder.get(Mockito.any(Class.class))).thenThrow(new IllegalArgumentException("error"));
 225
 226         boolean targetServiceHealthy =
 227                 buildClient().healthCheck("http://localhost:9000/aai/util/echo", "startSerice", "targetService");
 228
 229         assertEquals(false, targetServiceHealthy);
 230     }
 231
 232     @Test
 233     public void validateSuccessfulGetWithRetries() throws Exception {
 234         Mockito.when(mockedClientResponse.getStatus()).thenReturn(408).thenReturn(Response.Status.OK.getStatusCode());
 235         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error").thenReturn("ok");
 236
 237         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 238
 239         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 240         assertNotNull(result.getResult());
 241         assertNull(result.getFailureCause());
 242
 243     }
 244
 245     @Test
 246     public void validateFailedGetWithRetriesCausedByResourceNotFound() throws Exception {
 247         setResponseStatus(Response.Status.NOT_FOUND);
 248         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error").thenReturn("ok");
 249
 250         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 251
 252         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), result.getResultCode());
 253         assertNull(result.getResult());
 254         assertNotNull(result.getFailureCause());
 255
 256     }
 257
 258     @Test
 259     public void validateFailedGetAfterMaxRetries() throws Exception {
 260         setResponseStatus(Response.Status.INTERNAL_SERVER_ERROR);
 261         Mockito.when(mockedClientResponse.getEntity(String.class)).thenReturn("error");
 262
 263         OperationResult result = buildClient().get(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE, 3);
 264
 265         assertEquals(504, result.getResultCode());
 266         assertNull(result.getResult());
 267         assertNotNull(result.getFailureCause());
 268
 269     }
 270
 271     @Test
 272     public void validateSuccessfulDelete() throws Exception {
 273         RestClient restClient = buildClient();
 274
 275         OperationResult result = restClient.delete(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 276
 277         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 278         assertNotNull(result.getResult());
 279         assertNull(result.getFailureCause());
 280
 281         // Repeat the DELETE operation, this time with a return code of 204
 282         setResponseToNoContent();
 283         result = restClient.delete(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 284
 285         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), result.getResultCode());
 286         assertNull(result.getResult());
 287         assertNull(result.getFailureCause());
 288     }
 289
 290
 291     @Test
 292     public void validateSuccessfulHead() throws Exception {
 293         OperationResult result = buildClient().head(TEST_URL, emptyMap, MediaType.APPLICATION_JSON_TYPE);
 294
 295         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 296         assertNotNull(result.getResult());
 297         assertNull(result.getFailureCause());
 298
 299     }
 300
 301     @Test
 302     public void validateSuccessfulPatch() throws Exception {
 303         Mockito.when(mockedBuilder.header("X-HTTP-Method-Override", "PATCH")).thenReturn(mockedBuilder);
 304         OperationResult result = buildClient().patch(TEST_URL, "", emptyMap, MediaType.APPLICATION_JSON_TYPE,
 305                 MediaType.APPLICATION_JSON_TYPE);
 306
 307         assertEquals(Response.Status.OK.getStatusCode(), result.getResultCode());
 308         assertNotNull(result.getResult());
 309         assertNull(result.getFailureCause());
 310
 311     }
 312
 313     /**
 314      * Specify the status code of the response object returned by the mocked client
 315      *
 316      * @param status object storing the status code to mock in the ClientResponse
 317      */
 318     private void setResponseStatus(Status status) {
 319         Mockito.when(mockedClientResponse.getStatus()).thenReturn(status.getStatusCode());
 320     }
 321
 322     /**
 323      * Set the mocked client to return a response of "204 No Content"
 324      */
 325     private void setResponseToNoContent() {
 326         setResponseStatus(Response.Status.NO_CONTENT);
 327         // The Jersey client throws an exception when getEntity() is called following a 204 response
 328         UniformInterfaceException uniformInterfaceException = new UniformInterfaceException(mockedClientResponse);
 329         Mockito.when(mockedClientResponse.getEntity(String.class)).thenThrow(uniformInterfaceException);
 330     }
 331
 332     /**
 333      * @return a mocked Rest Client object using standard SSL settings
 334      */
 335     private RestClient buildClient() {
 336         return new RestClient(mockClientBuilder).authenticationMode(RestAuthenticationMode.SSL_CERT)
 337                 .connectTimeoutMs(1000).readTimeoutMs(500).clientCertFile("cert").clientCertPassword("password");
 338     }
 339
 340 }