From 68ff7064ecde0867ed97053ecc565eb85beb417c Mon Sep 17 00:00:00 2001 From: Ceki Gulcu Date: Mon, 8 Jan 2024 18:50:54 +0100 Subject: [PATCH] acceptance test, disabled for the moment Signed-off-by: Ceki Gulcu --- .../java/org/slf4j/simple/AcceptanceTest.java | 50 ++++ .../org/slf4j/simple/LoggerTestSuite.java | 274 ++++++++++++++++++ 2 files changed, 324 insertions(+) create mode 100644 slf4j-simple/src/test/java/org/slf4j/simple/AcceptanceTest.java create mode 100644 slf4j-simple/src/test/java/org/slf4j/simple/LoggerTestSuite.java diff --git a/slf4j-simple/src/test/java/org/slf4j/simple/AcceptanceTest.java b/slf4j-simple/src/test/java/org/slf4j/simple/AcceptanceTest.java new file mode 100644 index 000000000..769850735 --- /dev/null +++ b/slf4j-simple/src/test/java/org/slf4j/simple/AcceptanceTest.java @@ -0,0 +1,50 @@ +package org.slf4j.simple; + +import org.junit.Ignore; +import org.slf4j.Logger; +import org.slf4j.event.Level; + +import java.io.PrintStream; + +@Ignore +public class AcceptanceTest extends LoggerTestSuite { + + @Override + public Logger createLogger(ListAppendingOutputStream outputStream, Level level) { + SimpleLogger.CONFIG_PARAMS.outputChoice = new OutputChoice(new PrintStream(outputStream)); + + SimpleLogger logger = new SimpleLogger("TestSuiteLogger"); + logger.currentLogLevel = SimpleLoggerConfiguration.stringToLevel(level.toString()); + return logger; + } + + @Override + public String extractMessage(String message) { + return message + .split("\n")[0] + .split("- ")[1]; + } + + @Override + public String extractExceptionMessage(String message) { + String[] logLines = message.split("\n"); + + if (logLines.length < 2) { + return null; + } + String exceptionLine = logLines[1]; + return exceptionLine.split(": ")[1]; + } + + @Override + public String extractExceptionType(String message) { + String[] logLines = message.split("\n"); + + if (logLines.length < 2) { + return null; + } + String exceptionLine = logLines[1]; + return exceptionLine.split(": ")[0]; + } + +} \ No newline at end of file diff --git a/slf4j-simple/src/test/java/org/slf4j/simple/LoggerTestSuite.java b/slf4j-simple/src/test/java/org/slf4j/simple/LoggerTestSuite.java new file mode 100644 index 000000000..5784c1bd3 --- /dev/null +++ b/slf4j-simple/src/test/java/org/slf4j/simple/LoggerTestSuite.java @@ -0,0 +1,274 @@ +package org.slf4j.simple; + + +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.event.Level; + +import java.io.IOException; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + + +public abstract class LoggerTestSuite { + + public static class ListAppendingOutputStream extends OutputStream { + private final StringBuilder word = new StringBuilder(); + private int index = 0; + private final List list; + + private ListAppendingOutputStream(List list) {this.list = list;} + + + @Override + public void write(int b) throws IOException { + word.append((char) b); + } + + @Override + public void flush() { + list.add(word.toString()); + word.delete(0, word.length()); + index++; + } + } + + private ListAppendingOutputStream prepareSink(List source) { + return new ListAppendingOutputStream(source); + + } + + @Test + public void testTrace() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.TRACE); + + assertTrue("Trace level should be enabled for this test", configuredLogger.isTraceEnabled()); + configuredLogger.trace("Simple trace message"); + + assertEquals("Trace message should've been captured", 1, loggingEvents.size()); + assertTrue("Message should be logged in trace level", isTraceMessage(loggingEvents.get(0))); + assertEquals("Supplied trace message wasn't found in the log", + "Simple trace message", + extractMessage(loggingEvents.get(0))); + + loggingEvents.clear(); + + configuredLogger.debug("Simple debug message"); + configuredLogger.info("Simple info message"); + configuredLogger.warn("Simple warn message"); + configuredLogger.error("Simple error message"); + assertEquals("The other levels should have been captured", 4, loggingEvents.size()); + + } + + @Test + public void testDebug() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.DEBUG); + + configuredLogger.trace("Simple trace message"); + assertEquals("Lower levels should have been ignored", 0, loggingEvents.size()); + + assertTrue("Debug level should be enabled for this test", configuredLogger.isDebugEnabled()); + configuredLogger.debug("Simple debug message"); + + assertEquals("Debug message should've been captured", 1, loggingEvents.size()); + assertTrue("Message should be logged in debug level", isDebugMessage(loggingEvents.get(0))); + assertEquals("Supplied debug message wasn't found in the log", + "Simple debug message", + extractMessage(loggingEvents.get(0))); + + loggingEvents.clear(); + + configuredLogger.info("Simple info message"); + configuredLogger.warn("Simple warn message"); + configuredLogger.error("Simple error message"); + assertEquals("The other levels should have been captured", 3, loggingEvents.size()); + } + + + @Test + public void testInfo() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO); + + configuredLogger.trace("Simple trace message"); + configuredLogger.debug("Simple debug message"); + assertEquals("Lower levels should have been ignored", 0, loggingEvents.size()); + + assertTrue("Info level should be enabled for this test", configuredLogger.isInfoEnabled()); + configuredLogger.info("Simple info message"); + + assertEquals("Info message should've been captured", 1, loggingEvents.size()); + assertTrue("Message should be logged in debug level", isInfoMessage(loggingEvents.get(0))); + assertEquals("Supplied info message wasn't found in the log", + "Simple info message", + extractMessage(loggingEvents.get(0))); + + loggingEvents.clear(); + + configuredLogger.warn("Simple warn message"); + configuredLogger.error("Simple error message"); + assertEquals("The other levels should have been captured", 2, loggingEvents.size()); + } + + @Test + public void testWarn() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.WARN); + + configuredLogger.trace("Simple trace message"); + configuredLogger.debug("Simple debug message"); + configuredLogger.info("Simple info message"); + assertEquals("Lower levels should have been ignored", 0, loggingEvents.size()); + + assertTrue("Warn level should be enabled for this test", configuredLogger.isWarnEnabled()); + configuredLogger.warn("Simple warn message"); + + assertEquals("Warn message should've been captured", 1, loggingEvents.size()); + assertTrue("Message should be logged in warn level", isWarnMessage(loggingEvents.get(0))); + assertEquals("Supplied warn message wasn't found in the log", + "Simple warn message", + extractMessage(loggingEvents.get(0))); + + loggingEvents.clear(); + + configuredLogger.error("Simple error message"); + assertEquals("The other levels should have been captured", 1, loggingEvents.size()); + } + + @Test + public void testError() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.ERROR); + + configuredLogger.trace("Simple trace message"); + configuredLogger.debug("Simple debug message"); + configuredLogger.info("Simple info message"); + configuredLogger.warn("Simple warn message"); + assertEquals("Lower levels should have been ignored", 0, loggingEvents.size()); + + assertTrue("Error level should be enabled for this test", configuredLogger.isErrorEnabled()); + configuredLogger.error("Simple error message"); + + assertEquals("Error message should've been captured", 1, loggingEvents.size()); + assertTrue("Message should be logged in error level", isErrorMessage(loggingEvents.get(0))); + assertEquals("Supplied error message wasn't found in the log", + "Simple error message", + extractMessage(loggingEvents.get(0))); + } + + @Test + public void testFormatting() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO); + + configuredLogger.info("Some {} string", "formatted"); + assertEquals("The formatted message should've been captured", 1, loggingEvents.size()); + assertEquals("Message should've been formatted", "Some formatted string", extractMessage(loggingEvents.get(0))); + } + + @Test + public void testException() { + ArrayList loggingEvents = new ArrayList<>(); + Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO); + + Exception exception = new RuntimeException("My error"); + + configuredLogger.info("Logging with an exception", exception); + assertEquals("The formatted message should've been captured", 1, loggingEvents.size()); + assertEquals("Message should've been formatted", + "My error", + extractExceptionMessage(loggingEvents.get(0))); + + assertEquals("Message should've been formatted", + "java.lang.RuntimeException", + extractExceptionType(loggingEvents.get(0))); + } + + + /** + * Allows tests to check whether the log message contains a trace message. + * Override if needed. + * @param message String containing the full log message + * @return whether it is a trace message or not + */ + protected boolean isTraceMessage(String message) { + return message.toLowerCase().contains("trace"); + } + + /** + * Allows tests to check whether the log message contains a debug message. + * Override if needed. + * @param message String containing the full log message + * @return whether it is a debug message or not + */ + protected boolean isDebugMessage(String message) { + return message.toLowerCase().contains("debug"); + } + + /** + * Allows tests to check whether the log message contains an info message. + * Override if needed. + * @param message String containing the full log message + * @return whether it is an info message or not + */ + protected boolean isInfoMessage(String message) { + return message.toLowerCase().contains("info"); + } + + /** + * Allows tests to check whether the log message contains a warn message. + * Override if needed. + * @param message String containing the full log message + * @return whether it is a warn message or not + */ + protected boolean isWarnMessage(String message) { + return message.toLowerCase().contains("warn"); + } + + /** + * Allows tests to check whether the log message contains an error message. + * Override if needed. + * @param message String containing the full log message + * @return whether it is an error message or not + */ + protected boolean isErrorMessage(String message) { + return message.toLowerCase().contains("error"); + } + + /** + * Extracts only the part of the log string that should represent the `message` string. + * @param message the full log message + * @return only the supplied message + */ + public abstract String extractMessage(String message); + + /** + * Extracts only the part of the log string that should represent the supplied exception message, if any. + * @param message the full log message + * @return only the supplied exception message + */ + public abstract String extractExceptionMessage(String message); + + /** + * Extracts only the part of the log string that should represent the supplied exception type. + * @param message the full log message + * @return only the supplied exception type name + */ + public abstract String extractExceptionType(String message); + + /** + * Configures the logger for running the tests. + * @param outputStream The output stream for logs to be written to + * @param level The expected level the tests will run for this logger + * @return a configured logger able to run the tests + */ + public abstract Logger createLogger(ListAppendingOutputStream outputStream, Level level); + +} \ No newline at end of file