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;
  18
  19 import static org.easymock.EasyMock.anyObject;
  20 import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_PARTNER_NAME_HEADER;
  21 import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_REQUEST_ID_HEADER;
  22 import static org.openecomp.sdc.logging.servlet.LoggingFilter.PARTNER_NAME_HEADERS_PARAM;
  23 import static org.openecomp.sdc.logging.servlet.LoggingFilter.REQUEST_ID_HEADERS_PARAM;
  24
  25 import java.io.IOException;
  26 import java.util.UUID;
  27 import javax.servlet.FilterChain;
  28 import javax.servlet.FilterConfig;
  29 import javax.servlet.ServletException;
  30 import javax.servlet.ServletRequest;
  31 import javax.servlet.ServletResponse;
  32 import javax.servlet.http.HttpServletRequest;
  33 import javax.servlet.http.HttpServletResponse;
  34 import org.easymock.EasyMock;
  35 import org.junit.After;
  36 import org.junit.Rule;
  37 import org.junit.Test;
  38 import org.junit.rules.TestName;
  39 import org.junit.runner.RunWith;
  40 import org.openecomp.sdc.logging.api.ContextData;
  41 import org.openecomp.sdc.logging.api.LoggingContext;
  42 import org.powermock.api.easymock.PowerMock;
  43 import org.powermock.core.classloader.annotations.PrepareForTest;
  44 import org.powermock.modules.junit4.PowerMockRunner;
  45
  46 /**
  47  * Unit-tests logging filter for initialization and data retrieval.
  48  *
  49  * @author evitaliy
  50  * @since 17 Aug 2016
  51  */
  52 @RunWith(PowerMockRunner.class)
  53 @PrepareForTest(LoggingContext.class)
  54 public class LoggingFilterTest {
  55
  56     private static final String RANDOM_REQUEST_URI = UUID.randomUUID().toString();
  57     private static final String RANDOM_REQUEST_ID = UUID.randomUUID().toString();
  58     private static final String RANDOM_PARTNER_NAME = UUID.randomUUID().toString();
  59
  60     @Rule
  61     public TestName testName = new TestName();
  62
  63     /**
  64      * Verify all mocks after each test.
  65      */
  66     @After
  67     public void verifyMocks() {
  68
  69         try {
  70             PowerMock.verifyAll();
  71         } catch (AssertionError e) {
  72             throw new AssertionError("Expectations failed in " + testName.getMethodName() + "()", e);
  73         }
  74     }
  75
  76
  77     @Test
  78     public void filterPopulatesValuesWhenNoInitParamsAndNoHeaders() throws IOException, ServletException {
  79
  80         mockLoggingContext();
  81         LoggingFilter loggingFilter = new LoggingFilter();
  82         loggingFilter.init(mockFilterConfig(null, null));
  83         loggingFilter.doFilter(new MockRequestBuilder().build(), mockResponse(), mockChain());
  84     }
  85
  86     @Test
  87     public void filterPopulatesValuesWhenNoInitParamsAndExistingHeaders() throws IOException, ServletException {
  88
  89         mockLoggingContext();
  90
  91         LoggingFilter loggingFilter = new LoggingFilter();
  92         loggingFilter.init(mockFilterConfig(null, null));
  93
  94         HttpServletRequest mockRequest = new MockRequestBuilder().partnerName(RANDOM_PARTNER_NAME)
  95                                                                  .requestId(RANDOM_REQUEST_ID).build();
  96         loggingFilter.doFilter(mockRequest, mockResponse(), mockChain());
  97     }
  98
  99     @Test
 100     public void filterPopulatesValuesWhenCustomInitParamsAndNoHeaders() throws IOException, ServletException {
 101
 102         mockLoggingContext();
 103
 104         final String requestIdHeader = "x-request";
 105         final String partnerNameHeader = "x-partner";
 106
 107         LoggingFilter loggingFilter = new LoggingFilter();
 108         FilterConfig mockConfig = mockFilterConfig(requestIdHeader, partnerNameHeader);
 109         loggingFilter.init(mockConfig);
 110
 111         HttpServletRequest mockRequest = new MockRequestBuilder().requestIdHeader(requestIdHeader)
 112                                                                  .partnerNameHeader(partnerNameHeader).build();
 113         loggingFilter.doFilter(mockRequest, mockResponse(), mockChain());
 114     }
 115
 116     @Test
 117     public void filterPopulatesValuesWhenCustomInitParamsAndExistingHeaders() throws IOException, ServletException {
 118
 119         mockLoggingContext();
 120
 121         final String requestIdHeader = "x-request-id";
 122         final String partnerNameHeader = "x-partner-name";
 123
 124         LoggingFilter loggingFilter = new LoggingFilter();
 125         FilterConfig mockConfig = mockFilterConfig(requestIdHeader, partnerNameHeader);
 126         loggingFilter.init(mockConfig);
 127
 128         HttpServletRequest mockRequest = new MockRequestBuilder()
 129                 .partnerNameHeader(partnerNameHeader).partnerName(RANDOM_PARTNER_NAME)
 130                 .requestIdHeader(requestIdHeader).requestId(RANDOM_REQUEST_ID).build();
 131         loggingFilter.doFilter(mockRequest, mockResponse(), mockChain());
 132     }
 133
 134     private FilterConfig mockFilterConfig(String requestIdHeader, String partnerNameHeader) {
 135         FilterConfig config = EasyMock.mock(FilterConfig.class);
 136         EasyMock.expect(config.getInitParameter(REQUEST_ID_HEADERS_PARAM)).andReturn(requestIdHeader);
 137         EasyMock.expect(config.getInitParameter(PARTNER_NAME_HEADERS_PARAM)).andReturn(partnerNameHeader);
 138         EasyMock.replay(config);
 139         return config;
 140     }
 141
 142     private FilterChain mockChain() throws IOException, ServletException {
 143         FilterChain chain = EasyMock.mock(FilterChain.class);
 144         chain.doFilter(anyObject(ServletRequest.class), anyObject(ServletResponse.class));
 145         EasyMock.expectLastCall().once();
 146         EasyMock.replay(chain);
 147         return chain;
 148     }
 149
 150     private ServletResponse mockResponse() {
 151         HttpServletResponse servletResponse = EasyMock.mock(HttpServletResponse.class);
 152         EasyMock.replay(servletResponse);
 153         return servletResponse;
 154     }
 155
 156     private void mockLoggingContext() {
 157
 158         PowerMock.mockStatic(LoggingContext.class);
 159
 160         LoggingContext.clear();
 161         EasyMock.expectLastCall().times(2);
 162
 163         LoggingContext.put(anyObject(ContextData.class));
 164         EasyMock.expectLastCall().once();
 165
 166         PowerMock.replay(LoggingContext.class);
 167     }
 168
 169     private static class MockRequestBuilder {
 170
 171         private String requestIdHeader = DEFAULT_REQUEST_ID_HEADER;
 172         private String partnerNameHeader = DEFAULT_PARTNER_NAME_HEADER;
 173         private String requestId = null;
 174         private String partnerName = null;
 175
 176         MockRequestBuilder requestIdHeader(String h) {
 177             this.requestIdHeader = h;
 178             return this;
 179         }
 180
 181         MockRequestBuilder requestId(String id) {
 182             this.requestId = id;
 183             return this;
 184         }
 185
 186         MockRequestBuilder partnerNameHeader(String h) {
 187             this.partnerNameHeader = h;
 188             return this;
 189         }
 190
 191         MockRequestBuilder partnerName(String name) {
 192             this.partnerName = name;
 193             return this;
 194         }
 195
 196         HttpServletRequest build() {
 197             HttpServletRequest mockRequest = EasyMock.mock(HttpServletRequest.class);
 198             EasyMock.expect(mockRequest.getRequestURI()).andReturn(RANDOM_REQUEST_URI);
 199             EasyMock.expect(mockRequest.getHeader(requestIdHeader)).andReturn(requestId);
 200             EasyMock.expect(mockRequest.getHeader(partnerNameHeader)).andReturn(partnerName);
 201             EasyMock.replay(mockRequest);
 202             return mockRequest;
 203         }
 204     }
 205 }