diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api')
11 files changed, 1335 insertions, 13 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/pom.xml b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/pom.xml index 927f45454f..754a103706 100644 --- a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/pom.xml +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/pom.xml @@ -15,11 +15,48 @@ <dependencies> <dependency> + <groupId>javax.ws.rs</groupId> + <artifactId>javax.ws.rs-api</artifactId> + <version>${ws.rs.version}</version> + <scope>provided</scope> + </dependency> + <dependency> + <groupId>javax.servlet</groupId> + <artifactId>servlet-api</artifactId> + <version>${servlet-api.version}</version> + <scope>provided</scope> + </dependency> + <!-- testing --> + <dependency> <groupId>org.testng</groupId> <artifactId>testng</artifactId> <version>${testng.version}</version> <scope>test</scope> </dependency> + <dependency> + <groupId>org.easymock</groupId> + <artifactId>easymock</artifactId> + <version>${easymock.version}</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.powermock</groupId> + <artifactId>powermock-api-easymock</artifactId> + <version>${powermock.version}</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.powermock</groupId> + <artifactId>powermock-core</artifactId> + <version>${powermock.version}</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.powermock</groupId> + <artifactId>powermock-module-testng</artifactId> + <version>${powermock.version}</version> + <scope>test</scope> + </dependency> </dependencies> </project> diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/LoggingConstants.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/LoggingConstants.java new file mode 100644 index 0000000000..e8635b2418 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/LoggingConstants.java @@ -0,0 +1,40 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging; + +/** + * Constants that must be visible across the logging API. + * + * @author evitaliy + * @since 18 Mar 2018 + */ +public class LoggingConstants { + + /** + * Default HTTP header for propagation of a request ID for distributed tracing. + */ + public static final String DEFAULT_REQUEST_ID_HEADER = "X-ECOMP-RequestID"; + + /** + * Default HTTP header for exchanging a partner name between components. + */ + public static final String DEFAULT_PARTNER_NAME_HEADER = "USER_ID"; + + private LoggingConstants() { + // prevent instantiation of the constants class + } +} diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/api/ServiceBinder.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/api/ServiceBinder.java index e3c9ea02de..6706d6fa46 100644 --- a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/api/ServiceBinder.java +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/api/ServiceBinder.java @@ -4,9 +4,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -16,25 +16,22 @@ package org.openecomp.sdc.logging.api; -import org.openecomp.sdc.logging.spi.LoggerCreationService; -import org.openecomp.sdc.logging.spi.LoggingContextService; -import org.openecomp.sdc.logging.spi.LoggingServiceProvider; - import java.util.Iterator; import java.util.Optional; import java.util.ServiceLoader; +import org.openecomp.sdc.logging.spi.LoggerCreationService; +import org.openecomp.sdc.logging.spi.LoggingContextService; +import org.openecomp.sdc.logging.spi.LoggingServiceProvider; /** * <p>Binds to a concrete implementation of logging services.</p> - * * <p>In order to use the factory, a particular (e.g. framework-specific) implementation of a service must be * configured as described in * <a href="http://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html">java.util.ServiceLoader</a>).</p> * * @author evitaliy - * @since 13/09/2016. - * * @see ServiceLoader + * @since 13 Sep 2016 */ // No advanced logging can be used here because we don't know @@ -44,7 +41,7 @@ class ServiceBinder { private static final LoggingServiceProvider PROVIDER = lookupProvider(); - private ServiceBinder () { + private ServiceBinder() { // prevent instantiation } @@ -54,9 +51,8 @@ class ServiceBinder { Iterator<LoggingServiceProvider> iterator = loader.iterator(); if (!iterator.hasNext()) { - System.err.printf("[ERROR] No provider configured for logging services %s. " + - "Default implementation will be used.\n", - LoggingServiceProvider.class.getName()); + System.err.printf("[ERROR] No provider configured for logging services %s. " + + "Default implementation will be used.\n", LoggingServiceProvider.class.getName()); return null; } diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/HttpHeader.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/HttpHeader.java new file mode 100644 index 0000000000..4dcc197796 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/HttpHeader.java @@ -0,0 +1,55 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet; + +import java.util.function.Function; + +/** + * Handles any of possible header names to read a value for that header. This is useful for backward compatibility, if + * multiple headers may have the same meaning. For instance, when requests come from multiple service, some using an old + * header and others using a new header to pass the same information. + * + * @author evitaliy + * @since 25 Mar 2018 + */ +public class HttpHeader { + + private final String[] keys; + + public HttpHeader(String... keys) { + this.keys = keys; + } + + /** + * Returns the value of any of the possible headers. + * + * @param reader function for reading an HTTP header. + * @return value or null if not found + */ + public String getAny(Function<String, String> reader) { + + for (String k : keys) { + + String value = reader.apply(k); + if (value != null) { + return value; + } + } + + return null; + } +} diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/LoggingFilter.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/LoggingFilter.java new file mode 100644 index 0000000000..e53f28119c --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/LoggingFilter.java @@ -0,0 +1,136 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet; + +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_PARTNER_NAME_HEADER; +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_REQUEST_ID_HEADER; + +import java.io.IOException; +import java.util.UUID; +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import org.openecomp.sdc.logging.api.ContextData; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.openecomp.sdc.logging.servlet.jaxrs.LoggingRequestFilter; +import org.openecomp.sdc.logging.servlet.jaxrs.LoggingResponseFilter; + +/** + * <p>Places logging context information. Must be configured as a servlet filter in <i>web.xml</i>. The behavior can be + * customized via init-params.</p> + * <p>Example:</p> + * <pre> + * + * <filter> + * <filter-name>LoggingServletFilter</filter-name> + * <filter-class>org.openecomp.sdc.logging.servlet.LoggingFilter</filter-class> + * <init-param> + * <param-name>requestIdHeaders</param-name> + * <param-value>X-ONAP-RequestID</param-value> + * </init-param> + * <init-param> + * <param-name>partnerNameHeaders</param-name> + * <param-value>USER_ID</param-value> + * </init-param> + * </filter> + * + * <filter-mapping> + * <filter-name>LoggingServletFilter</filter-name> + * <url-pattern>/*</url-pattern> + * </filter-mapping> + * + * </pre> + * + * @author evitaliy + * @since 25 Jul 2016 + * @deprecated Kept for backward compatibility. For JAX-RS application, use + * {@link LoggingRequestFilter} and + * {@link LoggingResponseFilter} instead. + */ +@Deprecated +public class LoggingFilter implements Filter { + + static final String MULTI_VALUE_SEPARATOR = ","; + + static final String REQUEST_ID_HEADERS_PARAM = "requestIdHeaders"; + static final String PARTNER_NAME_HEADERS_PARAM = "partnerNameHeaders"; + + private static final Logger LOGGER = LoggerFactory.getLogger(LoggingFilter.class); + + private HttpHeader requestIdHeaders; + private HttpHeader partnerNameHeaders; + + @Override + public void init(FilterConfig config) { + requestIdHeaders = getInitParam(config, REQUEST_ID_HEADERS_PARAM, DEFAULT_REQUEST_ID_HEADER); + partnerNameHeaders = getInitParam(config, PARTNER_NAME_HEADERS_PARAM, DEFAULT_PARTNER_NAME_HEADER); + } + + @Override + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) + throws IOException, ServletException { + + HttpServletRequest httpRequest = HttpServletRequest.class.cast(request); + + try { + + LoggingContext.clear(); + + ContextData.ContextDataBuilder contextData = ContextData.builder(); + + contextData.serviceName(httpRequest.getRequestURI()); + + String requestId = requestIdHeaders.getAny(httpRequest::getHeader); + contextData.requestId(requestId == null ? UUID.randomUUID().toString() : requestId); + + String partner = partnerNameHeaders.getAny(httpRequest::getHeader); + if (partner != null) { + contextData.partnerName(partner); + } + + LoggingContext.put(contextData.build()); + + chain.doFilter(request, response); + + } finally { + LoggingContext.clear(); + } + } + + @Override + public void destroy() { + // forced by the interface - not implemented + } + + private HttpHeader getInitParam(FilterConfig config, String paramName, String defaultValue) { + + String value = config.getInitParameter(paramName); + LOGGER.debug("Logging filter configuration param '{}' value '{}'", paramName, value); + + if (value == null) { + return new HttpHeader(defaultValue); + } else { + return new HttpHeader(value.split(MULTI_VALUE_SEPARATOR)); + } + } +} diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilter.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilter.java new file mode 100644 index 0000000000..06660f35f4 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilter.java @@ -0,0 +1,118 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet.jaxrs; + +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_PARTNER_NAME_HEADER; +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_REQUEST_ID_HEADER; + +import java.util.UUID; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.container.ContainerRequestFilter; +import javax.ws.rs.container.ResourceInfo; +import javax.ws.rs.core.Context; +import javax.ws.rs.ext.Provider; +import org.openecomp.sdc.logging.api.ContextData; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.openecomp.sdc.logging.servlet.HttpHeader; + +/** + * <p>Takes care of logging initialization an HTTP request hits the application. This includes populating logging + * context and storing the request processing start time, so that it can be used for audit. The filter was built + * <b>works in tandem</b> with {@link LoggingResponseFilter} or a similar implementation.</p> + * <p>The filter requires a few HTTP header names to be configured. These HTTP headers are used for propagating logging + * and tracing information between ONAP components.</p> + * <p>Sample configuration for a Spring environment:</p> + * <pre> + * <jaxrs:providers> + * <bean class="org.openecomp.sdc.logging.ws.rs.LoggingRequestFilter"> + * <property name="requestIdHeaders" value="X-ONAP-RequestID"/> + * <property name="partnerNameHeaders" value="X-ONAP-InstanceID"/> + * </bean> + * </jaxrs:providers> + * </pre> + * <p>Keep in mind that the filters does nothing in case when a request cannot be mapped to a working JAX-RS resource + * (implementation). For instance, when the path is invalid (404), or there is no handler for a particular method (405). + * </p> + * + * @author evitaliy, katyr + * @since 29 Oct 17 + * + * @see ContainerRequestFilter + */ +@Provider +public class LoggingRequestFilter implements ContainerRequestFilter { + + static final String MULTI_VALUE_SEPARATOR = ","; + + static final String START_TIME_KEY = "audit.start.time"; + + private ResourceInfo resource; + + private HttpHeader requestIdHeader = new HttpHeader(DEFAULT_REQUEST_ID_HEADER); + private HttpHeader partnerNameHeader = new HttpHeader(DEFAULT_PARTNER_NAME_HEADER); + + /** + * Injection of a resource that matches the request from JAX-RS context. + * + * @param resource automatically injected by JAX-RS container + */ + @Context + public void setResource(ResourceInfo resource) { + this.resource = resource; + } + + /** + * Configuration parameter for request ID HTTP header. + */ + public void setRequestIdHeaders(String requestIdHeaders) { + this.requestIdHeader = new HttpHeader(requestIdHeaders.split(MULTI_VALUE_SEPARATOR)); + } + + /** + * Configuration parameter for partner name HTTP header. + */ + public void setPartnerNameHeaders(String partnerNameHeaders) { + this.partnerNameHeader = new HttpHeader(partnerNameHeaders.split(MULTI_VALUE_SEPARATOR)); + } + + @Override + public void filter(ContainerRequestContext containerRequestContext) { + + if (resource == null) { + // JAX-RS could not find a mapping this response, probably due to HTTP 404 (not found), + // 405 (method not allowed), 415 (unsupported media type), etc. with a message in Web server log + return; + } + + containerRequestContext.setProperty(START_TIME_KEY, System.currentTimeMillis()); + + LoggingContext.clear(); + + ContextData.ContextDataBuilder contextData = ContextData.builder(); + contextData.serviceName(resource.getResourceClass().getName() + "." + resource.getResourceMethod().getName()); + + String partnerName = partnerNameHeader.getAny(containerRequestContext::getHeaderString); + if (partnerName != null) { + contextData.partnerName(partnerName); + } + + String requestId = requestIdHeader.getAny(containerRequestContext::getHeaderString); + contextData.requestId(requestId == null ? UUID.randomUUID().toString() : requestId); + + LoggingContext.put(contextData.build()); + } +} diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilter.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilter.java new file mode 100644 index 0000000000..fbe28a79eb --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/main/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilter.java @@ -0,0 +1,147 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet.jaxrs; + +import static org.openecomp.sdc.logging.api.StatusCode.COMPLETE; +import static org.openecomp.sdc.logging.api.StatusCode.ERROR; + +import javax.servlet.http.HttpServletRequest; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.container.ContainerResponseContext; +import javax.ws.rs.container.ContainerResponseFilter; +import javax.ws.rs.core.Context; +import javax.ws.rs.core.Response; +import javax.ws.rs.ext.Provider; +import org.openecomp.sdc.logging.api.AuditData; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.openecomp.sdc.logging.api.StatusCode; + +/** + * <p>Takes care of logging when an HTTP request leaves the application. This includes writing to audit and clearing + * logging context. This filter <b>only works properly in tandem</b> with {@link LoggingRequestFilter} or a similar + * implementation.</p> + * <p>Sample configuration for a Spring environment:</p> + * <pre> + * <jaxrs:providers> + * <bean class="org.openecomp.sdc.logging.ws.rs.LoggingResponseFilter"/> + * </jaxrs:providers> + * </pre> + * <p><i>It is highly recommended to configure a custom JAX-RS exception mapper so that this filter will not be bypassed + * due to unhandled application or container exceptions.</i></p> + * + * @author evitaliy + * @since 29 Oct 17 + * + * @see ContainerResponseFilter + */ +@Provider +public class LoggingResponseFilter implements ContainerResponseFilter { + + private final Logger logger = LoggerFactory.getLogger(this.getClass()); + + /** + * Tracks reporting configuration problems to the log. We want to report them only once, and not to write to log + * upon every request, as the configuration will not change in runtime. + */ + private boolean reportBadConfiguration = true; + + private HttpServletRequest httpRequest; + + /** + * Injection of HTTP request object from JAX-RS context. + * + * @param httpRequest automatically injected by JAX-RS container + */ + @Context + public void setHttpRequest(HttpServletRequest httpRequest) { + this.httpRequest = httpRequest; + } + + @Override + public void filter(ContainerRequestContext containerRequestContext, + ContainerResponseContext containerResponseContext) { + + try { + writeAudit(containerRequestContext, containerResponseContext); + } finally { + LoggingContext.clear(); + } + } + + private void writeAudit(ContainerRequestContext containerRequestContext, + ContainerResponseContext containerResponseContext) { + + if (!logger.isAuditEnabled()) { + return; + } + + long start = readStartTime(containerRequestContext); + long end = System.currentTimeMillis(); + + Response.StatusType statusInfo = containerResponseContext.getStatusInfo(); + int responseCode = statusInfo.getStatusCode(); + StatusCode statusCode = isSuccess(responseCode) ? COMPLETE : ERROR; + + AuditData auditData = AuditData.builder().startTime(start).endTime(end).statusCode(statusCode) + .responseCode(Integer.toString(responseCode)) + .responseDescription(statusInfo.getReasonPhrase()) + .clientIpAddress(httpRequest.getRemoteAddr()).build(); + logger.audit(auditData); + } + + private boolean isSuccess(int responseCode) { + return responseCode > 199 && responseCode < 400; + } + + private long readStartTime(ContainerRequestContext containerRequestContext) { + + Object startTime = containerRequestContext.getProperty(LoggingRequestFilter.START_TIME_KEY); + if (startTime == null) { + return handleMissingStartTime(); + } + + return parseStartTime(startTime); + } + + private long handleMissingStartTime() { + reportConfigProblem("{} key was not found in JAX-RS request context. " + + "Make sure you configured a request filter", LoggingRequestFilter.START_TIME_KEY); + return 0; + } + + private long parseStartTime(Object startTime) { + + try { + return Long.class.cast(startTime); + } catch (ClassCastException e) { + reportConfigProblem("{} key in JAX-RS request context contains an object of type '{}', but 'java.lang.Long'" + + " is expected", LoggingRequestFilter.START_TIME_KEY, startTime.getClass().getName()); + return 0; + } + } + + private void reportConfigProblem(String message, Object... arguments) { + + if (reportBadConfiguration) { + reportBadConfiguration = false; + logger.error(message, arguments); + } + } +} + diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/LoggingFilterTest.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/LoggingFilterTest.java new file mode 100644 index 0000000000..535a50ca42 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/LoggingFilterTest.java @@ -0,0 +1,199 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet; + +import static org.easymock.EasyMock.anyObject; +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_PARTNER_NAME_HEADER; +import static org.openecomp.sdc.logging.LoggingConstants.DEFAULT_REQUEST_ID_HEADER; +import static org.openecomp.sdc.logging.servlet.LoggingFilter.PARTNER_NAME_HEADERS_PARAM; +import static org.openecomp.sdc.logging.servlet.LoggingFilter.REQUEST_ID_HEADERS_PARAM; + +import java.io.IOException; +import java.util.UUID; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.easymock.EasyMock; +import org.openecomp.sdc.logging.api.ContextData; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.powermock.api.easymock.PowerMock; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.testng.PowerMockTestCase; +import org.testng.ITestResult; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + +/** + * Unit-tests logging filter for initialization and data retrieval. + * + * @author evitaliy + * @since 17 Aug 2016 + */ +@PrepareForTest(LoggingContext.class) +public class LoggingFilterTest extends PowerMockTestCase { + + private static final String RANDOM_REQUEST_URI = UUID.randomUUID().toString(); + private static final String RANDOM_REQUEST_ID = UUID.randomUUID().toString(); + private static final String RANDOM_PARTNER_NAME = UUID.randomUUID().toString(); + + /** + * Verify all mocks after each test. + */ + @AfterMethod + public void verifyMocks(ITestResult result) { + + try { + PowerMock.verifyAll(); + } catch (AssertionError e) { + throw new AssertionError("Expectations failed in: " + result.getMethod().getMethodName(), e); + } + } + + + @Test + public void filterPopulatesValuesWhenNoInitParamsAndNoHeaders() throws Exception { + + mockLoggingContext(); + LoggingFilter loggingFilter = new LoggingFilter(); + loggingFilter.init(mockFilterConfig(null, null)); + loggingFilter.doFilter(new MockRequestBuilder().build(), mockResponse(), mockChain()); + } + + @Test + public void filterPopulatesValuesWhenNoInitParamsAndExistingHeaders() throws Exception { + + mockLoggingContext(); + + LoggingFilter loggingFilter = new LoggingFilter(); + loggingFilter.init(mockFilterConfig(null, null)); + + HttpServletRequest mockRequest = new MockRequestBuilder().partnerName(RANDOM_PARTNER_NAME) + .requestId(RANDOM_REQUEST_ID).build(); + loggingFilter.doFilter(mockRequest, mockResponse(), mockChain()); + } + + @Test + public void filterPopulatesValuesWhenCustomInitParamsAndNoHeaders() throws Exception { + + mockLoggingContext(); + + final String requestIdHeader = "x-request"; + final String partnerNameHeader = "x-partner"; + + LoggingFilter loggingFilter = new LoggingFilter(); + FilterConfig mockConfig = mockFilterConfig(requestIdHeader, partnerNameHeader); + loggingFilter.init(mockConfig); + + HttpServletRequest mockRequest = new MockRequestBuilder().requestIdHeader(requestIdHeader) + .partnerNameHeader(partnerNameHeader).build(); + loggingFilter.doFilter(mockRequest, mockResponse(), mockChain()); + } + + @Test + public void filterPopulatesValuesWhenCustomInitParamsAndExistingHeaders() throws Exception { + + mockLoggingContext(); + + final String requestIdHeader = "x-request-id"; + final String partnerNameHeader = "x-partner-name"; + + LoggingFilter loggingFilter = new LoggingFilter(); + FilterConfig mockConfig = mockFilterConfig(requestIdHeader, partnerNameHeader); + loggingFilter.init(mockConfig); + + HttpServletRequest mockRequest = new MockRequestBuilder() + .partnerNameHeader(partnerNameHeader).partnerName(RANDOM_PARTNER_NAME) + .requestIdHeader(requestIdHeader).requestId(RANDOM_REQUEST_ID).build(); + loggingFilter.doFilter(mockRequest, mockResponse(), mockChain()); + } + + private FilterConfig mockFilterConfig(String requestIdHeader, String partnerNameHeader) { + FilterConfig config = EasyMock.mock(FilterConfig.class); + EasyMock.expect(config.getInitParameter(REQUEST_ID_HEADERS_PARAM)).andReturn(requestIdHeader); + EasyMock.expect(config.getInitParameter(PARTNER_NAME_HEADERS_PARAM)).andReturn(partnerNameHeader); + EasyMock.replay(config); + return config; + } + + private FilterChain mockChain() throws IOException, ServletException { + FilterChain chain = EasyMock.mock(FilterChain.class); + chain.doFilter(anyObject(ServletRequest.class), anyObject(ServletResponse.class)); + EasyMock.expectLastCall().once(); + EasyMock.replay(chain); + return chain; + } + + private ServletResponse mockResponse() { + HttpServletResponse servletResponse = EasyMock.mock(HttpServletResponse.class); + EasyMock.replay(servletResponse); + return servletResponse; + } + + private void mockLoggingContext() { + + PowerMock.mockStatic(LoggingContext.class); + + LoggingContext.clear(); + EasyMock.expectLastCall().times(2); + + LoggingContext.put(anyObject(ContextData.class)); + EasyMock.expectLastCall().once(); + + PowerMock.replay(LoggingContext.class); + } + + private static class MockRequestBuilder { + + private String requestIdHeader = DEFAULT_REQUEST_ID_HEADER; + private String partnerNameHeader = DEFAULT_PARTNER_NAME_HEADER; + private String requestId = null; + private String partnerName = null; + + MockRequestBuilder requestIdHeader(String h) { + this.requestIdHeader = h; + return this; + } + + MockRequestBuilder requestId(String id) { + this.requestId = id; + return this; + } + + MockRequestBuilder partnerNameHeader(String h) { + this.partnerNameHeader = h; + return this; + } + + MockRequestBuilder partnerName(String name) { + this.partnerName = name; + return this; + } + + HttpServletRequest build() { + HttpServletRequest mockRequest = EasyMock.mock(HttpServletRequest.class); + EasyMock.expect(mockRequest.getRequestURI()).andReturn(RANDOM_REQUEST_URI); + EasyMock.expect(mockRequest.getHeader(requestIdHeader)).andReturn(requestId); + EasyMock.expect(mockRequest.getHeader(partnerNameHeader)).andReturn(partnerName); + EasyMock.replay(mockRequest); + return mockRequest; + } + } +} diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/HttpHeaderTest.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/HttpHeaderTest.java new file mode 100644 index 0000000000..3376c922e4 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/HttpHeaderTest.java @@ -0,0 +1,98 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet.jaxrs; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNull; + +import java.util.function.Function; +import org.openecomp.sdc.logging.servlet.HttpHeader; +import org.testng.annotations.Test; + +/** + * Unit tests mutliple-option headers. + * + * @author evitaliy + * @since 25 Mar 2018 + */ +public class HttpHeaderTest { + + @Test + public void valueReturnedWhenSinglePossibleHeader() { + + final String key = "Head"; + final String value = "1234"; + + Function<String, String> reader = createReader(key, value); + HttpHeader header = new HttpHeader(key); + assertEquals(header.getAny(reader), value); + } + + @Test + public void nullReturnedWhenSingleNoMatchingHeader() { + + final String key = "Head"; + + Function<String, String> reader = createReader(key, null); + HttpHeader header = new HttpHeader(key); + assertNull(header.getAny(reader)); + } + + @Test + public void nullReturnedWhenNoneHeaderMatches() { + Function<String, String> reader = createReader("None", "Value"); + HttpHeader header = new HttpHeader("A", "B", "C"); + assertNull(header.getAny(reader)); + } + + @Test + public void valueReturnedWhenLastHeaderMatches() { + + final String lastKey = "Last"; + final String value = "1234"; + + Function<String, String> reader = createReader(lastKey, value); + HttpHeader header = new HttpHeader("First", "Second", lastKey); + assertEquals(header.getAny(reader), value); + } + + @Test + public void valueReturnedWhenFirstHeaderMatches() { + + final String firstKey = "First"; + final String value = "1234"; + + Function<String, String> reader = createReader(firstKey, value); + HttpHeader header = new HttpHeader(firstKey, "Second", "Third"); + assertEquals(header.getAny(reader), value); + } + + @Test + public void valueReturnedWhenMiddleHeaderMatches() { + + final String middleKey = "Second"; + final String value = "1234"; + + Function<String, String> reader = createReader(middleKey, value); + HttpHeader header = new HttpHeader("First", middleKey, "Third"); + assertEquals(header.getAny(reader), value); + } + + private Function<String, String> createReader(String key, String value) { + return h -> h.equals(key) ? value : null; + } +}
\ No newline at end of file diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilterTest.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilterTest.java new file mode 100644 index 0000000000..0e0be017df --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingRequestFilterTest.java @@ -0,0 +1,262 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet.jaxrs; + +import static org.easymock.EasyMock.anyObject; +import static org.easymock.EasyMock.anyString; +import static org.openecomp.sdc.logging.servlet.jaxrs.LoggingRequestFilter.START_TIME_KEY; + +import java.lang.reflect.Method; +import java.util.UUID; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.container.ResourceInfo; +import org.easymock.EasyMock; +import org.openecomp.sdc.logging.LoggingConstants; +import org.openecomp.sdc.logging.api.ContextData; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.powermock.api.easymock.PowerMock; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.testng.PowerMockTestCase; +import org.testng.ITestResult; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + +/** + * Unit testing JAX-RS request filter. + * + * @author evitaliy + * @since 19 Mar 2018 + */ +@PrepareForTest({LoggingContext.class, ContextData.class}) +public class LoggingRequestFilterTest extends PowerMockTestCase { + + private static final Class RESOURCE_CLASS = MockResource.class; + private static final Method RESOURCE_METHOD = MockResource.class.getDeclaredMethods()[0]; + private static final String RESOURCE_NAME = RESOURCE_CLASS.getName() + "." + RESOURCE_METHOD.getName(); + + private static final String RANDOM_REQUEST_ID = UUID.randomUUID().toString(); + private static final String RANDOM_PARTNER_NAME = UUID.randomUUID().toString(); + + /** + * Verify all mocks after each test. + */ + @AfterMethod + public void verifyMocks(ITestResult result) { + + try { + PowerMock.verifyAll(); + } catch (AssertionError e) { + throw new AssertionError("Expectations failed in: " + result.getMethod().getMethodName(), e); + } + } + + @Test + public void notHandledWhenNoMatchingResource() { + + PowerMock.mockStatic(LoggingContext.class); + PowerMock.replay(LoggingContext.class); + + new LoggingRequestFilter().filter(mockEmptyContainerRequestContext()); + } + + @Test + public void serviceNamePopulatedWhenThereIsMatchingResource() { + + mockContextDataBuilder(null, RESOURCE_NAME, null); + mockLoggingContext(); + + LoggingRequestFilter filter = new LoggingRequestFilter(); + filter.setResource(mockResource()); + + filter.filter(mockContainerRequestContext( + new RequestIdHeader(null), + new PartnerHeader(null))); + } + + @Test + public void partnerNamePopulatedWhenPresentInDefaultHeader() { + + mockContextDataBuilder(null, RESOURCE_NAME, RANDOM_PARTNER_NAME); + mockLoggingContext(); + + LoggingRequestFilter filter = new LoggingRequestFilter(); + filter.setResource(mockResource()); + + filter.filter(mockContainerRequestContext( + new RequestIdHeader(null), + new PartnerHeader(RANDOM_PARTNER_NAME))); + } + + @Test + public void partnerNamePopulatedWhenPresentInCustomHeader() { + + final String partnerHeader = "x-partner-header"; + mockContextDataBuilder(null, RESOURCE_NAME, RANDOM_PARTNER_NAME); + mockLoggingContext(); + + LoggingRequestFilter filter = new LoggingRequestFilter(); + filter.setResource(mockResource()); + filter.setPartnerNameHeaders(partnerHeader); + + filter.filter(mockContainerRequestContext( + new RequestIdHeader(null), + new PartnerHeader(partnerHeader, RANDOM_PARTNER_NAME))); + } + + @Test + public void requestIdPopulatedWhenPresentInDefaultHeader() { + + mockContextDataBuilder(RANDOM_REQUEST_ID, RESOURCE_NAME, null); + mockLoggingContext(); + + LoggingRequestFilter filter = new LoggingRequestFilter(); + filter.setResource(mockResource()); + + filter.filter(mockContainerRequestContext( + new RequestIdHeader(RANDOM_REQUEST_ID), + new PartnerHeader(null))); + } + + @Test + public void requestIdPopulatedWhenPresentInCustomHeader() { + + final String requestIdHeader = "x-request-id"; + mockContextDataBuilder(RANDOM_REQUEST_ID, RESOURCE_NAME, null); + mockLoggingContext(); + + LoggingRequestFilter filter = new LoggingRequestFilter(); + filter.setResource(mockResource()); + filter.setRequestIdHeaders(requestIdHeader); + + filter.filter(mockContainerRequestContext( + new RequestIdHeader(requestIdHeader, RANDOM_REQUEST_ID), + new PartnerHeader(null))); + } + + private ResourceInfo mockResource() { + ResourceInfo resource = EasyMock.mock(ResourceInfo.class); + //noinspection unchecked + EasyMock.expect(resource.getResourceClass()).andReturn(RESOURCE_CLASS); + EasyMock.expect(resource.getResourceMethod()).andReturn(RESOURCE_METHOD); + EasyMock.replay(resource); + return resource; + } + + private ContainerRequestContext mockEmptyContainerRequestContext() { + ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class); + EasyMock.replay(requestContext); + return requestContext; + } + + private ContainerRequestContext mockContainerRequestContext(Header... headers) { + + ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class); + + for (Header h : headers) { + EasyMock.expect(requestContext.getHeaderString(h.key)).andReturn(h.value); + } + + requestContext.setProperty(EasyMock.eq(START_TIME_KEY), EasyMock.anyLong()); + EasyMock.expectLastCall(); + + EasyMock.replay(requestContext); + return requestContext; + } + + private void mockContextDataBuilder(String requestId, String serviceName, String partnerName) { + + ContextData.ContextDataBuilder mockBuilder = EasyMock.mock(ContextData.ContextDataBuilder.class); + + if (requestId != null) { + EasyMock.expect(mockBuilder.requestId(requestId)).andReturn(mockBuilder); + } else { + EasyMock.expect(mockBuilder.requestId(anyString())).andReturn(mockBuilder); + } + + if (serviceName != null) { + EasyMock.expect(mockBuilder.serviceName(serviceName)).andReturn(mockBuilder); + } + + if (partnerName != null) { + EasyMock.expect(mockBuilder.partnerName(partnerName)).andReturn(mockBuilder); + } + + EasyMock.expect(mockBuilder.build()).andReturn(EasyMock.mock(ContextData.class)); + EasyMock.replay(mockBuilder); + + PowerMock.mockStatic(ContextData.class); + + ContextData.builder(); + PowerMock.expectLastCall().andReturn(mockBuilder); + + PowerMock.replay(ContextData.class); + } + + private void mockLoggingContext() { + + PowerMock.mockStatic(LoggingContext.class); + + LoggingContext.clear(); + EasyMock.expectLastCall().once(); + + LoggingContext.put(anyObject(ContextData.class)); + EasyMock.expectLastCall().once(); + + PowerMock.replay(LoggingContext.class); + } + + private abstract static class Header { + + private final String key; + private final String value; + + private Header(String key, String value) { + this.key = key; + this.value = value; + } + } + + private static class PartnerHeader extends Header { + + private PartnerHeader(String value) { + super(LoggingConstants.DEFAULT_PARTNER_NAME_HEADER, value); + } + + private PartnerHeader(String key, String value) { + super(key, value); + } + } + + private static class RequestIdHeader extends Header { + + private RequestIdHeader(String value) { + super(LoggingConstants.DEFAULT_REQUEST_ID_HEADER, value); + } + + private RequestIdHeader(String key, String value) { + super(key, value); + } + } + + private static class MockResource { + + @SuppressWarnings("EmptyMethod") + void process() { + // no-op + } + } +}
\ No newline at end of file diff --git a/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilterTest.java b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilterTest.java new file mode 100644 index 0000000000..37627d5d5a --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-api/src/test/java/org/openecomp/sdc/logging/servlet/jaxrs/LoggingResponseFilterTest.java @@ -0,0 +1,234 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.logging.servlet.jaxrs; + +import static org.easymock.EasyMock.anyObject; +import static org.easymock.EasyMock.anyString; + +import java.util.Comparator; +import java.util.Objects; +import java.util.function.Consumer; +import javax.servlet.http.HttpServletRequest; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.container.ContainerResponseContext; +import javax.ws.rs.core.Response; +import org.easymock.EasyMock; +import org.easymock.LogicalOperator; +import org.openecomp.sdc.logging.api.AuditData; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.logging.api.LoggingContext; +import org.openecomp.sdc.logging.api.StatusCode; +import org.powermock.api.easymock.PowerMock; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.testng.PowerMockTestCase; +import org.testng.ITestResult; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + + +/** + * Unit testing JAX-RS response filter. + * + * @author evitaliy + * @since 19 Mar 2018 + */ +@PrepareForTest({LoggingContext.class, LoggerFactory.class}) +public class LoggingResponseFilterTest extends PowerMockTestCase { + + /** + * Verify all mocks after each test. + */ + @AfterMethod + public void verifyMocks(ITestResult result) { + + try { + PowerMock.verifyAll(); + } catch (AssertionError e) { + throw new AssertionError("Expectations failed in: " + result.getMethod().getMethodName(), e); + } + } + + @Test + public void noAuditWhenAuditDisabled() { + mockLogger(false, AuditData.builder().build()); + mockLoggingContext(); + new LoggingResponseFilter().filter(mockDisabledRequestContext(), mockDisabledResponseContext()); + } + + private void mockLogger(boolean enabled, AuditData auditData, Consumer<Logger>... additionalMockings) { + + Logger logger = EasyMock.mock(Logger.class); + + EasyMock.expect(logger.isAuditEnabled()).andReturn(enabled).atLeastOnce(); + + if (enabled) { + logger.audit(EasyMock.cmp(auditData, new AuditDataComparator(), LogicalOperator.EQUAL)); + EasyMock.expectLastCall(); + } + + for (Consumer<Logger> mocking : additionalMockings) { + mocking.accept(logger); + } + + EasyMock.replay(logger); + + PowerMock.mockStatic(LoggerFactory.class); + LoggerFactory.getLogger(LoggingResponseFilter.class); + PowerMock.expectLastCall().andReturn(logger); + PowerMock.replay(LoggerFactory.class); + } + + private void mockLoggingContext() { + PowerMock.mockStatic(LoggingContext.class); + LoggingContext.clear(); + EasyMock.expectLastCall().once(); + PowerMock.replay(LoggingContext.class); + } + + private ContainerRequestContext mockDisabledRequestContext() { + ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class); + EasyMock.replay(requestContext); + return requestContext; + } + + private ContainerResponseContext mockDisabledResponseContext() { + ContainerResponseContext responseContext = EasyMock.mock(ContainerResponseContext.class); + EasyMock.replay(responseContext); + return responseContext; + } + + @Test + public void startTimeReadWhenPresentInRequestContext() { + + final String clientIp = "10.56.56.10"; + final long startTime = 12345L; + final Response.Status ok = Response.Status.OK; + + mockLogger(true, buildAuditData(startTime, clientIp, ok, StatusCode.COMPLETE)); + + mockLoggingContext(); + LoggingResponseFilter filter = new LoggingResponseFilter(); + filter.setHttpRequest(mockHttpRequest(clientIp)); + + filter.filter(mockRequestContext(startTime), mockResponseContext(ok)); + } + + private AuditData buildAuditData(long startTime, String clientIp, Response.Status responseStatus, + StatusCode status) { + return AuditData.builder().startTime(startTime).responseCode(Integer.toString(responseStatus.getStatusCode())) + .responseDescription(responseStatus.getReasonPhrase()).clientIpAddress(clientIp) + .statusCode(status).build(); + } + + private HttpServletRequest mockHttpRequest(String clientIp) { + HttpServletRequest servletRequest = EasyMock.mock(HttpServletRequest.class); + EasyMock.expect(servletRequest.getRemoteAddr()).andReturn(clientIp); + EasyMock.replay(servletRequest); + return servletRequest; + } + + private ContainerRequestContext mockRequestContext(Object startTime) { + ContainerRequestContext requestContext = EasyMock.mock(ContainerRequestContext.class); + EasyMock.expect(requestContext.getProperty(LoggingRequestFilter.START_TIME_KEY)).andReturn(startTime); + EasyMock.replay(requestContext); + return requestContext; + } + + private ContainerResponseContext mockResponseContext(Response.StatusType statusInfo) { + ContainerResponseContext responseContext = EasyMock.mock(ContainerResponseContext.class); + EasyMock.expect(responseContext.getStatusInfo()).andReturn(statusInfo); + EasyMock.replay(responseContext); + return responseContext; + } + + @Test + public void startTimeZeroWhenNotPresentInRequestContext() { + + final String clientIp = "10.56.56.12"; + final Response.Status ok = Response.Status.OK; + + AuditData expectedAuditData = buildAuditData(0, clientIp, ok, StatusCode.COMPLETE); + + mockLogger(true, expectedAuditData, logger -> { + logger.error(anyString(), anyObject(Object[].class)); + EasyMock.expectLastCall(); + }); + + mockLoggingContext(); + LoggingResponseFilter filter = new LoggingResponseFilter(); + filter.setHttpRequest(mockHttpRequest(clientIp)); + + filter.filter(mockRequestContext(null), mockResponseContext(ok)); + } + + @Test + public void startTimeZeroWhenIncorrectObjectType() { + + final String clientIp = "10.56.56.13"; + final Response.Status accepted = Response.Status.ACCEPTED; + + AuditData expectedAuditData = buildAuditData(0, clientIp, accepted, StatusCode.COMPLETE); + + mockLogger(true, expectedAuditData, logger -> { + logger.error(anyString(), new Object[] {anyString(), anyString()}); + EasyMock.expectLastCall(); + }); + + mockLoggingContext(); + LoggingResponseFilter filter = new LoggingResponseFilter(); + filter.setHttpRequest(mockHttpRequest(clientIp)); + + filter.filter(mockRequestContext("string object"), mockResponseContext(accepted)); + } + + @Test + public void statusErrorWhenHttpResponseGreaterThan399() { + + final Response.Status error = Response.Status.BAD_REQUEST; + final String clientIp = "10.56.56.13"; + final long startTime = 88668603L; + + AuditData expectedAuditData = buildAuditData(startTime, clientIp, error, StatusCode.ERROR); + + mockLogger(true, expectedAuditData); + + mockLoggingContext(); + LoggingResponseFilter filter = new LoggingResponseFilter(); + filter.setHttpRequest(mockHttpRequest(clientIp)); + + filter.filter(mockRequestContext(startTime), mockResponseContext(error)); + } + + private static class AuditDataComparator implements Comparator<AuditData> { + + @Override + public int compare(AuditData one, AuditData two) { + + // don't compare end time as it changes + if (Objects.equals(one.getClientIpAddress(), two.getClientIpAddress()) && Objects + .equals(one.getResponseCode(), two.getResponseCode()) && Objects + .equals(one.getResponseDescription(), one.getResponseDescription()) && one.getStartTime() == two + .getStartTime() && Objects.equals(one.getStatusCode(), two.getStatusCode())) { + + return 0; + } + + return -1; + } + } +}
\ No newline at end of file |