LogCaptor Documentation

LogCaptor may fail to set up if the logger and LogCaptor are initialized by different classloaders (a common issue in frameworks like Quarkus using @QuarkusTest).

An alternative solution is to redirect all logs to the console and use ConsoleCaptor to verify them.

1. Add Dependencies

Add consolecaptor and logback-classic to your test scope.

2. Configure Logback

Add a logback-test.xml to your test resources to route logs to STDOUT.

3. Use ConsoleCaptor in Tests

Wrap your test logic in a try-with-resources block using ConsoleCaptor and assert against getStandardOutput().

<!-- 1. Dependencies -->
<dependencies>
   <dependency>
      <groupId>io.github.hakky54</groupId>
      <artifactId>consolecaptor</artifactId>
      <scope>test</scope>
   </dependency>
   <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <scope>test</scope>
   </dependency>
</dependencies>

<!-- 2. logback-test.xml -->
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="TRACE">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

<!-- 3. Test Implementation -->
@QuarkusTest
class QuarkusTestTest {
    @Test
    void captureLogs() {
       try(ConsoleCaptor consoleCaptor = new ConsoleCaptor()) {
           HelloResource resource = new HelloResource();
           resource.hello();

           List<String> standardOutput = consoleCaptor.getStandardOutput();
           assertThat(standardOutput).hasSize(1).contains("Hello");
       }
    }
}

For better performance, you can initialize a LogCaptor once in a @BeforeAll method and reuse it across all tests in a class. To prevent logs from one test leaking into another, call logCaptor.clearLogs() in an @AfterEach method. Finally, ensure you call logCaptor.close() in an @AfterAll method to release resources.

import nl.altindag.log.LogCaptor;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;

public class FooServiceShould {

    private static LogCaptor logCaptor;
    
    @BeforeAll
    public static void setupLogCaptor() {
        logCaptor = LogCaptor.forClass(FooService.class);
    }

    @AfterEach
    public void clearLogs() {
        logCaptor.clearLogs();
    }
    
    @AfterAll
    public static void tearDown() {
        logCaptor.close();
    }

    @Test
    public void testMethod() {
        // ... test logic
    }
}

LogCaptor uses Logback as its SLF4J implementation. If your project already uses another SLF4J binding (like Log4j), you will see a SLF4J: Class path contains multiple SLF4J bindings warning during tests. This can prevent LogCaptor from capturing logs.

To fix this, exclude your main logging framework's SLF4J implementation during the test phase. Identify the conflicting dependency from the SLF4J warning message (e.g., org.apache.logging.log4j:log4j-slf4j-impl).

<!-- Maven Surefire/Failsafe Example -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <classpathDependencyExcludes>
                    <classpathDependencyExclude>org.apache.logging.log4j:log4j-slf4j-impl</classpathDependencyExclude>
                    <classpathDependencyExclude>org.apache.logging.log4j:log4j-slf4j2-impl</classpathDependencyExclude>
                </classpathDependencyExcludes>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <configuration>
                <classpathDependencyExcludes>
                    <classpathDependencyExclude>org.apache.logging.log4j:log4j-slf4j-impl</classpathDependencyExclude>
                    <classpathDependencyExclude>org.apache.logging.log4j:log4j-slf4j2-impl</classpathDependencyExclude>
                </classpathDependencyExcludes>
            </configuration>
        </plugin>
    </plugins>
</build>

<!-- Gradle Example -->
configurations {
    testImplementation {
        exclude(group = "org.apache.logging.log4j", module = "log4j-slf4j-impl")
        exclude(group = "org.apache.logging.log4j", module = "log4j-slf4j2-impl")
    }
}

To capture logs for a specific class, use LogCaptor.forClass(Class<?> clazz). You can then retrieve logs filtered by their severity level (e.g., getInfoLogs(), getWarnLogs(), getErrorLogs(), etc.) or retrieve all logs using getLogs(). This is useful for verifying that specific messages were logged during a method execution.

import nl.altindag.log.LogCaptor;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;

public class FooServiceShould {

    @Test
    public void logInfoAndWarnMessages() {
        LogCaptor logCaptor = LogCaptor.forClass(FooService.class);

        FooService fooService = new FooService();
        fooService.sayHello();

        // Get logs based on level
        assertThat(logCaptor.getInfoLogs()).containsExactly("Keyboard not responding. Press any key to continue...");
        assertThat(logCaptor.getWarnLogs()).containsExactly("Congratulations, you are pregnant!");

        // Get all logs
        assertThat(logCaptor.getLogs())
                .hasSize(2)
                .contains(
                    "Keyboard not responding. Press any key to continue...",
                    "Congratulations, you are pregnant!"
                );
    }
}

To inspect detailed metadata about a log entry, such as the exception thrown, the log level, or the thread name, use logCaptor.getLogEvents(). This returns a list of LogEvent objects.

import nl.altindag.log.LogCaptor;
import nl.altindag.log.model.LogEvent;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;

@Test
void captureLoggingEventsContainingException() {
    LogCaptor logCaptor = LogCaptor.forClass(ZooService.class);

    FooService service = new FooService();
    service.sayHello();

    List<LogEvent> logEvents = logCaptor.getLogEvents();
    assertThat(logEvents).hasSize(1);

    LogEvent logEvent = logEvents.get(0);
    assertThat(logEvent.getMessage()).isEqualTo("Caught unexpected exception");
    assertThat(logEvent.getLevel()).isEqualTo("ERROR");
    assertThat(logEvent.getThrowable()).isPresent();
    assertThat(logEvent.getThrowable().get())
            .hasMessage("KABOOM!")
            .isInstanceOf(IOException.class);
}