blob: cb7b4977ab9a1e19006b5339f423da0d8ca53c25 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.logging.log4j.core.config;
import java.util.List;
import java.util.Map;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.appender.ConsoleAppender;
import org.apache.logging.log4j.core.appender.FileAppender;
import org.apache.logging.log4j.core.config.composite.CompositeConfiguration;
import org.apache.logging.log4j.core.filter.RegexFilter;
import org.apache.logging.log4j.core.util.Throwables;
import org.apache.logging.log4j.junit.LoggerContextRule;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import static org.junit.Assert.*;
public class CompositeConfigurationTest {
/*
@Test
public void compositeConfigurationUsed() {
final LoggerContextRule lcr = new LoggerContextRule(
"classpath:log4j-comp-appender.xml,log4j-comp-appender.json");
Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
assertTrue(lcr.getConfiguration() instanceof CompositeConfiguration);
}
};
runTest(lcr, test);
}
@Test
public void compositeProperties() {
final LoggerContextRule lcr = new LoggerContextRule(
"classpath:log4j-comp-properties.xml,log4j-comp-properties.json");
Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
assertEquals("json", config.getStrSubstitutor().replace("${propertyShared}"));
assertEquals("xml", config.getStrSubstitutor().replace("${propertyXml}"));
assertEquals("json", config.getStrSubstitutor().replace("${propertyJson}"));
}
};
runTest(lcr, test);
}
@Test
public void compositeAppenders() {
final LoggerContextRule lcr = new LoggerContextRule(
"classpath:log4j-comp-appender.xml,log4j-comp-appender.json");
Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
Map<String, Appender> appender = config.getAppenders();
assertEquals(3, appender.size());
assertTrue(appender.get("STDOUT") instanceof ConsoleAppender);
assertTrue(appender.get("File") instanceof FileAppender);
assertTrue(appender.get("Override") instanceof RollingFileAppender);
}
};
runTest(lcr, test);
}
*/
@Test
public void compositeLogger() {
final LoggerContextRule lcr = new LoggerContextRule("classpath:log4j-comp-logger.xml,log4j-comp-logger.json");
final Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
Map<String, Appender> appendersMap = config.getLogger("cat1").getAppenders();
assertEquals("Expected 2 Appender references for cat1 but got " + appendersMap.size(), 2,
appendersMap.size());
assertTrue(appendersMap.get("STDOUT") instanceof ConsoleAppender);
Filter loggerFilter = config.getLogger("cat1").getFilter();
assertTrue(loggerFilter instanceof RegexFilter);
assertEquals(loggerFilter.getOnMatch(), Filter.Result.DENY);
appendersMap = config.getLogger("cat2").getAppenders();
assertEquals("Expected 1 Appender reference for cat2 but got " + appendersMap.size(), 1,
appendersMap.size());
assertTrue(appendersMap.get("File") instanceof FileAppender);
appendersMap = config.getLogger("cat3").getAppenders();
assertEquals("Expected 1 Appender reference for cat3 but got " + appendersMap.size(), 1,
appendersMap.size());
assertTrue(appendersMap.get("File") instanceof FileAppender);
appendersMap = config.getRootLogger().getAppenders();
assertEquals("Expected 2 Appender references for the root logger but got " + appendersMap.size(), 2,
appendersMap.size());
assertTrue(appendersMap.get("File") instanceof FileAppender);
assertTrue(appendersMap.get("STDOUT") instanceof ConsoleAppender);
}
};
runTest(lcr, test);
}
@Test
public void testAttributeCheckWhenMergingConfigurations() {
final LoggerContextRule lcr = new LoggerContextRule("classpath:log4j-comp-root-loggers.xml,log4j-comp-logger.json");
final Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
try {
final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
Assert.assertNotNull(config);
} catch (final NullPointerException e) {
fail("Should not throw NullPointerException when there are different nodes.");
}
}
};
runTest(lcr, test);
}
@Test
public void testAttributeMergeForLoggers() {
final LoggerContextRule lcr = new LoggerContextRule("classpath:log4j-comp-logger-root.xml,log4j-comp-logger-attr-override.json");
final Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
//Test for Root log level override
assertEquals("Expected Root logger log level to be WARN", Level.WARN, config.getRootLogger().getLevel());
//Test for cat2 level override
final LoggerConfig cat2 = config.getLogger("cat2");
assertEquals("Expected cat2 log level to be INFO", Level.INFO, cat2.getLevel());
//Test for cat2 additivity override
assertTrue("Expected cat2 additivity to be true", cat2.isAdditive());
//Regression
//Check level on cat3 (not present in root config)
assertEquals("Expected cat3 log level to be ERROR", Level.ERROR, config.getLogger("cat3").getLevel());
//Check level on cat1 (not present in overriden config)
assertEquals("Expected cat1 log level to be DEBUG", Level.DEBUG, config.getLogger("cat1").getLevel());
}
};
runTest(lcr, test);
}
@Test
public void testAppenderRefFilterMerge() {
final LoggerContextRule lcr = new LoggerContextRule(
"classpath:log4j-comp-logger-ref.xml,log4j-comp-logger-ref.json");
final Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
final List<AppenderRef> appenderRefList = config.getLogger("cat1").getAppenderRefs();
final AppenderRef appenderRef = getAppenderRef(appenderRefList, "STDOUT");
assertTrue("Expected cat1 STDOUT appenderRef to have a regex filter",
appenderRef.getFilter() != null && appenderRef.getFilter() instanceof RegexFilter);
}
};
runTest(lcr, test);
}
private AppenderRef getAppenderRef(final List<AppenderRef> appenderRefList, final String refName) {
for (final AppenderRef ref : appenderRefList) {
if (ref.getRef().equalsIgnoreCase(refName)) {
return ref;
}
}
return null;
}
/*
@Test
public void overrideFilter() {
final LoggerContextRule lcr = new LoggerContextRule("classpath:log4j-comp-filter.xml,log4j-comp-filter.json");
Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration();
assertTrue(config.getFilter() instanceof CompositeFilter);
CompositeFilter filter = (CompositeFilter) config.getFilter();
assertTrue(filter.getFiltersArray().length == 2);
}
};
runTest(lcr, test);
}
@Test
public void testReconfiguration() throws Exception {
final LoggerContextRule rule =
new LoggerContextRule("classpath:log4j-comp-reconfig.xml,log4j-comp-reconfig.properties");
Statement test = new Statement() {
@Override
public void evaluate() throws Throwable {
final Configuration oldConfig = rule.getConfiguration();
final org.apache.logging.log4j.Logger logger = rule.getLogger("LoggerTest");
final int MONITOR_INTERVAL_SECONDS = 5;
final File file = new File("target/test-classes/log4j-comp-reconfig.properties");
final long orig = file.lastModified();
final long newTime = orig + 10000;
assertTrue("setLastModified should have succeeded.", file.setLastModified(newTime));
TimeUnit.SECONDS.sleep(MONITOR_INTERVAL_SECONDS + 1);
for (int i = 0; i < 17; ++i) {
logger.debug("Reconfigure");
}
int loopCount = 0;
Configuration newConfig;
do {
Thread.sleep(100);
newConfig = rule.getConfiguration();
++loopCount;
} while (newConfig == oldConfig && loopCount <= 5);
assertNotSame("Reconfiguration failed", newConfig, oldConfig);
}
};
runTest(rule, test);
} */
private void runTest(final LoggerContextRule rule, final Statement statement) {
try {
rule.apply(statement, Description
.createTestDescription(getClass(), Thread.currentThread().getStackTrace()[1].getMethodName()))
.evaluate();
} catch (final Throwable e) {
Throwables.rethrow(e);
}
}
}