Spring/spring-boot-data-geode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor the spring-geode-starter-logging module.

Browse Source
This commit is contained in:
John Blum
2022-10-05 12:23:18 -07:00
parent 77eb15e591
commit 78b2a02c36
7 changed files with 374 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
spring-geode-starter-logging/spring-geode-starter-logging.gradle
View File

@@ -9,6 +9,7 @@ dependencies {
compile "org.springframework.boot:spring-boot-starter-logging"
implementation "org.codehaus.janino:janino"
implementation "org.springframework:spring-core"
testImplementation project(":spring-geode-starter-test")

73
spring-geode-starter-logging/src/main/java/org/springframework/geode/logging/slf4j/logback/support/LogbackSupport.java
View File

@@ -20,10 +20,11 @@ import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import org.springframework.util.ClassUtils;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.impl.StaticLoggerBinder;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.spi.ILoggingEvent;
@@ -43,6 +44,13 @@ import ch.qos.logback.core.Appender;
@SuppressWarnings("unused")
public abstract class LogbackSupport {
private static final Class<ch.qos.logback.classic.Logger> LOGBACK_LOGGER_TYPE = ch.qos.logback.classic.Logger.class;
private static final String STATIC_LOGGER_BINDER_CLASSNAME = "org.slf4j.impl.StaticLoggerBinder";
private static final boolean STATIC_LOGGER_BINDER_CLASS_PRESENT =
ClassUtils.isPresent(STATIC_LOGGER_BINDER_CLASSNAME, ClassUtils.getDefaultClassLoader());
protected static final Function<Logger, Optional<ch.qos.logback.classic.Logger>> slf4jLoggerToLogbackLoggerConverter =
logger -> Optional.ofNullable(logger)
.filter(ch.qos.logback.classic.Logger.class::isInstance)
@@ -69,28 +77,61 @@ public abstract class LogbackSupport {
requireLoggerContext().putObject(SPRING_BOOT_LOGGING_SYSTEM_CLASS_NAME, new Object());
}
/**
* Properly stops Logback classic.
*
* @see <a href="https://logback.qos.ch/manual/configuration.html#stopContext">Stopping logback-classic</a>
*/
public static void stopLogback() {
resolveLoggerContext()
.ifPresent(LoggerContext::stop);
}
/**
* Resets the state of the SLF4J Logback logging provider and system.
*/
public static void resetLogback() {
try {
Method loggerFactoryReset = LoggerFactory.class.getDeclaredMethod("reset");
loggerFactoryReset.setAccessible(true);
loggerFactoryReset.invoke(null);
Method staticLoggerBinderReset = StaticLoggerBinder.class.getDeclaredMethod("reset");
staticLoggerBinderReset.setAccessible(true);
staticLoggerBinderReset.invoke(null);
resetLoggerContext();
resetLoggerFactory();
resetStaticLoggerBinder();
}
catch (Throwable cause) {
throw new IllegalStateException("Failed to reset Logback", cause);
}
}
private static void resetLoggerContext() {
resolveLoggerContext().ifPresent(loggerContext -> {
loggerContext.reset();
loggerContext.getStatusManager().clear();
});
}
private static void resetLoggerFactory() throws Exception {
Method loggerFactoryReset = LoggerFactory.class.getDeclaredMethod("reset");
loggerFactoryReset.setAccessible(true);
loggerFactoryReset.invoke(null);
}
private static void resetStaticLoggerBinder() throws Exception {
if (STATIC_LOGGER_BINDER_CLASS_PRESENT) {
Class<?> staticLoggerBinderClass =
ClassUtils.forName(STATIC_LOGGER_BINDER_CLASSNAME, ClassUtils.getDefaultClassLoader());
Method staticLoggerBinderReset = staticLoggerBinderClass.getDeclaredMethod("reset");
staticLoggerBinderReset.setAccessible(true);
staticLoggerBinderReset.invoke(null);
}
}
/**
* Resolves the SLF4J, Logback {@link LoggerContext}.
*
@@ -146,10 +187,10 @@ public abstract class LogbackSupport {
public static ch.qos.logback.classic.Logger requireLogbackRootLogger() {
return resolveRootLogger()
.filter(ch.qos.logback.classic.Logger.class::isInstance)
.map(ch.qos.logback.classic.Logger.class::cast)
.filter(LOGBACK_LOGGER_TYPE::isInstance)
.map(LOGBACK_LOGGER_TYPE::cast)
.orElseThrow(() -> new IllegalStateException(String.format(ILLEGAL_LOGGER_TYPE_EXCEPTION_MESSAGE,
ROOT_LOGGER_NAME, nullSafeTypeName(resolveRootLogger()))));
ROOT_LOGGER_NAME, nullSafeTypeName(resolveRootLogger().orElse(null)))));
}
/**
@@ -166,7 +207,7 @@ public abstract class LogbackSupport {
* @see org.slf4j.Logger
*/
public static <E, T extends Appender<E>> Optional<T> resolveAppender(ch.qos.logback.classic.Logger logger,
String appenderName, Class<T> appenderType) {
String appenderName, Class<T> appenderType) {
appenderType = nullSafeAppenderType(appenderType);
@@ -192,7 +233,7 @@ public abstract class LogbackSupport {
* @see ch.qos.logback.core.Appender
*/
public static <E, T extends Appender<E>> T requireAppender(ch.qos.logback.classic.Logger logger,
String appenderName, Class<T> appenderType) {
String appenderName, Class<T> appenderType) {
return resolveAppender(logger, appenderName, appenderType)
.orElseThrow(() -> new IllegalStateException(String.format(UNRESOLVABLE_APPENDER_EXCEPTION_MESSAGE,

297
spring-geode-starter-logging/src/test/java/org/springframework/geode/logging/slf4j/logback/AbstractLoggingIntegrationTests.java
View File

@@ -18,15 +18,26 @@ package org.springframework.geode.logging.slf4j.logback;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.springframework.data.gemfire.tests.integration.IntegrationTestsSupport;
import org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender;
import org.springframework.data.gemfire.util.ArrayUtils;
import org.springframework.data.gemfire.util.CollectionUtils;
import org.springframework.geode.logging.slf4j.logback.support.LogbackSupport;
import org.springframework.util.StringUtils;
import org.slf4j.ILoggerFactory;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -34,118 +45,286 @@ import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.util.ContextInitializer;
import ch.qos.logback.core.Appender;
import ch.qos.logback.core.joran.spi.JoranException;
import ch.qos.logback.core.status.Status;
import ch.qos.logback.core.status.StatusListener;
/**
* Abstract base class for testing the spring-geode-starter-logging and spring-gemfire-starter modules.
* Abstract base class for testing the spring-geode-starter-logging and spring-geode-starter modules.
*
* @author John Blum
* @see org.slf4j.Logger
* @see org.slf4j.LoggerFactory
* @see org.springframework.data.gemfire.tests.integration.IntegrationTestsSupport
* @see org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender
* @see ch.qos.logback.classic.Level
* @see ch.qos.logback.classic.Logger
* @see ch.qos.logback.classic.LoggerContext
* @see ch.qos.logback.classic.util.ContextInitializer
* @see ch.qos.logback.core.Appender
* @since 1.3.0
*/
public abstract class AbstractLoggingIntegrationTests extends IntegrationTestsSupport {
@SuppressWarnings("unused")
public abstract class AbstractLoggingIntegrationTests {
private static final boolean STATUS_DEBUG_ENABLED = false;
private static final Class<ch.qos.logback.classic.Logger> LOGBACK_LOGGER_TYPE =
ch.qos.logback.classic.Logger.class;
private static final Function<? super ch.qos.logback.classic.Logger, Level> LOGBACK_LOGGER_LEVEL =
ch.qos.logback.classic.Logger::getLevel;
protected static final String APACHE_GEODE_LOGGER_NAME = "org.apache.geode";
protected static final String CONSOLE_APPENDER_NAME = "CONSOLE";
protected static final String DELEGATE_APPENDER_NAME = "delegate";
protected static final String SPRING_BOOT_DATA_GEMFIRE_LOG_LEVEL_PROPERTY = "spring.boot.data.gemfire.log.level";
private Logger apacheGeodeLogger = LoggerFactory.getLogger(APACHE_GEODE_LOGGER_NAME);
private static TestAppender testAppender;
private TestAppender testAppender;
private static ch.qos.logback.classic.Logger assertLogbackLogger(org.slf4j.Logger slf4jLogger,
String loggerName, Level logLevel) {
protected TestAppender getTestAppender() {
assertThat(slf4jLogger).isInstanceOf(LOGBACK_LOGGER_TYPE);
assertThat(slf4jLogger.getName()).isEqualTo(loggerName);
assertThat(slf4jLogger)
.asInstanceOf(InstanceOfAssertFactories.type(LOGBACK_LOGGER_TYPE))
.extracting(LOGBACK_LOGGER_LEVEL)
.isEqualTo(logLevel);
assertThat(this.testAppender).describedAs("TestAppender could not be resolved").isNotNull();
return this.testAppender;
return LOGBACK_LOGGER_TYPE.cast(slf4jLogger);
}
protected Level getTestLogLevel() {
return Level.INFO;
private static LoggerContext assertLogbackLoggerConfiguration(LoggerContext loggerContext,
String... loggerNames) {
List<String> configuredLoggerNames = CollectionUtils.nullSafeList(loggerContext.getLoggerList()).stream()
.filter(Objects::nonNull)
.map(Logger::getName)
.filter(StringUtils::hasText)
.collect(Collectors.toList());
assertThat(configuredLoggerNames).contains(loggerNames);
return loggerContext;
}
public void assertApacheGeodeLoggerLogLevel(Level logLevel) {
private static ch.qos.logback.classic.Logger assertLogbackLoggerAppenderConfiguration(
ch.qos.logback.classic.Logger logbackLogger, String... appenderNames) {
Optional.ofNullable(this.apacheGeodeLogger)
.filter(ch.qos.logback.classic.Logger.class::isInstance)
.map(ch.qos.logback.classic.Logger.class::cast)
.map(logger -> {
assertThat(logger.getLevel()).isEqualTo(logLevel);
return logger;
})
.orElseThrow(() -> newIllegalStateException("'org.apache.geode' Logger not found"));
Spliterator<Appender<?>> configuredTestLoggerAppenders =
Spliterators.spliteratorUnknownSize(logbackLogger.iteratorForAppenders(), Spliterator.NONNULL);
List<String> configuredTestLoggerAppenderNames =
StreamSupport.stream(configuredTestLoggerAppenders, false)
.filter(Objects::nonNull)
.map(Appender::getName)
.filter(StringUtils::hasText)
.collect(Collectors.toList());
assertThat(configuredTestLoggerAppenderNames).contains(appenderNames);
return logbackLogger;
}
@Before
public void setup() {
private static void log(String message, Object... args) {
System.err.printf(message, args);
System.err.flush();
}
configureLogging();
private static ch.qos.logback.classic.Logger logConfiguredAppenders(ch.qos.logback.classic.Logger logger) {
log("Configured Appenders: ");
Spliterator<Appender<?>> appenders =
Spliterators.spliteratorUnknownSize(logger.iteratorForAppenders(), Spliterator.NONNULL);
log("%s%n", Arrays.toString(StreamSupport.stream(appenders, false)
.filter(Objects::nonNull)
.map(Appender::getName)
.filter(StringUtils::hasText)
.toArray(String[]::new)));
return logger;
}
private static LoggerContext logConfiguredLoggers(LoggerContext loggerContext) {
log("Configured Loggers: ");
log("%s%n", Arrays.toString(loggerContext.getLoggerList().stream()
.filter(Objects::nonNull)
.map(Logger::getName)
.filter(StringUtils::hasText)
.toArray(String[]::new)));
return loggerContext;
}
protected static void setupLogback(Level testLogLevel) {
configureLogging(testLogLevel);
configureRootLoggerDelegatingAppender();
logMessages();
}
private void configureLogging() {
System.setProperty(SPRING_BOOT_DATA_GEMFIRE_LOG_LEVEL_PROPERTY, getTestLogLevel().toString());
ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
assertThat(loggerFactory).isInstanceOf(LoggerContext.class);
LoggerContext loggerContext = (LoggerContext) loggerFactory;
@SuppressWarnings("all")
private static void configureLogging(Level testLogLevel) {
try {
new ContextInitializer(loggerContext).autoConfig();
System.setProperty(SPRING_BOOT_DATA_GEMFIRE_LOG_LEVEL_PROPERTY, testLogLevel.toString());
LogbackSupport.resetLogback();
LoggerContext loggerContext = LogbackSupport.requireLoggerContext();
initializeLogback(loggerContext)
.getStatusManager().add(LoggingStatusListener.create().debug(STATUS_DEBUG_ENABLED));
logConfiguredLoggers(loggerContext);
assertLogbackLoggerConfiguration(loggerContext,
Logger.ROOT_LOGGER_NAME, APACHE_GEODE_LOGGER_NAME, "com.gemstone.gemfire", "org.jgroups");
ch.qos.logback.classic.Logger logbackOrgApacheGeodeLogger = assertLogbackLogger(loggerContext
.getLogger(APACHE_GEODE_LOGGER_NAME), APACHE_GEODE_LOGGER_NAME, testLogLevel);
logConfiguredAppenders(logbackOrgApacheGeodeLogger);
assertLogbackLoggerAppenderConfiguration(logbackOrgApacheGeodeLogger,
CONSOLE_APPENDER_NAME, DELEGATE_APPENDER_NAME);
}
catch (Exception cause) {
throw newIllegalStateException("Failed to configure and initialize SLF4J/Logback logging context", cause);
throw newIllegalStateException("Failed to configure and initialize SLF4J/Logback", cause);
}
}
private static LoggerContext initializeLogback(LoggerContext loggerContext) throws JoranException {
new ContextInitializer(loggerContext).autoConfig();
return loggerContext;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private void configureRootLoggerDelegatingAppender() {
private static void configureRootLoggerDelegatingAppender() {
Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
ch.qos.logback.classic.Logger logbackRootLogger =
assertLogbackLogger(LogbackSupport.requireLogbackRootLogger(), Logger.ROOT_LOGGER_NAME, Level.ERROR);
assertThat(rootLogger).isInstanceOf(ch.qos.logback.classic.Logger.class);
assertThat(logbackRootLogger.getAppender(CONSOLE_APPENDER_NAME)).isNull();
ch.qos.logback.classic.Logger logbackRootLogger = (ch.qos.logback.classic.Logger) rootLogger;
Appender<?> delegateAppender = logbackRootLogger.getAppender("delegate");
Appender<?> delegateAppender = logbackRootLogger.getAppender(DELEGATE_APPENDER_NAME);
assertThat(delegateAppender).isNotNull();
assertThat(delegateAppender.getName()).isEqualTo("delegate");
assertThat(delegateAppender.getName()).isEqualTo(DELEGATE_APPENDER_NAME);
this.testAppender = new TestAppender();
this.testAppender.start();
TestAppender testAppender = initializeTestAppender();
((DelegatingAppender) delegateAppender).setAppender(this.testAppender);
((DelegatingAppender) delegateAppender).setAppender(testAppender);
assertThat(((DelegatingAppender) delegateAppender).getAppender()).isSameAs(this.testAppender);
assertThat(delegateAppender)
.asInstanceOf(InstanceOfAssertFactories.type(DelegatingAppender.class))
.extracting(DelegatingAppender::getAppender)
.isSameAs(testAppender);
}
public void logMessages() {
private static TestAppender initializeTestAppender() {
testAppender = new TestAppender();
testAppender.start();
return testAppender;
}
@AfterClass
public static void cleanupTestContext() {
System.clearProperty(SPRING_BOOT_DATA_GEMFIRE_LOG_LEVEL_PROPERTY);
Optional.ofNullable(testAppender).ifPresent(TestAppender::clear);
}
private Logger apacheGeodeLogger;
@Before
public void initializeApacheGeodeLoggerReference() {
this.apacheGeodeLogger = LoggerFactory.getLogger(APACHE_GEODE_LOGGER_NAME);
}
protected TestAppender getTestAppender() {
assertThat(testAppender)
.describedAs("TestAppender could not be resolved")
.isNotNull();
return testAppender;
}
protected void assertApacheGeodeLoggerLogLevel(Level logLevel) {
Optional.ofNullable(this.apacheGeodeLogger)
.filter(LOGBACK_LOGGER_TYPE::isInstance)
.map(LOGBACK_LOGGER_TYPE::cast)
.map(logger -> {
assertThat(logger.getName()).isEqualTo(APACHE_GEODE_LOGGER_NAME);
assertThat(logger.getLevel()).isEqualTo(logLevel);
return logger;
})
.orElseThrow(() -> newIllegalStateException("'%s' Logger not found", APACHE_GEODE_LOGGER_NAME));
}
protected void assertLogMessages(String... logMessages) {
logMessages();
Arrays.stream(ArrayUtils.nullSafeArray(logMessages, String.class)).forEach(logMessage ->
assertThat(getTestAppender().lastLogMessage()).isEqualTo(logMessage));
assertThat(getTestAppender().lastLogMessage()).isNull();
}
protected void logMessages() {
assertThat(this.apacheGeodeLogger).isNotNull();
this.apacheGeodeLogger.trace("TRACE TEST");
this.apacheGeodeLogger.debug("DEBUG TEST");
this.apacheGeodeLogger.info("INFO TEST");
this.apacheGeodeLogger.warn("WARN TEST");
this.apacheGeodeLogger.error("ERROR TEST");
}
@After
public void tearDown() {
protected static class LoggingStatusListener implements StatusListener {
Optional.ofNullable(this.testAppender).ifPresent(it -> {
it.clear();
it.stop();
});
protected static LoggingStatusListener create() {
return new LoggingStatusListener();
}
System.clearProperty(SPRING_BOOT_DATA_GEMFIRE_LOG_LEVEL_PROPERTY);
private volatile boolean debug = false;
protected boolean isDebugging() {
return this.debug;
}
@Override
public void addStatusEvent(Status status) {
if (isDebugging()) {
logStatus(status);
}
}
protected LoggingStatusListener debug(boolean debug) {
this.debug = debug;
return this;
}
private void logStatus(Status status) {
log("[STATUS] %s: %s%n", status.getOrigin(), status.getMessage());
if (status.hasChildren()) {
for (Status child : CollectionUtils.iterable(status.iterator())) {
logStatus(child);
}
}
}
}
}

23
spring-geode-starter-logging/src/test/java/org/springframework/geode/logging/slf4j/logback/DebugLoggingIntegrationTests.java
View File

@@ -15,12 +15,9 @@
*/
package org.springframework.geode.logging.slf4j.logback;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender;
import ch.qos.logback.classic.Level;
/**
@@ -40,24 +37,20 @@ import ch.qos.logback.classic.Level;
*/
public class DebugLoggingIntegrationTests extends AbstractLoggingIntegrationTests {
@Override
protected Level getTestLogLevel() {
return Level.DEBUG;
private static final Level TEST_LOG_LEVEL = Level.DEBUG;
@BeforeClass
public static void setupLogback() {
setupLogback(TEST_LOG_LEVEL);
}
@Test
public void logLevelIsSetToDebug() {
assertApacheGeodeLoggerLogLevel(Level.DEBUG);
assertApacheGeodeLoggerLogLevel(TEST_LOG_LEVEL);
}
@Test
public void logMessagesAtDebug() {
TestAppender testAppender = getTestAppender();
assertThat(testAppender.lastLogMessage()).isEqualTo("ERROR TEST");
assertThat(testAppender.lastLogMessage()).isEqualTo("INFO TEST");
assertThat(testAppender.lastLogMessage()).isEqualTo("DEBUG TEST");
assertThat(testAppender.lastLogMessage()).isNull();
assertLogMessages("ERROR TEST", "WARN TEST", "INFO TEST", "DEBUG TEST");
}
}

52
spring-geode-starter-logging/src/test/java/org/springframework/geode/logging/slf4j/logback/ErrorLoggingIntegrationTests.java Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2017-present the original author or authors.
*
* Licensed 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
*
* https://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.springframework.geode.logging.slf4j.logback;
import org.junit.BeforeClass;
import org.junit.Test;
import ch.qos.logback.classic.Level;
/**
* Integration Tests testing the {@literal org.apache.geode} {@link org.slf4j.Logger}
* with the log level {@link Level#ERROR}.
*
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender
* @see org.springframework.geode.logging.slf4j.logback.ErrorLoggingIntegrationTests
* @see ch.qos.logback.classic.Level#ERROR
* @since 1.7.5
*/
public class ErrorLoggingIntegrationTests extends AbstractLoggingIntegrationTests {
private static final Level TEST_LOG_LEVEL = Level.ERROR;
@BeforeClass
public static void setupLogback() {
setupLogback(TEST_LOG_LEVEL);
}
@Test
public void logLevelIsSetToDebug() {
assertApacheGeodeLoggerLogLevel(TEST_LOG_LEVEL);
}
@Test
public void logMessagesAtDebug() {
assertLogMessages("ERROR TEST");
}
}

21
spring-geode-starter-logging/src/test/java/org/springframework/geode/logging/slf4j/logback/InfoLoggingIntegrationTests.java
View File

@@ -15,12 +15,9 @@
*/
package org.springframework.geode.logging.slf4j.logback;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender;
import ch.qos.logback.classic.Level;
/**
@@ -36,18 +33,20 @@ import ch.qos.logback.classic.Level;
*/
public class InfoLoggingIntegrationTests extends AbstractLoggingIntegrationTests {
private static final Level TEST_LOG_LEVEL = Level.INFO;
@BeforeClass
public static void setupLogback() {
setupLogback(TEST_LOG_LEVEL);
}
@Test
public void logLevelIsSetToInfo() {
assertApacheGeodeLoggerLogLevel(Level.INFO);
assertApacheGeodeLoggerLogLevel(TEST_LOG_LEVEL);
}
@Test
public void logsMessagesAtInfo() {
TestAppender testAppender = getTestAppender();
assertThat(testAppender.lastLogMessage()).isEqualTo("ERROR TEST");
assertThat(testAppender.lastLogMessage()).isEqualTo("INFO TEST");
assertThat(testAppender.lastLogMessage()).isNull();
assertLogMessages("ERROR TEST", "WARN TEST", "INFO TEST");
}
}

20
spring-geode-starter-logging/src/test/java/org/springframework/geode/logging/slf4j/logback/NoLoggingIntegrationTests.java
View File

@@ -15,12 +15,9 @@
*/
package org.springframework.geode.logging.slf4j.logback;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.data.gemfire.tests.logging.slf4j.logback.TestAppender;
import ch.qos.logback.classic.Level;
/**
@@ -40,21 +37,20 @@ import ch.qos.logback.classic.Level;
*/
public class NoLoggingIntegrationTests extends AbstractLoggingIntegrationTests {
@Override
protected Level getTestLogLevel() {
return Level.OFF;
private static final Level TEST_LOG_LEVEL = Level.OFF;
@BeforeClass
public static void setupLogback() {
setupLogback(TEST_LOG_LEVEL);
}
@Test
public void logLevelIsSetToOff() {
assertApacheGeodeLoggerLogLevel(Level.OFF);
assertApacheGeodeLoggerLogLevel(TEST_LOG_LEVEL);
}
@Test
public void logsNoMessages() {
TestAppender testAppender = getTestAppender();
assertThat(testAppender.lastLogMessage()).isNull();
assertLogMessages();
}
}