gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 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;
  18
  19 import ch.qos.logback.classic.Level;
  20 import ch.qos.logback.classic.Logger;
  21 import ch.qos.logback.classic.sift.SiftingAppender;
  22 import ch.qos.logback.classic.spi.ILoggingEvent;
  23 import ch.qos.logback.core.AppenderBase;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.concurrent.ConcurrentHashMap;
  29 import java.util.function.Predicate;
  30 import org.junit.Assert;
  31 import org.junit.BeforeClass;
  32 import org.junit.Test;
  33 import org.openecomp.sdc.logging.logback.EventTypeDiscriminator;
  34 import org.openecomp.sdc.logging.slf4j.Markers;
  35 import org.slf4j.LoggerFactory;
  36
  37 /**
  38  * Routing of events to the correct appender.
  39  *
  40  * @author EVITALIY
  41  * @since 17/08/2016.
  42  */
  43 public class RoutingTest {
  44
  45     private static final String ERROR = "Error";
  46     private static final String DEBUG = "Debug";
  47     private static final String AUDIT = "Audit";
  48     private static final String METRICS = "Metrics";
  49     private static final Map<String, TestAppender> result = new ConcurrentHashMap<>();
  50     private static Logger logger;
  51
  52     @BeforeClass
  53     public static void setUp() {
  54
  55         SiftingAppender appender = new SiftingAppender();
  56
  57         EventTypeDiscriminator discriminator = new EventTypeDiscriminator();
  58         discriminator.start();
  59
  60         appender.setDiscriminator(discriminator);
  61         appender.setAppenderFactory((context,
  62                 discriminatingValue) -> result.computeIfAbsent(discriminatingValue, f -> {
  63                     TestAppender tmp = new TestAppender();
  64                     tmp.start();
  65                     return tmp;
  66                 }));
  67
  68         appender.start();
  69
  70         logger = (Logger) LoggerFactory.getLogger(RoutingTest.class.getName());
  71         // prevent from writing into appenders attached via parent loggers
  72         logger.setAdditive(false);
  73         logger.addAppender(appender);
  74         logger.setLevel(Level.DEBUG);
  75     }
  76
  77     @Test
  78     public void testWarning() {
  79         String msg = "This is a test warning";
  80         logger.warn(msg);
  81         TestAppender appender = result.get(ERROR);
  82         Assert.assertTrue(appender.contains(
  83                 (event) -> Level.WARN.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
  84     }
  85
  86     @Test
  87     public void testError() {
  88         String msg = "This is a test error";
  89         logger.error(msg);
  90         TestAppender appender = result.get(ERROR);
  91         Assert.assertTrue(appender.contains(
  92                 (event) -> Level.ERROR.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
  93     }
  94
  95     @Test
  96     public void testDebug() {
  97         String msg = "This is a test debug";
  98         logger.debug(msg);
  99         TestAppender appender = result.get(DEBUG);
 100         Assert.assertTrue(appender.contains(
 101                 (event) -> Level.DEBUG.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
 102     }
 103
 104     @Test
 105     public void testInfo() {
 106         String msg = "This is a test info";
 107         logger.info(msg);
 108         TestAppender appender = result.get(ERROR);
 109         Assert.assertTrue(appender.contains(
 110                 (event) -> Level.INFO.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
 111     }
 112
 113     @Test
 114     public void testAudit() {
 115         String msg = "This is a test audit";
 116         logger.info(Markers.AUDIT, msg);
 117         TestAppender appender = result.get(AUDIT);
 118         Assert.assertTrue(appender.contains(
 119                 (event) -> Level.INFO.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
 120     }
 121
 122     @Test
 123     public void testMetrics() {
 124         String msg = "This is a test metrics";
 125         logger.info(Markers.METRICS, msg);
 126         TestAppender appender = result.get(METRICS);
 127         Assert.assertTrue(appender.contains(
 128                 (event) -> Level.INFO.equals(event.getLevel()) && msg.equals(event.getFormattedMessage())));
 129     }
 130
 131     /**
 132      * An appender that just accumulates messages in a list and enables to inspect them.
 133      *
 134      * @author EVITALIY
 135      * @since 17/08/2016.
 136      */
 137     private static class TestAppender extends AppenderBase<ILoggingEvent> {
 138
 139         private final List<ILoggingEvent> events = Collections.synchronizedList(new ArrayList<>(10));
 140
 141         @Override
 142         protected void append(ILoggingEvent event) {
 143             this.events.add(event);
 144         }
 145
 146         boolean contains(Predicate<ILoggingEvent> predicate) {
 147             return events.stream().anyMatch(predicate);
 148         }
 149     }
 150 }