common-app-logging/src/test/java/org/openecomp/sdc/common/log/wrappers/LoggerTest.java

   1 package org.openecomp.sdc.common.log.wrappers;
   2
   3 import org.junit.Before;
   4 import org.junit.Test;
   5 import org.junit.runner.RunWith;
   6 import org.mockito.ArgumentCaptor;
   7 import org.mockito.Captor;
   8 import org.mockito.InjectMocks;
   9 import org.mockito.Mock;
  10 import org.mockito.junit.MockitoJUnitRunner;
  11 import org.onap.logging.ref.slf4j.ONAPLogConstants;
  12 import org.openecomp.sdc.common.log.api.ILogConfiguration;
  13 import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
  14 import org.openecomp.sdc.common.log.elements.LoggerError;
  15 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
  16 import org.openecomp.sdc.common.log.enums.LogLevel;
  17 import org.openecomp.sdc.common.log.enums.Severity;
  18 import org.openecomp.sdc.common.log.utils.LoggingThreadLocalsHolder;
  19 import org.slf4j.MDC;
  20 import org.slf4j.Marker;
  21 import org.slf4j.MarkerFactory;
  22
  23 import javax.ws.rs.container.ContainerRequestContext;
  24 import javax.ws.rs.core.Response;
  25 import javax.ws.rs.core.UriInfo;
  26 import java.net.URI;
  27 import java.net.URISyntaxException;
  28
  29 import static org.junit.Assert.*;
  30 import static org.mockito.ArgumentMatchers.*;
  31 import static org.mockito.Mockito.*;
  32 import static org.onap.logging.ref.slf4j.ONAPLogConstants.MDCs.REQUEST_ID;
  33 import static org.onap.logging.ref.slf4j.ONAPLogConstants.MDCs.SERVICE_NAME;
  34 import static org.openecomp.sdc.common.log.api.ILogConfiguration.*;
  35
  36 @RunWith(MockitoJUnitRunner.class)
  37 public class LoggerTest {
  38
  39     private final static String targetEntity = "DCEA";
  40     private final static String targetServiceName = "test target name";
  41     private final static String serviceName = "testService";
  42     private final static String message = "Logger message";
  43     private final static String exceptionMsg= "Exception testing";
  44     private final static String missingFieldsMessageFragment = "mandatory parameters for ECOMP logging";
  45
  46     @Mock
  47     private org.slf4j.Logger logger;
  48     @Mock
  49     private ContainerRequestContext requestContext;
  50     @Mock
  51     private UriInfo uriInfo;
  52     @Mock
  53     private Response.StatusType statusType;
  54
  55     @InjectMocks
  56     private Logger commonLogger;
  57
  58     @Captor
  59     private ArgumentCaptor<String> captor;
  60
  61     @Before
  62     public void setUp() {
  63         MDC.clear();
  64     }
  65
  66     @Test
  67     public void validateErrorLogWhenErrorSettingsProvided() {
  68         when(logger.isErrorEnabled()).thenReturn(true);
  69         commonLogger.error(EcompLoggerErrorCode.PERMISSION_ERROR, serviceName, targetEntity, message);
  70
  71         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
  72         assertEquals(message, captor.getValue());
  73         assertEquals(String.valueOf(EcompLoggerErrorCode.PERMISSION_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
  74         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
  75         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
  76         assertEquals(serviceName, MDC.get(SERVICE_NAME));
  77     }
  78
  79     @Test
  80     public void validateWarnMessageIsLoggedWhenAllErrorSettingsProvided() {
  81         when(logger.isErrorEnabled()).thenReturn(true);
  82         commonLogger.error(EcompLoggerErrorCode.AVAILABILITY_TIMEOUTS_ERROR, serviceName, targetEntity, message);
  83
  84         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
  85         assertEquals(message, captor.getValue());
  86         assertEquals(String.valueOf(EcompLoggerErrorCode.AVAILABILITY_TIMEOUTS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
  87         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
  88         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
  89         assertEquals(serviceName, MDC.get(SERVICE_NAME));
  90     }
  91
  92     @Test
  93     public void validateFatalMessageIsLoggedWhenAllErrorSettingsProvided() {
  94         when(logger.isErrorEnabled()).thenReturn(true);
  95         commonLogger.fatal(EcompLoggerErrorCode.PERMISSION_ERROR, serviceName, targetEntity, message);
  96
  97         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
  98         assertEquals(message, captor.getValue());
  99         assertEquals(String.valueOf(EcompLoggerErrorCode.PERMISSION_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 100         assertEquals(LogLevel.FATAL.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 101         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 102         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 103     }
 104
 105     @Test
 106     public void validateWarnMessage_AllErrorElements() {
 107         when(logger.isWarnEnabled()).thenReturn(true);
 108         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 109                 .targetEntity(targetEntity)
 110                 .targetServiceName(targetServiceName).build();
 111         commonLogger.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 112         verify(logger).warn(any(Marker.class), captor.capture(), any(Object[].class));
 113         assertEquals(message, captor.getValue());
 114         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 115         assertEquals(LogLevel.WARN.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 116         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 117         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 118         assertEquals(targetServiceName, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 119     }
 120
 121     @Test
 122     public void validateWarnMessage_emptyTargetEntity() {
 123         when(logger.isWarnEnabled()).thenReturn(true);
 124         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 125                 .targetServiceName(targetServiceName).build();
 126         commonLogger.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 127         verify(logger).warn(any(Marker.class), captor.capture(), any(Object[].class));
 128         assertEquals(message, captor.getValue());
 129         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 130         assertEquals(LogLevel.WARN.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 131         assertEquals(null, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 132         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 133         assertEquals(targetServiceName, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 134     }
 135
 136     @Test
 137     public void validateWarnMessage_emptyTargetServiceName() {
 138         when(logger.isWarnEnabled()).thenReturn(true);
 139         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 140                 .targetEntity(targetEntity).build();
 141         commonLogger.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 142         verify(logger).warn(any(Marker.class), captor.capture(), any(Object[].class));
 143         assertEquals(message, captor.getValue());
 144         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 145         assertEquals(LogLevel.WARN.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 146         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 147         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 148         assertEquals(null, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 149     }
 150
 151
 152     @Test
 153     public void validateErrorMessage_AllErrorElements() {
 154         when(logger.isErrorEnabled()).thenReturn(true);
 155         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 156                 .targetEntity(targetEntity)
 157                 .targetServiceName(targetServiceName).build();
 158         commonLogger.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 159         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
 160         assertEquals(message, captor.getValue());
 161         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 162         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 163         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 164         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 165         assertEquals(targetServiceName, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 166     }
 167
 168     @Test
 169     public void validateErrorMessage_emptyTargetEntity() {
 170         when(logger.isErrorEnabled()).thenReturn(true);
 171         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 172                 .targetServiceName(targetServiceName).build();
 173         commonLogger.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 174         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
 175         assertEquals(message, captor.getValue());
 176         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 177         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 178         assertEquals(null, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 179         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 180         assertEquals(targetServiceName, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 181     }
 182
 183     @Test
 184     public void validateErrorMessage_emptyTargetServiceName() {
 185         when(logger.isErrorEnabled()).thenReturn(true);
 186         ErrorLogOptionalData errorLogOptionalData = ErrorLogOptionalData.newBuilder()
 187                 .targetEntity(targetEntity).build();
 188         commonLogger.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName,errorLogOptionalData, message);
 189         verify(logger).error(any(Marker.class), captor.capture(), any(Object[].class));
 190         assertEquals(message, captor.getValue());
 191         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 192         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 193         assertEquals(targetEntity, MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 194         assertEquals(serviceName, MDC.get(SERVICE_NAME));
 195         assertEquals(null, MDC.get(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME));
 196     }
 197
 198
 199
 200     @Test
 201     public void validateErrorMessageIsNotLoggedWhenErrorLevelIsDisabledEvenIfErrorSettingsProvided() {
 202         commonLogger.error(EcompLoggerErrorCode.PERMISSION_ERROR, serviceName, targetEntity, message);
 203         verify(logger, never()).error(any(Marker.class), any(String.class));
 204     }
 205
 206     @Test
 207     public void validateErrorLogWhenErrorSettingsProvidedPartially() {
 208         when(logger.isErrorEnabled()).thenReturn(true);
 209         commonLogger.error(message);
 210
 211         verify(logger).error(any(Marker.class), eq(message), any(Object[].class));
 212         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 213         assertEquals(LogLevel.ERROR.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 214         assertNull(MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 215         assertEquals(LoggerError.defaultServiceName, MDC.get(SERVICE_NAME));
 216     }
 217
 218     @Test
 219     public void errorMessageIsNotLoggedWhenErrorLevelIsDisabled() {
 220         commonLogger.error(message);
 221         verify(logger, times(0)).error(any(Marker.class), anyString());
 222     }
 223
 224     @Test
 225     public void traceMessageWithExceptionIsNotLoggedWhenTraceLevelIsDisabled() {
 226         commonLogger.trace(message, new UnsupportedOperationException());
 227         verify(logger, times(0)).trace(any(Marker.class), anyString());
 228     }
 229
 230     @Test
 231     public void verifyInfoMessage() {
 232         final String msg = "Info message";
 233         when(logger.isInfoEnabled()).thenReturn(true);
 234         commonLogger.info(msg, new RuntimeException());
 235         verify(logger).info(any(Marker.class), anyString());
 236     }
 237
 238     @Test
 239     public void verifyWarnMessage() {
 240         when(logger.isWarnEnabled()).thenReturn(true);
 241         commonLogger.warn("Text");
 242         assertEquals(LogLevel.WARN.name(), MDC.get(MDC_ERROR_CATEGORY));
 243         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(MDC_ERROR_CODE));
 244         assertEquals(LoggerError.defaultServiceName, MDC.get(SERVICE_NAME));
 245     }
 246
 247     @Test
 248     public void validateErrorLogWithExceptionWhenErrorSettingsProvidedPartially() {
 249         LoggingThreadLocalsHolder.setUuid("uuid");
 250         final String logFieldsNotProvidedMsg = "mandatory parameters for ECOMP logging, missing fields: ServiceName PartnerName";
 251         when(logger.isWarnEnabled()).thenReturn(true);
 252         commonLogger.warn(message, new NullPointerException(exceptionMsg));
 253
 254         //the expected warn message
 255         verify(logger).warn(any(Marker.class), contains(message), any(Object[].class));
 256         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(ILogConfiguration.MDC_ERROR_CODE));
 257         assertEquals(LogLevel.WARN.name(), MDC.get(ILogConfiguration.MDC_ERROR_CATEGORY));
 258         assertEquals("uuid", MDC.get(REQUEST_ID));
 259         assertNull(MDC.get(ONAPLogConstants.MDCs.TARGET_ENTITY));
 260         assertEquals(LoggerError.defaultServiceName, MDC.get(SERVICE_NAME));
 261     }
 262
 263
 264     @Test
 265     public void validateDebugLogWithException() {
 266         final String msg = "Debug message";
 267         LoggingThreadLocalsHolder.setUuid("uuid");
 268         when(logger.isDebugEnabled()).thenReturn(true);
 269         commonLogger.debug(msg, new RuntimeException());
 270
 271         verify(logger).debug(any(Marker.class), eq(msg), any(RuntimeException.class));
 272     }
 273
 274     @Test
 275     public void validateTraceLogWithExceptionAndPartialParamsAndDebugLevelDisabled() {
 276         final String msg = "Debug message";
 277         when(logger.isTraceEnabled()).thenReturn(true);
 278         commonLogger.trace(msg, new RuntimeException());
 279
 280         verify(logger).trace(any(Marker.class), eq(msg), any(RuntimeException.class));
 281     }
 282
 283     @Test
 284     public void warnMessageWithParameterIsNotLoggedIfWarnLevelIsDisabled() {
 285         commonLogger.warn("msg", "param");
 286         verify(logger, times(0)).warn(any(Marker.class),
 287                                     anyString(), any(Object.class));
 288     }
 289
 290     @Test
 291     public void verifyMdcValuesAreStoredWhenAuditAndErrorLoggersAreInvokedSequentially() throws URISyntaxException {
 292         final String uuid = "12345";
 293         final String message = "message";
 294         when(requestContext.getHeaderString(anyString())).thenReturn("ab2222");
 295         when(requestContext.getUriInfo()).thenReturn(uriInfo);
 296         when(logger.isErrorEnabled()).thenReturn(true);
 297
 298         URI uri = new URI("http:/abc.com/getId");
 299         when(uriInfo.getRequestUri()).thenReturn(uri);
 300         when(uriInfo.getBaseUri()).thenReturn(uri);
 301         when(statusType.getStatusCode()).thenReturn(200);
 302         when(statusType.getReasonPhrase()).thenReturn("OK");
 303         LoggerSdcAudit audit = new LoggerSdcAudit(this.getClass());
 304         LoggingThreadLocalsHolder.setUuid(uuid);
 305         audit.startLog(requestContext);
 306         audit.logExit("abc.log.com", requestContext, statusType, LogLevel.INFO, Severity.OK, message,
 307                 MarkerFactory.getMarker(ONAPLogConstants.Markers.EXIT.getName()));
 308
 309         commonLogger.error(message);
 310         verify(logger).error(any(Marker.class), eq(message), any(Object[].class));
 311         assertEquals(uuid, MDC.get(REQUEST_ID));
 312         assertEquals("/", MDC.get(SERVICE_NAME));
 313         assertEquals(LogLevel.ERROR.name(), MDC.get(MDC_ERROR_CATEGORY));
 314         assertEquals(String.valueOf(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode()), MDC.get(MDC_ERROR_CODE));
 315     }
 316
 317     @Test
 318     public void verifyLoggerDoesNothingWhenTheLevelIsNotSet() {
 319         if (commonLogger.isDebugEnabled()) {
 320             commonLogger.debug("text");
 321         }
 322         verify(logger, times(0)).debug(any(Marker.class), anyString(), eq((Object[])null));
 323     }
 324
 325     @Test
 326     public void verifyLoggerTraceMethodIsCalledWhenTheLevelIsSet() {
 327         LoggingThreadLocalsHolder.setUuid("1234");
 328         when(logger.isTraceEnabled()).thenReturn(true);
 329         if (commonLogger.isTraceEnabled()) {
 330             commonLogger.trace("text");
 331         }
 332         verify(logger, times(1)).trace(any(Marker.class), anyString(), eq((Object[])null));
 333     }
 334
 335
 336     @Test
 337     public void verifyMdcValuesAreStoredWhenTraceLoggerIsInvokedAfterAuditStart() throws URISyntaxException {
 338         final String uuid = "12345";
 339         final String message = "message";
 340         when(requestContext.getHeaderString(anyString())).thenReturn("ab2222");
 341         when(requestContext.getUriInfo()).thenReturn(uriInfo);
 342         when(logger.isTraceEnabled()).thenReturn(true);
 343
 344         URI uri = new URI("http:/abc.com/getId");
 345         when(uriInfo.getRequestUri()).thenReturn(uri);
 346         when(uriInfo.getBaseUri()).thenReturn(uri);
 347         LoggerSdcAudit audit = new LoggerSdcAudit(this.getClass());
 348         LoggingThreadLocalsHolder.setUuid(uuid);
 349         audit.startLog(requestContext);
 350
 351         commonLogger.trace(message);
 352         verify(logger).trace(any(Marker.class), captor.capture(), eq((Object[])null));
 353         assertEquals(message, captor.getValue());
 354         assertEquals(uuid, MDC.get(REQUEST_ID));
 355     }
 356
 357
 358 }