vid-app-common/src/test/java/org/onap/vid/mso/rest/OutgoingRequestHeadersTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.vid.mso.rest;
  22
  23 import static org.apache.commons.io.IOUtils.toInputStream;
  24 import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
  25 import static org.apache.commons.lang3.StringUtils.equalsIgnoreCase;
  26 import static org.hamcrest.CoreMatchers.is;
  27 import static org.hamcrest.CoreMatchers.startsWith;
  28 import static org.hamcrest.MatcherAssert.assertThat;
  29 import static org.hamcrest.Matchers.allOf;
  30 import static org.hamcrest.Matchers.hasItem;
  31 import static org.hamcrest.Matchers.hasToString;
  32 import static org.hamcrest.Matchers.instanceOf;
  33 import static org.hamcrest.Matchers.matchesPattern;
  34 import static org.junit.Assert.assertEquals;
  35 import static org.junit.Assert.assertNotEquals;
  36 import static org.mockito.ArgumentMatchers.any;
  37 import static org.mockito.ArgumentMatchers.anyMap;
  38 import static org.mockito.ArgumentMatchers.anyString;
  39 import static org.mockito.ArgumentMatchers.eq;
  40 import static org.mockito.Mockito.mock;
  41 import static org.mockito.Mockito.reset;
  42 import static org.mockito.Mockito.when;
  43
  44 import com.google.common.collect.ImmutableList;
  45 import io.joshworks.restclient.http.HttpResponse;
  46 import java.nio.charset.StandardCharsets;
  47 import java.util.Map;
  48 import java.util.Optional;
  49 import java.util.Set;
  50 import java.util.UUID;
  51 import java.util.function.Consumer;
  52 import java.util.stream.Collectors;
  53 import java.util.stream.Stream;
  54 import javax.servlet.http.HttpServletRequest;
  55 import javax.ws.rs.client.Client;
  56 import javax.ws.rs.client.Invocation;
  57 import javax.ws.rs.client.Invocation.Builder;
  58 import javax.ws.rs.core.MultivaluedMap;
  59 import org.apache.commons.lang3.reflect.FieldUtils;
  60 import org.mockito.ArgumentCaptor;
  61 import org.mockito.Captor;
  62 import org.mockito.InjectMocks;
  63 import org.mockito.Matchers;
  64 import org.mockito.Mock;
  65 import org.mockito.Mockito;
  66 import org.mockito.MockitoAnnotations;
  67 import org.onap.portalsdk.core.util.SystemProperties;
  68 import org.onap.vid.aai.util.HttpsAuthClient;
  69 import org.onap.vid.aai.util.ServletRequestHelper;
  70 import org.onap.vid.aai.util.SystemPropertyHelper;
  71 import org.onap.vid.client.SyncRestClient;
  72 import org.onap.vid.controller.filter.PromiseRequestIdFilter;
  73 import org.onap.vid.logging.Headers;
  74 import org.onap.vid.mso.MsoProperties;
  75 import org.onap.vid.mso.RestMsoImplementation;
  76 import org.onap.vid.testUtils.TestUtils;
  77 import org.onap.vid.utils.Logging;
  78 import org.onap.vid.utils.SystemPropertiesWrapper;
  79 import org.springframework.http.HttpMethod;
  80 import org.springframework.mock.web.MockHttpServletRequest;
  81 import org.springframework.web.context.request.RequestContextHolder;
  82 import org.springframework.web.context.request.ServletRequestAttributes;
  83 import org.testng.annotations.BeforeClass;
  84 import org.testng.annotations.BeforeMethod;
  85 import org.testng.annotations.DataProvider;
  86 import org.testng.annotations.Test;
  87
  88
  89 public class OutgoingRequestHeadersTest {
  90
  91     private static final PromiseRequestIdFilter promiseRequestIdFilter = new PromiseRequestIdFilter();
  92
  93     @InjectMocks
  94     private RestMsoImplementation restMsoImplementation;
  95
  96     private MsoRestClientNew msoRestClientNew;
  97
  98     @Mock
  99     private SystemPropertyHelper systemPropertyHelper;
 100
 101     @Mock
 102     private SystemPropertiesWrapper  systemPropertiesWrapper;
 103
 104     @Mock
 105     private HttpsAuthClient httpsAuthClient;
 106
 107     @Mock
 108     private ServletRequestHelper servletRequestHelper;
 109
 110     @Mock
 111     private Logging loggingService;
 112
 113     @Mock
 114     SyncRestClient syncRestClient;
 115
 116     @Captor
 117     private ArgumentCaptor<MultivaluedMap<String, Object>> multivaluedMapArgumentCaptor;
 118
 119     @BeforeClass
 120     public void initMocks() {
 121         MockitoAnnotations.initMocks(this);
 122         String oneIncomingRequestId = UUID.randomUUID().toString();
 123         when(servletRequestHelper.extractOrGenerateRequestId()).thenReturn(oneIncomingRequestId);
 124         when(systemPropertiesWrapper.getProperty(MsoProperties.MSO_PASSWORD)).thenReturn("OBF:1vub1ua51uh81ugi1u9d1vuz");
 125         when(systemPropertiesWrapper.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenReturn("vid");
 126         //the ctor of MsoRestClientNew require the above lines as preconditions
 127         msoRestClientNew = new MsoRestClientNew(syncRestClient, "baseUrl",systemPropertiesWrapper);
 128     }
 129
 130     @BeforeMethod
 131     private void setup() {
 132         putRequestInSpringContext();
 133     }
 134
 135     public static void putRequestInSpringContext() {
 136         RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(
 137             (HttpServletRequest) promiseRequestIdFilter.wrapIfNeeded(new MockHttpServletRequest())));
 138     }
 139
 140     @DataProvider
 141     public Object[][] msoMethods() {
 142         return Stream.<ThrowingConsumer<RestMsoImplementation>>of(
 143                 client -> client.GetForObject("/any path", Object.class),
 144                 client -> client.restCall(HttpMethod.DELETE, Object.class, "some payload", "/any path", Optional.of("userId")),
 145                 client -> client.PostForObject("some payload", "/any path", Object.class)
 146         ).map(l -> ImmutableList.of(l).toArray()).collect(Collectors.toList()).toArray(new Object[][]{});
 147     }
 148
 149     @Test
 150     public void whenProvideMsoRestCallUserId_builderHasXRequestorIDHeader() throws Exception {
 151
 152         final TestUtils.JavaxRsClientMocks mocks = setAndGetMocksInsideRestImpl(restMsoImplementation);
 153         String randomUserName = randomAlphabetic(10);
 154
 155         restMsoImplementation.restCall(HttpMethod.DELETE, String.class, null, "abc", Optional.of(randomUserName));
 156         assertEquals(randomUserName, captureHeaderKeyAndReturnItsValue(mocks.getFakeBuilder(), "X-RequestorID"));
 157     }
 158
 159     @DataProvider
 160     public Object[][] msoRestClientNewMethods() {
 161         return Stream.<ThrowingConsumer<MsoRestClientNew>>of(
 162             client -> client.createInstance(new Object(), "/any path")
 163         ).map(l -> ImmutableList.of(l).toArray()).collect(Collectors.toList()).toArray(new Object[][]{});
 164     }
 165
 166     @Test(dataProvider = "msoRestClientNewMethods")
 167     public void msoRestClientNewHeadersTest(Consumer<MsoRestClientNew> f) throws Exception {
 168         Map[] captor = setMocksForMsoRestClientNew();
 169
 170         f.accept(msoRestClientNew);
 171         Map headers = captor[0];
 172
 173         String ecompRequestId = assertRequestHeaderIsUUID(headers, "X-ECOMP-RequestID");
 174         String onapRequestID = assertRequestHeaderIsUUID(headers, "X-ONAP-RequestID");
 175         assertEquals(ecompRequestId, onapRequestID);
 176
 177
 178         String invocationId1 = assertRequestHeaderIsUUID(headers, "X-InvocationID");
 179         assertThat((String) headers.get("Authorization"), startsWith("Basic "));
 180         assertThat(headers.get("X-ONAP-PartnerName"), is("VID.VID"));
 181
 182         //verify requestId is same in next call but invocationId is different
 183
 184         //given
 185         captor = setMocksForMsoRestClientNew();
 186
 187         //when
 188         f.accept(msoRestClientNew);
 189         headers = captor[0];
 190
 191         //then
 192         assertEquals(headers.get("X-ONAP-RequestID"), onapRequestID);
 193         String invocationId2 = assertRequestHeaderIsUUID(headers, "X-InvocationID");
 194         assertNotEquals(invocationId1, invocationId2);
 195
 196     }
 197
 198     private Map[] setMocksForMsoRestClientNew() {
 199         reset(syncRestClient);
 200         HttpResponse<String> httpResponse = mock(HttpResponse.class);
 201         String expectedResponse = "myResponse";
 202         when(httpResponse.getStatus()).thenReturn(202);
 203         when(httpResponse.getBody()).thenReturn(expectedResponse);
 204         when(httpResponse.getRawBody()).thenReturn(toInputStream(expectedResponse, StandardCharsets.UTF_8));
 205         final Map[] headersCapture = new Map[1];
 206         when(syncRestClient.post(anyString(), anyMap(), any(), eq(String.class))).thenAnswer(
 207             invocation -> {
 208                 headersCapture[0] = (Map)invocation.getArguments()[1];
 209                 return httpResponse;
 210             });
 211
 212         return headersCapture;
 213     }
 214
 215 //    @Test(dataProvider = "schedulerMethods")
 216 //    public void scheduler(Consumer<AAIRestInterface> f) throws Exception {
 217 //
 218 //        This test os not feasible in the wat acheduler is implemented today,
 219 //        as Scheduler's client is rewritten in every call.
 220 //
 221 //        :-(
 222 //
 223 //    }
 224
 225     private String verifyXEcompRequestIdHeaderWasAdded(Invocation.Builder fakeBuilder) {
 226         final String requestIdHeader = "x-ecomp-requestid";
 227         return assertRequestHeaderIsUUID(fakeBuilder, requestIdHeader);
 228     }
 229
 230     private String assertRequestHeaderIsUUID(Invocation.Builder fakeBuilder, String headerName) {
 231         Object headerValue = captureHeaderKeyAndReturnItsValue(fakeBuilder, headerName);
 232         return assertRequestHeaderIsUUID(headerName, headerValue);
 233     }
 234
 235     private String assertRequestHeaderIsUUID(Map headers, String headerName) {
 236         return assertRequestHeaderIsUUID(headerName, headers.get(headerName));
 237     }
 238
 239     private String assertRequestHeaderIsUUID(String headerName, Object headerValue) {
 240         final String uuidRegex = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 241         assertThat("header '" + headerName + "' should be a uuid", headerValue,
 242                 allOf(instanceOf(String.class), hasToString(matchesPattern(uuidRegex))));
 243         return (String)headerValue;
 244     }
 245
 246     private void verifyXOnapPartnerNameHeaderWasAdded(Invocation.Builder fakeBuilder) {
 247         assertThat(
 248             captureHeaderKeyAndReturnItsValue(fakeBuilder, Headers.PARTNER_NAME.getHeaderName()),
 249             is("VID.VID")
 250         );
 251     }
 252
 253     private Object captureHeaderKeyAndReturnItsValue(Invocation.Builder fakeBuilder, String headerName) {
 254         // Checks that the builder was called with either one of header("x-ecomp-requestid", uuid)
 255         // or the plural brother: headers(Map.of("x-ecomp-requestid", Set.of(uuid))
 256
 257         Object requestId;
 258         // The 'verify()' will capture the request id. If no match -- AssertionError will
 259         // catch for a second chance -- another 'verify()'.
 260         try {
 261             try {
 262                 ArgumentCaptor<Object> argumentCaptor = ArgumentCaptor.forClass(Object.class);
 263                 Mockito.verify(fakeBuilder)
 264                     .header(
 265                         Matchers.argThat(s -> equalsIgnoreCase(s, headerName)),
 266                         argumentCaptor.capture()
 267                     );
 268                 requestId = argumentCaptor.getValue();
 269
 270             } catch (AssertionError e) {
 271                 Mockito.verify(fakeBuilder).headers(multivaluedMapArgumentCaptor.capture());
 272
 273                 final MultivaluedMap<String, Object> headersMap = multivaluedMapArgumentCaptor.getValue();
 274                 final String thisRequestIdHeader = getFromSetCaseInsensitive(headersMap.keySet(), headerName);
 275
 276                 assertThat(headersMap.keySet(), hasItem(thisRequestIdHeader));
 277                 requestId = headersMap.getFirst(thisRequestIdHeader);
 278             }
 279         } catch (AssertionError e) {
 280             throw new AssertionError("header not captured: " + headerName, e);
 281         }
 282         return requestId;
 283     }
 284
 285     private String getFromSetCaseInsensitive(Set<String> set, String key) {
 286         return set.stream()
 287                 .filter(anotherString -> anotherString.equalsIgnoreCase(key))
 288                 .findFirst()
 289                 .orElse(key);
 290     }
 291
 292     private TestUtils.JavaxRsClientMocks setAndGetMocksInsideRestImpl(Class<?> clazz) throws IllegalAccessException {
 293         TestUtils.JavaxRsClientMocks mocks = new TestUtils.JavaxRsClientMocks();
 294         Client fakeClient = mocks.getFakeClient();
 295
 296         FieldUtils.writeStaticField(clazz, "client", fakeClient, true);
 297
 298         return mocks;
 299     }
 300
 301     private TestUtils.JavaxRsClientMocks setAndGetMocksInsideRestImpl(Object instance) throws IllegalAccessException {
 302         TestUtils.JavaxRsClientMocks mocks = new TestUtils.JavaxRsClientMocks();
 303         Client fakeClient = mocks.getFakeClient();
 304
 305         FieldUtils.writeField(instance, "client", fakeClient, true);
 306
 307         return mocks;
 308     }
 309
 310     @FunctionalInterface
 311     public interface ThrowingConsumer<T> extends Consumer<T> {
 312         @Override
 313         default void accept(T t) {
 314             try {
 315                 acceptThrows(t);
 316             } catch (Exception e) {
 317                 throw new RuntimeException(e);
 318             }
 319         }
 320
 321         void acceptThrows(T t) throws Exception;
 322     }
 323
 324     private class HeadersVerifier {
 325
 326         private String firstRequestId;
 327         private String firstInvocationId;
 328
 329
 330         HeadersVerifier verifyFirstCall(Builder fakeBuilder) {
 331             firstRequestId = verifyXEcompRequestIdHeaderWasAdded(fakeBuilder);
 332             assertEquals(firstRequestId, captureHeaderKeyAndReturnItsValue(fakeBuilder, "X-ONAP-RequestID"));
 333             firstInvocationId = assertRequestHeaderIsUUID(fakeBuilder, "X-InvocationID");
 334             verifyXOnapPartnerNameHeaderWasAdded(fakeBuilder);
 335             return this;
 336         }
 337
 338         void verifySecondCall(Builder fakeBuilder) {
 339             String secondRequestId = verifyXEcompRequestIdHeaderWasAdded(fakeBuilder);
 340             assertEquals(firstRequestId, secondRequestId);
 341
 342             Object secondInvocationId = assertRequestHeaderIsUUID(fakeBuilder, "X-InvocationID");
 343             assertNotEquals(firstInvocationId, secondInvocationId);
 344         }
 345     }
 346 }