在这里，模拟是一个选项，尽管这很困难，因为记录器通常是私有的静态final -所以设置模拟记录器不是小意思，或者需要修改被测试的类。

你可以创建一个自定义的Appender(或者其他什么名字)，然后注册它——要么通过一个只测试的配置文件，要么通过运行时(在某种程度上，依赖于日志框架)。 然后，您可以获得该appender(如果在配置文件中声明，可以是静态的，如果在运行时插入它，则可以通过它的当前引用)，并验证其内容。

Here is the sample code to mock log, irrespective of the version used for junit or sping, springboot.

import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.Appender;
import org.mockito.ArgumentMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.Test;

import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class MyTest {
  private static Logger logger = LoggerFactory.getLogger(MyTest.class);

    @Test
    public void testSomething() {
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    final Appender mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);

    //... do whatever you need to trigger the log

    verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
      @Override
      public boolean matches(final Object argument) {
        return ((LoggingEvent)argument).getFormattedMessage().contains("Hey this is the message I want to see");
      }
    }));
  }
}

对于Junit 5 (Jupiter)， Spring的OutputCaptureExtension非常有用。它从Spring Boot 2.2开始就可以使用，并且可以在Spring - Boot -test构件中使用。

示例(取自javadoc):

@ExtendWith(OutputCaptureExtension.class)
class MyTest {
    @Test
    void test(CapturedOutput output) {
        System.out.println("ok");
        assertThat(output).contains("ok");
        System.err.println("error");
    }

    @AfterEach
    void after(CapturedOutput output) {
        assertThat(output.getOut()).contains("ok");
        assertThat(output.getErr()).contains("error");
    }
}

这是我为logback所做的。

我创建了一个TestAppender类:

public class TestAppender extends AppenderBase<ILoggingEvent> {

    private Stack<ILoggingEvent> events = new Stack<ILoggingEvent>();

    @Override
    protected void append(ILoggingEvent event) {
        events.add(event);
    }

    public void clear() {
        events.clear();
    }

    public ILoggingEvent getLastEvent() {
        return events.pop();
    }
}

然后在我的testng单元测试类的父类中创建了一个方法:

protected TestAppender testAppender;

@BeforeClass
public void setupLogsForTesting() {
    Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    testAppender = (TestAppender)root.getAppender("TEST");
    if (testAppender != null) {
        testAppender.clear();
    }
}

我在src/test/resources中定义了一个logback-test.xml文件，并添加了一个测试appender:

<appender name="TEST" class="com.intuit.icn.TestAppender">
    <encoder>
        <pattern>%m%n</pattern>
    </encoder>
</appender>

并将这个appender添加到根appender:

<root>
    <level value="error" />
    <appender-ref ref="STDOUT" />
    <appender-ref ref="TEST" />
</root>

现在，在从父测试类扩展而来的测试类中，我可以获得appender并记录最后一条消息，并验证消息、级别和throwable。

ILoggingEvent lastEvent = testAppender.getLastEvent();
assertEquals(lastEvent.getMessage(), "...");
assertEquals(lastEvent.getLevel(), Level.WARN);
assertEquals(lastEvent.getThrowableProxy().getMessage(), "...");

在这里，模拟是一个选项，尽管这很困难，因为记录器通常是私有的静态final -所以设置模拟记录器不是小意思，或者需要修改被测试的类。

你可以创建一个自定义的Appender(或者其他什么名字)，然后注册它——要么通过一个只测试的配置文件，要么通过运行时(在某种程度上，依赖于日志框架)。 然后，您可以获得该appender(如果在配置文件中声明，可以是静态的，如果在运行时插入它，则可以通过它的当前引用)，并验证其内容。

通过添加Appender进行单元测试并不能真正测试Logger的配置。因此，我认为这是一种独特的情况，在这种情况下，单元测试没有带来那么多价值，而集成测试带来了很多价值(特别是如果您的日志有一些审计目的)。

为了为它创建集成测试，让我们假设您正在运行一个简单的ConsoleAppender，并希望测试它的输出。然后，您应该测试如何将消息从System.out写入到它自己的ByteArrayOutputStream。

从这个意义上说，我会做以下事情(我使用JUnit 5):

public class Slf4jAuditLoggerTest {

    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

    @BeforeEach
    public void beforeEach() {
        System.setOut(new PrintStream(outContent));
    }

通过这种方式，你可以简单地测试它的输出:

    @Test
    public void myTest() {
        // Given...
        // When...
        // Then
        assertTrue(outContent.toString().contains("[INFO] My formatted string from Logger"));
    }

如果你这样做了，你将为你的项目带来更多的价值，而不需要使用内存中的实现，创建一个新的Appender，或者其他什么。