appc-common/src/test/java/org/onap/appc/logging/LoggingUtilsTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2018 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  *
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.appc.logging;
  23
  24 import org.junit.Test;
  25 import org.powermock.reflect.Whitebox;
  26 import org.slf4j.MDC;
  27 import com.att.eelf.configuration.EELFLogger;
  28 import com.att.eelf.configuration.EELFManager;
  29 import static org.junit.Assert.assertEquals;
  30 import static org.junit.Assert.assertNotNull;
  31 import static org.junit.Assert.assertNull;
  32 import static org.junit.Assert.fail;
  33 import java.lang.Class;
  34 import java.lang.reflect.Method;
  35 import java.time.Instant;
  36
  37 public class LoggingUtilsTest {
  38     @Test(expected = IllegalAccessError.class)
  39     public void testConstructor() throws Exception {
  40         Whitebox.invokeConstructor(LoggingUtils.class);
  41     }
  42
  43     @Test
  44     public void testLogErrorMessageStringStringStringStringStringString() {
  45         try {
  46             LoggingUtils.logErrorMessage("ERROR_CODE", "ERROR_DESCRIPTION", "TARGET_ENTITY", "TARGET_SERVICE_NAME", "ADDITIONAL_MESSAGE", "CLASS_NAME");
  47             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
  48         } catch (Exception e) {
  49             fail("Exception invoking logErrorMessage: " + e.toString());
  50         }
  51     }
  52
  53     @Test
  54     public void testLogErrorMessageStringStringStringString() {
  55         try {
  56             LoggingUtils.logErrorMessage("TARGET_ENTITY", "TARGET_SERVICE_NAME", "ADDITIONAL_MESSAGE", "CLASS_NAME");
  57             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
  58         } catch (Exception e) {
  59             fail("Exception invoking logErrorMessage: " + e.toString());
  60         }
  61         }
  62
  63     @Test
  64     public void testLogErrorMessageStringStringString() {
  65         try {
  66             LoggingUtils.logErrorMessage("TARGET_SERVICE_NAME", "ADDITIONAL_MESSAGE", "CLASS_NAME");
  67             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
  68         } catch (Exception e) {
  69             fail("Exception invoking logErrorMessage: " + e.toString());
  70         }
  71     }
  72
  73     @Test
  74     public void testLogError() {
  75         try {
  76             Class<?>[] paramString = { String.class, String.class, String.class, String.class, String.class, String.class };
  77             Method m = LoggingUtils.class.getDeclaredMethod("logError", paramString);
  78             m.setAccessible(true);
  79             m.invoke(null, "ERROR_CODE", "ERROR_DESCRIPTION", "TARGET_ENTITY", "TARGET_SERVICE_NAME", "ADDITIONAL_MESSAGE", "CLASS_NAME");
  80             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
  81         } catch (Exception e) {
  82             fail("Exception invoking logError: " + e.toString());
  83         }
  84     }
  85
  86     @Test
  87     public void testLogAuditMessage() {
  88         try {
  89             Class<?>[] paramString = { Instant.class, Instant.class, String.class, String.class, String.class };
  90             Method m = LoggingUtils.class.getDeclaredMethod("logAuditMessage", paramString);
  91             m.setAccessible(true);
  92             java.util.Date timestamp = new java.util.Date();
  93             m.invoke(null, timestamp.toInstant(), timestamp.toInstant(), "CODE", "RESPONSE_DESCRIPTION", "CLASS_NAME");
  94             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
  95         } catch (Exception e) {
  96             fail("Exception invoking logAuditMessage: " + e.toString());
  97         }
  98     }
  99
 100     @Test
 101     public void testAuditInfo() {
 102         try {
 103             EELFLogger auditLogger = EELFManager.getInstance().getAuditLogger();
 104             auditLogger.info("Audit logging test info");
 105         } catch (Exception e) {
 106             fail("Exception invoking testAuditInfo: " + e.toString());
 107         }
 108     }
 109
 110     @Test
 111     public void testAuditWarn() {
 112         try {
 113             EELFLogger auditLogger = EELFManager.getInstance().getAuditLogger();
 114             auditLogger.warn("Audit logging test warning");
 115         } catch (Exception e) {
 116             fail("Exception invoking testAuditWarn: " + e.toString());
 117         }
 118     }
 119
 120     @Test
 121     public void testLogMetricsMessage() {
 122         try {
 123             java.util.Date timestamp = new java.util.Date();
 124             LoggingUtils.logMetricsMessage(timestamp.toInstant(), timestamp.toInstant(), "TARGET_ENTITY", "TARGET_SERVICE_NAME", "STATUS_CODE", "RESPONSE_CODE", "RESPONSE_DESCRIPTION", "CLASS_NAME");
 125             assertNull(MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 126
 127         } catch (Exception e) {
 128             fail("Exception invoking logMetricsMessage: " + e.toString());
 129         }
 130     }
 131
 132     @Test
 133     public void testPopulateAuditLogContext() {
 134         try {
 135             Class<?>[] paramString = { Instant.class, Instant.class, String.class, String.class, String.class };
 136             Method m = LoggingUtils.class.getDeclaredMethod("populateAuditLogContext", paramString);
 137             m.setAccessible(true);
 138             java.util.Date timestamp = new java.util.Date();
 139             m.invoke(null, timestamp.toInstant(), timestamp.toInstant(), "100", "RESPONSE_DESCRIPTION", "CLASS_NAME");
 140             assertEquals("COMPLETE", MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 141             assertEquals("100", MDC.get(LoggingConstants.MDCKeys.RESPONSE_CODE));
 142             assertEquals("RESPONSE_DESCRIPTION", MDC.get(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION));
 143         } catch (Exception e) {
 144             fail("Exception invoking populateAuditLogContext: " + e.toString());
 145         }
 146     }
 147
 148     @Test
 149     public void testCleanAuditErrorContext() {
 150         try {
 151             Method m = LoggingUtils.class.getDeclaredMethod("cleanAuditErrorContext");
 152             m.setAccessible(true);
 153             MDC.put(LoggingConstants.MDCKeys.STATUS_CODE, "STATUS_CODE");
 154             MDC.put(LoggingConstants.MDCKeys.RESPONSE_CODE, "RESPONSE_CODE");
 155             MDC.put(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION, "RESPONSE_DESCRIPTION");
 156             MDC.put(LoggingConstants.MDCKeys.CLASS_NAME, "CLASS_NAME");
 157             m.invoke(null);
 158             assertNull(MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 159             assertNull(MDC.get(LoggingConstants.MDCKeys.RESPONSE_CODE));
 160             assertNull(MDC.get(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION));
 161             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
 162         } catch (Exception e) {
 163             fail("Exception invoking cleanAuditErrorLogContext: " + e.toString());
 164         }
 165     }
 166
 167     @Test
 168     public void testPopulateErrorLogContext() {
 169         try {
 170             Class<?>[] paramString = { String.class, String.class, String.class, String.class, String.class };
 171             Method m = LoggingUtils.class.getDeclaredMethod("populateErrorLogContext", paramString);
 172             m.setAccessible(true);
 173             m.invoke(null, "ERROR_CODE", "ERROR_DESCRIPTION", "TARGET_ENTITY", "TARGET_SERVICENAME", "CLASS_NAME");
 174             assertEquals("CLASS_NAME", MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
 175         } catch (Exception e) {
 176             fail("Exception invoking populateErrorLogContext: " + e.toString());
 177         }
 178     }
 179
 180     @Test
 181     public void testCleanErrorLogContext() {
 182         try {
 183             Method m = LoggingUtils.class.getDeclaredMethod("cleanErrorLogContext");
 184             m.setAccessible(true);
 185             MDC.put(LoggingConstants.MDCKeys.CLASS_NAME, "CLASS_NAME");
 186             m.invoke(null);
 187             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
 188         } catch (Exception e) {
 189             fail("Exception invoking cleanErrorLogContext: " + e.toString());
 190         }
 191     }
 192
 193     @Test
 194     public void testPopulateMetricLogContext() {
 195         try {
 196             Class<?>[] paramString = { Instant.class, Instant.class, String.class, String.class, String.class,
 197                     String.class, String.class, String.class };
 198             Method m = LoggingUtils.class.getDeclaredMethod("populateMetricLogContext", paramString);
 199             m.setAccessible(true);
 200             java.util.Date timestamp = new java.util.Date();
 201             m.invoke(null, timestamp.toInstant(), timestamp.toInstant(), "TARGET_ENTITY", "TARGET_SERVICE_NAME", "STATUS_CODE", "RESPONSE_CODE", "RESPONSE_DESCRIPTION", "CLASS_NAME");
 202             assertEquals("STATUS_CODE", MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 203             assertEquals("RESPONSE_CODE", MDC.get(LoggingConstants.MDCKeys.RESPONSE_CODE));
 204             assertEquals("RESPONSE_DESCRIPTION", MDC.get(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION));
 205         } catch (Exception e) {
 206             fail("Exception invoking populateMetricLogContext: " + e.toString());
 207         }
 208     }
 209
 210     @Test
 211     public void testCleanMetricContext() {
 212         try {
 213             Method m = LoggingUtils.class.getDeclaredMethod("cleanMetricContext");
 214             m.setAccessible(true);
 215             MDC.put(LoggingConstants.MDCKeys.CLASS_NAME, "CLASS_NAME");
 216             m.invoke(null);
 217             assertNull(MDC.get(LoggingConstants.MDCKeys.CLASS_NAME));
 218         } catch (Exception e) {
 219             fail("Exception invoking cleanMetricContext: " + e.toString());
 220         }
 221     }
 222
 223     @Test
 224     public void testPopulateTargetContext() {
 225         try {
 226             Class<?>[] paramString = { String.class, String.class };
 227             Method m = LoggingUtils.class.getDeclaredMethod("populateTargetContext", paramString);
 228             m.setAccessible(true);
 229             m.invoke(null, "TARGET_ENTITY", "TARGET_SERVICE_NAME");
 230             assertEquals("TARGET_ENTITY", MDC.get(LoggingConstants.MDCKeys.TARGET_ENTITY));
 231             assertEquals("TARGET_SERVICE_NAME", MDC.get(LoggingConstants.MDCKeys.TARGET_SERVICE_NAME));
 232         } catch (Exception e) {
 233             fail("Exception invoking populateTargetContext: " + e.toString());
 234         }
 235     }
 236
 237     @Test
 238     public void testCleanTargetContext() {
 239         try {
 240             Method m = LoggingUtils.class.getDeclaredMethod("cleanTargetContext");
 241             m.setAccessible(true);
 242             MDC.put(LoggingConstants.MDCKeys.TARGET_ENTITY, "TARGET_ENTITY");
 243             MDC.put(LoggingConstants.MDCKeys.TARGET_SERVICE_NAME, "TARGET_SERVICE_NAME");
 244             m.invoke(null);
 245             assertNull(MDC.get(LoggingConstants.MDCKeys.TARGET_ENTITY));
 246             assertNull(MDC.get(LoggingConstants.MDCKeys.TARGET_SERVICE_NAME));
 247         } catch (Exception e) {
 248             fail("Exception invoking cleanTargetContext: " + e.toString());
 249         }
 250     }
 251
 252     @Test
 253     public void testPopulateTimeContext() {
 254         try {
 255             Class<?>[] paramString = { Instant.class, Instant.class };
 256             Method m = LoggingUtils.class.getDeclaredMethod("populateTimeContext", paramString);
 257             m.setAccessible(true);
 258             java.util.Date timestamp = new java.util.Date();
 259             m.invoke(null, timestamp.toInstant(), timestamp.toInstant());
 260         } catch (Exception e) {
 261             fail("Exception invoking populateTimeContext: " + e.toString());
 262         }
 263     }
 264
 265     @Test
 266     public void testGenerateTimestampStr() {
 267         try {
 268             Class<?>[] paramString = { Instant.class };
 269             Method m = LoggingUtils.class.getDeclaredMethod("generateTimestampStr", paramString);
 270             m.setAccessible(true);
 271             java.util.Date timestamp = new java.util.Date();
 272             assertNotNull((String) m.invoke(null, timestamp.toInstant()));
 273         } catch (Exception e) {
 274             fail("Exception invoking testGenerateTimestampStr: " + e.toString());
 275         }
 276
 277     }
 278
 279     @Test
 280     public void testCleanTimeContext() {
 281         try {
 282             Method m = LoggingUtils.class.getDeclaredMethod("cleanTimeContext");
 283             m.setAccessible(true);
 284             MDC.put(LoggingConstants.MDCKeys.BEGIN_TIMESTAMP, "BEGIN_TIMESTAMP");
 285             MDC.put(LoggingConstants.MDCKeys.END_TIMESTAMP, "END_TIMESTAMP");
 286             MDC.put(LoggingConstants.MDCKeys.ELAPSED_TIME, "ELAPSED_TIME");
 287             m.invoke(null);
 288             assertNull(MDC.get(LoggingConstants.MDCKeys.BEGIN_TIMESTAMP));
 289             assertNull(MDC.get(LoggingConstants.MDCKeys.END_TIMESTAMP));
 290             assertNull(MDC.get(LoggingConstants.MDCKeys.ELAPSED_TIME));
 291         } catch (Exception e) {
 292             fail("Exception invoking cleanErrorContext: " + e.toString());
 293         }
 294     }
 295
 296     @Test
 297     public void testPopulateResponseContext() {
 298         try {
 299             Class<?>[] paramString = { String.class, String.class, String.class };
 300             Method m = LoggingUtils.class.getDeclaredMethod("populateResponseContext", paramString);
 301             m.setAccessible(true);
 302             m.invoke(null, "STATUS_CODE", "RESPONSE_CODE", "RESPONSE_DESCRIPTION");
 303             assertEquals("STATUS_CODE", MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 304             assertEquals("RESPONSE_CODE", MDC.get(LoggingConstants.MDCKeys.RESPONSE_CODE));
 305             assertEquals("RESPONSE_DESCRIPTION", MDC.get(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION));
 306         } catch (Exception e) {
 307             fail("Exception invoking populateResponseContext: " + e.toString());
 308         }
 309     }
 310
 311     @Test
 312     public void testCleanResponseContext() {
 313         try {
 314             Method m = LoggingUtils.class.getDeclaredMethod("cleanResponseContext");
 315             m.setAccessible(true);
 316             MDC.put(LoggingConstants.MDCKeys.STATUS_CODE, "STATUS_CODE");
 317             MDC.put(LoggingConstants.MDCKeys.RESPONSE_CODE, "RESPONSE_CODE");
 318             MDC.put(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION, "RESPONSE_DESCRIPTION");
 319             m.invoke(null);
 320             assertNull(MDC.get(LoggingConstants.MDCKeys.STATUS_CODE));
 321             assertNull(MDC.get(LoggingConstants.MDCKeys.RESPONSE_CODE));
 322             assertNull(MDC.get(LoggingConstants.MDCKeys.RESPONSE_DESCRIPTION));
 323         } catch (Exception e) {
 324             fail("Exception invoking cleanErrorContext: " + e.toString());
 325         }
 326     }
 327
 328     @Test
 329     public void testPopulateErrorContext() {
 330         try {
 331             Class<?>[] paramString = { String.class, String.class };
 332             Method m = LoggingUtils.class.getDeclaredMethod("populateErrorContext", paramString);
 333             m.setAccessible(true);
 334             m.invoke(null, "ERROR_CODE", "ERROR_DESCRIPTION");
 335             assertEquals("ERROR_CODE", MDC.get(LoggingConstants.MDCKeys.ERROR_CODE));
 336             assertEquals("ERROR_DESCRIPTION", MDC.get(LoggingConstants.MDCKeys.ERROR_DESCRIPTION));
 337         } catch (Exception e) {
 338             fail("Exception invoking populateErrorContext: " + e.toString());
 339         }
 340     }
 341
 342     @Test
 343     public void testCleanErrorContext() {
 344         try {
 345             Method m = LoggingUtils.class.getDeclaredMethod("cleanErrorContext");
 346             m.setAccessible(true);
 347             MDC.put(LoggingConstants.MDCKeys.ERROR_CODE, "ERROR_CODE");
 348             MDC.put(LoggingConstants.MDCKeys.ERROR_DESCRIPTION, "ERROR_DESCRIPTION");
 349             m.invoke(null);
 350             assertNull(MDC.get(LoggingConstants.MDCKeys.ERROR_CODE));
 351             assertNull(MDC.get(LoggingConstants.MDCKeys.ERROR_DESCRIPTION));
 352         } catch (Exception e) {
 353             fail("Exception invoking cleanErrorContext: " + e.toString());
 354         }
 355     }
 356
 357 }