Mocking Logger and LoggerFactory

1. Overview

Logging is an essential part of software development. We often add logs to simplify debugging and gain insights into an application’s internal behavior.

While writing tests, we may not want to rely on real logging infrastructure. Mocking allows us to isolate a class under test by replacing its dependencies with controllable substitutes.

In this tutorial, we’ll explore how Mockito enables us to mock Logger and work with LoggerFactory. Also, we’ll walk through examples to demonstrate the process step by step.

2. Logger and LoggerFactory Classes

The SLF4J library provides the Logger interface, which provides common logging methods such as info(), error(), and debug(). Also, the library provides the LoggerFactory class, which helps create a logger instance for a given class.

Typically, loggers in Java applications are declared as static fields:

private static final Logger logger = LoggerFactory.getLogger(Example.class);

Since Loggerfactory.getLogger() is a static method, mocking may require a third-party tool such as PowerMock. However, since Mockito 3.4.0, we can now mock static methods directly using the MockedStatic class, eliminating the need for PowerMock or a dedicated test runner.

3. Maven Dependencies

To demonstrate how to mock a Logger and Loggerfactory, let’s boostrap a simple Java project and add the mockito-core dependency to our pom.xml:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.19.0</version>
    <scope>test</scope>
</dependency>

The mockito-core dependencies provide the core classes for creating mocks and stubs.

Also, let’s add the slf4j-api and junit-jupiter-api dependencies to the pom.xml:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.17</version>
</dependency>

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.13.4</version>
    <scope>test</scope>
</dependency>

Additionally, slf4j-api enables us to log to the console, and junit-jupiter-api facilitates writing JUnit 5 tests.

4. Service Class

Moving on, let’s write a service class with a method to put under test:

class UserService {

    private final Logger logger;

    public UserService(Logger logger) {
        this.logger = logger;
    }

    public void checkAdminStatus(boolean isAdmin) {
        if (isAdmin) {
            logger.info("You are an admin, access granted");
        } else {
            logger.error("You are not an admin");
        }
    }

    public void processUser(String username) {
        logger.info("Processing user: {}", username);
        logger.warn("Please don't close your browser ...");
        logger.info("Processing complete");
    }
}

In the code above, we define a class named UserService with two methods. The first method, named checkAdminStatus(), checks if the user is an admin or not. The second method, named processUser(), processes a user by logging certain information on the console.

Also, we inject a Logger instance through the constructor instead of instantiating it directly. This design makes the class easier to test, since we can provide a mock Logger when testing.

5. Unit Test

Next, let’s write unit tests for the UserService class. First, let’s define a unit test class and set up the necessary mock:

class UserServiceUnitTest {

    private Logger mockLogger;
    private UserService userService;

    @BeforeEach
    public void setup() {
        mockLogger = mock(Logger.class);
        userService = new UserService(mockLogger);
    }
}

Here, we create a mockLogger and inject it into the UserService instance. This makes it easy to verify logging behavior during tests.

Moving on, let’s write our first test case, where a user isn’t an admin:

@Test
void givenUserServiceLogic_whenVerifyingIfUserIsNotAnAdmin_thenReturnCorrectLog() {

    try (MockedStatic<LoggerFactory> mockedFactory = mockStatic(LoggerFactory.class)) {
        mockedFactory.when(() -> LoggerFactory.getLogger(UserService.class))
          .thenReturn(mockLogger);
        userService.checkAdminStatus(false);

        verify(mockLogger).error("You are not an admin");

   }
}

In the code above, we use the MockedStatic class to intercept calls to LoggerFactory.getLogger()  and return our mock Logger. Then, we call the method under test and verify that the expected error message was logged.

Next, let’s add another test for the case where a user is an admin:

@Test
void givenUserServiceLogic_whenVerifyingIfUserIsAnAdmin_thenReturnCorrectLog() {

    try (MockedStatic<LoggerFactory> mockedFactory = mockStatic(LoggerFactory.class)) {
        mockedFactory.when(() -> LoggerFactory.getLogger(UserService.class))
          .thenReturn(mockLogger);
        userService.checkAdminStatus(true);

        verify(mockLogger).info("You are an admin, access granted");
    }
}

Here, we check the positive case and verify that the correct info log message is produced.

Finally, let’s write a test that verifies multiple logging calls:

@Test
void givenUserServiceLogic_whenProcessingAUser_thenLogMultipleMessage() {
    try (MockedStatic<LoggerFactory> mockedFactory = mockStatic(LoggerFactory.class)) {
        mockedFactory.when(() -> LoggerFactory.getLogger(UserService.class))
          .thenReturn(mockLogger);
        userService.processUser("Harry");

        InOrder inOrder = inOrder(mockLogger);

        inOrder.verify(mockLogger).info("Processing user: {}", "Harry");
        inOrder.verify(mockLogger).info("Processing complete");
    }
}

In the code above, we put the processUser() method, which makes two logging calls, under test. Also, we invoke the verify() method twice – once for each expected log message and use the inOrder() method to ensure that the messages are logged in the correct sequence. This guarantees that both messages are captured exactly as intended.

6. Conclusion

In this article, we learned how to mock Logger and LoggerFactory using Mockito without relying on a runner like PowerMock. Also, we saw how the MockedStatic class enables us to mock static methods, making it possible to intercept calls to LoggerFactory.getLogger() during testing.