opendaylight/config/logback-config/src/test/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImplTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.config.yang.logback.config;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15
  16 import java.util.Collection;
  17 import java.util.Iterator;
  18 import java.util.List;
  19
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.mockito.Mock;
  23 import org.mockito.MockitoAnnotations;
  24 import org.opendaylight.controller.config.api.DependencyResolver;
  25 import org.opendaylight.controller.config.api.ModuleIdentifier;
  26 import org.slf4j.LoggerFactory;
  27
  28 import ch.qos.logback.classic.LoggerContext;
  29 import ch.qos.logback.classic.spi.ILoggingEvent;
  30 import ch.qos.logback.core.Appender;
  31
  32 import com.google.common.collect.HashMultimap;
  33 import com.google.common.collect.Lists;
  34 import com.google.common.collect.Multimap;
  35
  36 public class ContextSetterImplTest {
  37
  38     @Mock
  39     private LogbackRuntimeRegistrator runtimeRegistratorMock;
  40     @Mock
  41     private DependencyResolver dependencyResolverMock;
  42
  43     @Before
  44     public void setUp() throws Exception {
  45         MockitoAnnotations.initMocks(this);
  46         LogbackRuntimeRegistration reg = mock(LogbackRuntimeRegistration.class);
  47         doReturn(reg).when(runtimeRegistratorMock).register(
  48                 any(LogbackRuntimeMXBean.class));
  49     }
  50
  51     @Test
  52     public void testUpdate() throws Exception {
  53         Multimap<String, String> loggersToAppenders = HashMultimap.create();
  54         loggersToAppenders.put("l1", "a1");
  55         loggersToAppenders.put("l1", "a2");
  56         createContextSetter(loggersToAppenders);
  57
  58         assertLoggerWithAppenders("l1", "a1", "a2");
  59     }
  60
  61     @Test
  62     public void testUpdateTwice() throws Exception {
  63         Multimap<String, String> loggersToAppenders = HashMultimap.create();
  64         loggersToAppenders.put("l1", "a1");
  65         loggersToAppenders.put("l1", "a2");
  66         createContextSetter(loggersToAppenders);
  67
  68         loggersToAppenders.clear();
  69         loggersToAppenders.put("l1", "a3");
  70         loggersToAppenders.put("l1", "a2");
  71         loggersToAppenders.put("l1", "a4");
  72         createContextSetter(loggersToAppenders);
  73
  74         assertLoggerWithAppenders("l1", "a2", "a3", "a4");
  75     }
  76
  77     @Test
  78     public void testKeepOtherLoggers() throws Exception {
  79         Multimap<String, String> loggersToAppenders = HashMultimap.create();
  80         loggersToAppenders.put("l1", "a1");
  81         loggersToAppenders.put("l1", "a2");
  82         loggersToAppenders.put("l2", "a22");
  83         createContextSetter(loggersToAppenders);
  84
  85         loggersToAppenders.clear();
  86         loggersToAppenders.put("l1", "a3");
  87         createContextSetter(loggersToAppenders);
  88
  89         assertLoggerWithAppenders("l1", "a3");
  90         assertLoggerWithAppenders("l2", "a22");
  91     }
  92
  93     private void createContextSetter(Multimap<String, String> loggersToAppenders) {
  94         ContextSetterImpl setter = new ContextSetterImpl(runtimeRegistratorMock);
  95
  96         List<LoggerTO> logger = Lists.newArrayList();
  97         List<ConsoleAppenderTO> consoleAppenders = Lists.newArrayList();
  98
  99         for (String loggerName : loggersToAppenders.keySet()) {
 100             LoggerTO l1 = createLogger(loggerName,
 101                     loggersToAppenders.get(loggerName));
 102             logger.add(l1);
 103             for (String appenderName : loggersToAppenders.get(loggerName)) {
 104                 consoleAppenders.add(createConsoleAppender(appenderName));
 105             }
 106
 107         }
 108
 109         LogbackModule logbackModule = createLogbackModule(logger,
 110                 consoleAppenders);
 111         setter.updateContext(logbackModule);
 112     }
 113
 114     private void assertLoggerWithAppenders(String name, String... appenders) {
 115         LoggerContext context = (LoggerContext) LoggerFactory
 116                 .getILoggerFactory();
 117         ch.qos.logback.classic.Logger logger = context.getLogger(name);
 118         Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
 119
 120         Multimap<String, Appender<?>> foundAppenders = HashMultimap.create();
 121         while (it.hasNext()) {
 122             final Appender<ILoggingEvent> app = it.next();
 123             foundAppenders.put(app.getName(), app);
 124         }
 125
 126         if (appenders.length == 0) {
 127             assertEquals(0, foundAppenders.values().size());
 128         }
 129
 130         for (String appender : appenders) {
 131             boolean isPresent = foundAppenders.get(appender).isEmpty();
 132             assertFalse(
 133                     "Appender " + appender + " for logger " + name
 134                             + " was not present, present appenders: "
 135                             + foundAppenders.keys(), isPresent);
 136         }
 137
 138     }
 139
 140     private LogbackModule createLogbackModule(List<LoggerTO> logger,
 141             List<ConsoleAppenderTO> consoleAppenders) {
 142         LogbackModule logbackModule = new LogbackModule(new ModuleIdentifier(
 143                 "fact", "first"), dependencyResolverMock);
 144         logbackModule.setLoggerTO(logger);
 145         logbackModule.setConsoleAppenderTO(consoleAppenders);
 146         logbackModule.setRollingFileAppenderTO(Lists
 147                 .<RollingFileAppenderTO> newArrayList());
 148         return logbackModule;
 149     }
 150
 151     private LoggerTO createLogger(String name, Collection<String> appenders) {
 152         LoggerTO l1 = new LoggerTO();
 153         l1.setAppenders(Lists.newArrayList(appenders));
 154         l1.setLoggerName(name);
 155         l1.setLevel("INFO");
 156         return l1;
 157     }
 158
 159     private ConsoleAppenderTO createConsoleAppender(String name) {
 160         ConsoleAppenderTO a = new ConsoleAppenderTO();
 161         a.setName(name);
 162         a.setEncoderPattern("%-4relative [%thread] %-5level %logger{35} - %msg%n");
 163         return a;
 164     }
 165 }