gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.logging.servlet.jaxrs;
  18
  19 import static org.easymock.EasyMock.anyObject;
  20 import static org.easymock.EasyMock.anyString;
  21 import static org.openecomp.sdc.logging.servlet.jaxrs.LoggingRequestFilter.START_TIME_KEY;
  22
  23 import java.lang.reflect.Method;
  24 import java.util.UUID;
  25 import javax.ws.rs.container.ContainerRequestContext;
  26 import javax.ws.rs.container.ResourceInfo;
  27 import org.easymock.EasyMock;
  28 import org.openecomp.sdc.logging.LoggingConstants;
  29 import org.openecomp.sdc.logging.api.ContextData;
  30 import org.openecomp.sdc.logging.api.LoggingContext;
  31 import org.powermock.api.easymock.PowerMock;
  32 import org.powermock.core.classloader.annotations.PrepareForTest;
  33 import org.powermock.modules.testng.PowerMockTestCase;
  34 import org.testng.ITestResult;
  35 import org.testng.annotations.AfterMethod;
  36 import org.testng.annotations.Test;
  37
  38 /**
  39  * Unit testing JAX-RS request filter.
  40  *
  41  * @author evitaliy
  42  * @since 19 Mar 2018
  43  */
  44 @PrepareForTest({LoggingContext.class, ContextData.class})
  45 public class LoggingRequestFilterTest extends PowerMockTestCase {
  46
  47     private static final Class RESOURCE_CLASS = MockResource.class;
  48     private static final Method RESOURCE_METHOD = MockResource.class.getDeclaredMethods()[0];
  49     private static final String RESOURCE_NAME = RESOURCE_CLASS.getName() + "." + RESOURCE_METHOD.getName();
  50
  51     private static final String RANDOM_REQUEST_ID = UUID.randomUUID().toString();
  52     private static final String RANDOM_PARTNER_NAME = UUID.randomUUID().toString();
  53
  54     /**
  55      * Verify all mocks after each test.
  56      */
  57     @AfterMethod
  58     public void verifyMocks(ITestResult result) {
  59
  60         try {
  61             PowerMock.verifyAll();
  62         } catch (AssertionError e) {
  63             throw new AssertionError("Expectations failed in: " + result.getMethod().getMethodName(), e);
  64         }
  65     }
  66
  67     @Test
  68     public void notHandledWhenNoMatchingResource() {
  69
  70         PowerMock.mockStatic(LoggingContext.class);
  71         PowerMock.replay(LoggingContext.class);
  72
  73         new LoggingRequestFilter().filter(mockEmptyContainerRequestContext());
  74     }
  75
  76     @Test
  77     public void serviceNamePopulatedWhenThereIsMatchingResource() {
  78
  79         mockContextDataBuilder(null, RESOURCE_NAME, null);
  80         mockLoggingContext();
  81
  82         LoggingRequestFilter filter = new LoggingRequestFilter();
  83         filter.setResource(mockResource());
  84
  85         filter.filter(mockContainerRequestContext(
  86                 new RequestIdHeader(null),
  87                 new PartnerHeader(null)));
  88     }
  89
  90     @Test
  91     public void partnerNamePopulatedWhenPresentInDefaultHeader() {
  92
  93         mockContextDataBuilder(null, RESOURCE_NAME, RANDOM_PARTNER_NAME);
  94         mockLoggingContext();
  95
  96         LoggingRequestFilter filter = new LoggingRequestFilter();
  97         filter.setResource(mockResource());
  98
  99         filter.filter(mockContainerRequestContext(
 100                 new RequestIdHeader(null),
 101                 new PartnerHeader(RANDOM_PARTNER_NAME)));
 102     }
 103
 104     @Test
 105     public void partnerNamePopulatedWhenPresentInCustomHeader() {
 106
 107         final String partnerHeader = "x-partner-header";
 108         mockContextDataBuilder(null, RESOURCE_NAME, RANDOM_PARTNER_NAME);
 109         mockLoggingContext();
 110
 111         LoggingRequestFilter filter = new LoggingRequestFilter();
 112         filter.setResource(mockResource());
 113         filter.setPartnerNameHeaders(partnerHeader);
 114
 115         filter.filter(mockContainerRequestContext(
 116                 new RequestIdHeader(null),
 117                 new PartnerHeader(partnerHeader, RANDOM_PARTNER_NAME)));
 118     }
 119
 120     @Test
 121     public void requestIdPopulatedWhenPresentInDefaultHeader() {
 122
 123         mockContextDataBuilder(RANDOM_REQUEST_ID, RESOURCE_NAME, null);
 124         mockLoggingContext();
 125
 126         LoggingRequestFilter filter = new LoggingRequestFilter();
 127         filter.setResource(mockResource());
 128
 129         filter.filter(mockContainerRequestContext(
 130                 new RequestIdHeader(RANDOM_REQUEST_ID),
 131                 new PartnerHeader(null)));
 132     }
 133
 134     @Test
 135     public void requestIdPopulatedWhenPresentInCustomHeader() {
 136
 137         final String requestIdHeader = "x-request-id";
 138         mockContextDataBuilder(RANDOM_REQUEST_ID, RESOURCE_NAME, null);
 139         mockLoggingContext();
 140
 141         LoggingRequestFilter filter = new LoggingRequestFilter();
 142         filter.setResource(mockResource());
 143         filter.setRequestIdHeaders(requestIdHeader);
 144
 145         filter.filter(mockContainerRequestContext(
 146                 new RequestIdHeader(requestIdHeader, RANDOM_REQUEST_ID),
 147                 new PartnerHeader(null)));
 148     }
 149
 150     private ResourceInfo mockResource() {
 151         ResourceInfo resource = EasyMock.mock(ResourceInfo.class);
 152         //noinspection unchecked
 153         EasyMock.expect(resource.getResourceClass()).andReturn(RESOURCE_CLASS);
 154         EasyMock.expect(resource.getResourceMethod()).andReturn(RESOURCE_METHOD);
 155         EasyMock.replay(resource);
 156         return resource;
 157     }
 158
 159     private ContainerRequestContext mockEmptyContainerRequestContext() {
 160         ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class);
 161         EasyMock.replay(requestContext);
 162         return requestContext;
 163     }
 164
 165     private ContainerRequestContext mockContainerRequestContext(Header... headers) {
 166
 167         ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class);
 168
 169         for (Header h : headers) {
 170             EasyMock.expect(requestContext.getHeaderString(h.key)).andReturn(h.value);
 171         }
 172
 173         requestContext.setProperty(EasyMock.eq(START_TIME_KEY), EasyMock.anyLong());
 174         EasyMock.expectLastCall();
 175
 176         EasyMock.replay(requestContext);
 177         return requestContext;
 178     }
 179
 180     private void mockContextDataBuilder(String requestId, String serviceName, String partnerName) {
 181
 182         ContextData.ContextDataBuilder mockBuilder = EasyMock.mock(ContextData.ContextDataBuilder.class);
 183
 184         if (requestId != null) {
 185             EasyMock.expect(mockBuilder.requestId(requestId)).andReturn(mockBuilder);
 186         } else {
 187             EasyMock.expect(mockBuilder.requestId(anyString())).andReturn(mockBuilder);
 188         }
 189
 190         if (serviceName != null) {
 191             EasyMock.expect(mockBuilder.serviceName(serviceName)).andReturn(mockBuilder);
 192         }
 193
 194         if (partnerName != null) {
 195             EasyMock.expect(mockBuilder.partnerName(partnerName)).andReturn(mockBuilder);
 196         }
 197
 198         EasyMock.expect(mockBuilder.build()).andReturn(EasyMock.mock(ContextData.class));
 199         EasyMock.replay(mockBuilder);
 200
 201         PowerMock.mockStatic(ContextData.class);
 202
 203         ContextData.builder();
 204         PowerMock.expectLastCall().andReturn(mockBuilder);
 205
 206         PowerMock.replay(ContextData.class);
 207     }
 208
 209     private void mockLoggingContext() {
 210
 211         PowerMock.mockStatic(LoggingContext.class);
 212
 213         LoggingContext.clear();
 214         EasyMock.expectLastCall().once();
 215
 216         LoggingContext.put(anyObject(ContextData.class));
 217         EasyMock.expectLastCall().once();
 218
 219         PowerMock.replay(LoggingContext.class);
 220     }
 221
 222     private abstract static class Header {
 223
 224         private final String key;
 225         private final String value;
 226
 227         private Header(String key, String value) {
 228             this.key = key;
 229             this.value = value;
 230         }
 231     }
 232
 233     private static class PartnerHeader extends Header {
 234
 235         private PartnerHeader(String value) {
 236             super(LoggingConstants.DEFAULT_PARTNER_NAME_HEADER, value);
 237         }
 238
 239         private PartnerHeader(String key, String value) {
 240             super(key, value);
 241         }
 242     }
 243
 244     private static class RequestIdHeader extends Header {
 245
 246         private RequestIdHeader(String value) {
 247             super(LoggingConstants.DEFAULT_REQUEST_ID_HEADER, value);
 248         }
 249
 250         private RequestIdHeader(String key, String value) {
 251             super(key, value);
 252         }
 253     }
 254
 255     private static class MockResource {
 256
 257         @SuppressWarnings("EmptyMethod")
 258         void process() {
 259             // no-op
 260         }
 261     }
 262 }