org.apache.logging.log4j.junit.LoggerContextRule Java Examples

@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);
}
 

@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 overridden config)
            assertEquals("Expected cat1 log level to be DEBUG", Level.DEBUG, config.getLogger("cat1").getLevel());
        }
    };
    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);
}
 

protected JdbcAppenderMapMessageDataSourceTest(final JdbcRule jdbcRule) {
    // @formatter:off
    this.rules = RuleChain.emptyRuleChain()
            .around(new JndiRule("java:/comp/env/jdbc/TestDataSourceAppender", createMockDataSource()))
            .around(jdbcRule)
            .around(new LoggerContextRule("org/apache/logging/log4j/jdbc/appender/log4j2-data-source-map-message.xml"));
    // @formatter:on
    this.jdbcRule = jdbcRule;
}
 

public RandomAccessFileAppenderTest(final String testName, final boolean locationEnabled, final String type) {
    this.init = new LoggerContextRule(testName + type);
    this.logFile = new File("target", testName + ".log");
    this.files = new CleanFiles(this.logFile);
    this.locationEnabled = locationEnabled;
    this.chain = RuleChain.outerRule(files).around(init);
}
 

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);
    }
}
 

@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);

            assertEquals("Expected COMPOSITE_SOURCE for composite configuration but got " + config.getConfigurationSource(),
                    config.getConfigurationSource(), ConfigurationSource.COMPOSITE_SOURCE);
        }
    };
    runTest(lcr, test);
}
 

protected AbstractJdbcAppenderDataSourceTest(final JdbcRule jdbcRule) {
    this.rules = RuleChain.emptyRuleChain()
        .around(new JndiRule("java:/comp/env/jdbc/TestDataSourceAppender", createMockDataSource()))
        .around(jdbcRule)
        .around(new LoggerContextRule(
            "org/apache/logging/log4j/jdbc/appender/log4j2-data-source.xml"));
    this.jdbcRule = jdbcRule;
}
 

protected AbstractJdbcAppenderFactoryMethodTest(final JdbcRule jdbcRule, final String databaseType) {
    this.rules = RuleChain.emptyRuleChain().around(jdbcRule).around(new LoggerContextRule(
        "org/apache/logging/log4j/jdbc/appender/log4j2-" + databaseType + "-factory-method.xml"));
    this.jdbcRule = jdbcRule;
}
 

protected JdbcAppenderColumnMappingPatternTest(final JdbcRule jdbcRule) {
	this.rules = RuleChainFactory.create(jdbcRule, new LoggerContextRule(
			"org/apache/logging/log4j/jdbc/appender/log4j2-dm-column-mapping-pattern.xml"));
	this.jdbcRule = jdbcRule;
}
 

protected JdbcAppenderColumnMappingLiteralTest(final JdbcRule jdbcRule) {
    this.rules = RuleChainFactory.create(jdbcRule,
            new LoggerContextRule("org/apache/logging/log4j/jdbc/appender/log4j2-dm-column-mapping-literal.xml"));
    this.jdbcRule = jdbcRule;
}
 

public RandomRollingAppenderOnStartupTest(final String configFile) {
    this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(configFile);
}
 

public DataSourceConnectionSourceTest(final String jndiURL) {
    this.rules = RuleChain.outerRule(new JndiRule(jndiURL, dataSource))
        .around(new LoggerContextRule(CONFIG));
    this.jndiURL = jndiURL;
}
 

@Override
public LoggerContextRule getContext() {
    return context;
}
 

@Override
public LoggerContextRule getContext() {
    return context;
}
 

@Override
public LoggerContextRule getContext() {
    return context;
}
 

@Override
public LoggerContextRule getContext() {
    return context;
}
 

public AsyncAppenderTest(final String configFileName) {
    context = new LoggerContextRule(configFileName);
}
 

public ScriptAppenderSelectorTest(final String configLocation) {
    this.loggerContextRule = new LoggerContextRule(configLocation);
}
 

public RollingAppenderNoUnconditionalDeleteTest(final String configFile, final String dir) {
    this.directory = new File(dir);
    this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(configFile);
    deleteDir();
    deleteDirParent();
}
 

public RollingAppenderCountTest() {
    this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
}
 

public XmlCompleteFileAppenderTest(final Class<ContextSelector> contextSelector) {
    this.loggerContextRule = new LoggerContextRule("XmlCompleteFileAppenderTest.xml", contextSelector);
    this.cleanFiles = new CleanFiles(logFile);
    this.ruleChain = RuleChain.outerRule(cleanFiles).around(loggerContextRule);
}
 

public RollingAppenderSizeTest(final String configFile, final String fileExtension, final boolean createOnDemand) {
    this.fileExtension = fileExtension;
    this.createOnDemand = createOnDemand;
    this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(configFile);
    this.chain = loggerContextRule.withCleanFoldersRule(DIR);
}
 

public RollingAppenderOnStartupTest() {
    this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
}
 

public RoutesScriptAppenderTest(final String configLocation, final boolean expectBindingEntries) {
    this.loggerContextRule = new LoggerContextRule(configLocation);
    this.expectBindingEntries = expectBindingEntries;
}
 

public DefaultRouteScriptAppenderTest(final String configLocation, final boolean expectBindingEntries) {
    this.loggerContextRule = new LoggerContextRule(configLocation);
    this.expectBindingEntries = expectBindingEntries;
}
 

public XIncludeTest(final String configFileName, final String logFileName) {
    this.logFileName = logFileName;
    this.init = new LoggerContextRule(configFileName);
    this.rules = RuleChain.outerRule(new CleanFiles(logFileName)).around(this.init);
}
 

public ConfigurationTest(final String configFileName, final String logFileName) {
    this.logFileName = logFileName;
    this.init = new LoggerContextRule(configFileName);
    rules = RuleChain.outerRule(new CleanFiles(logFileName)).around(this.init);
}
 

public CsvParameterLayoutTest(final LoggerContextRule contextRule) {
    this.init = contextRule;
}
 

@Parameterized.Parameters(name = "{0}")
public static Collection<Object[]> data() {
    return Arrays.asList(new Object[][] { { new LoggerContextRule("csvParamsSync.xml"), },
            { new LoggerContextRule("csvParamsMixedAsync.xml"), }, });
}