com.github.valfirst.slf4jtest.LevelAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of slf4j-test Show documentation
An in-memory SLF4J implementation focused on aiding unit testing.
There is a newer version: 3.0.1
package com.github.valfirst.slf4jtest;

import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.slf4j.event.Level;

/**
 * A set of assertions to validate that logs have been logged to a {@link TestLogger}, for a
 * specific log level.
 */
public class LevelAssert extends AbstractTestLoggerAssert {

    private static Predicate messageWithSubstring(String substring) {
        return event -> event.getMessage().contains(substring);
    }

    private static Predicate messageForPattern(String regex) {
        return event -> event.getMessage().matches(regex);
    }

    private final Level level;

    public LevelAssert(TestLogger logger, Level level) {
        super(logger, LevelAssert.class);

        this.level = level;
    }

    /**
     * Assert that the given log level has the expected number of logs, regardless of content.
     *
     * @param expected the number of logs expected at this level
     * @return a {@link LevelAssert} for chaining
     */
    public LevelAssert hasNumberOfLogs(int expected) {
        long count = getLogCount(level, ignored -> true);
        if (count != expected) {
            failWithMessage(
                    "Expected level %s to have %d log messages available, but %d were found",
                    level, expected, count);
        }

        return this;
    }

    /**
     * Assert that the given log level includes a log message that contains a substring.
     *
     * @param substring a substring of a log message that should be present
     * @return a {@link LevelAssert} for chaining
     */
    public LevelAssert hasMessageContaining(String substring) {
        long count = getLogCount(level, messageWithSubstring(substring));
        if (count == 0) {
            failWithMessage(
                    "Expected level %s to contain a log message containing `%s`, but it did not.\n\nLog messages found:%n%s",
                    level, substring, eventsToLogMessage(level));
        }

        return this;
    }

    /**
     * Assert that the given log level includes a log message that matches a regex.
     *
     * @param regex the regular expression to which this string is to be matched
     * @return a {@link LevelAssert} for chaining
     */
    public LevelAssert hasMessageMatching(String regex) {
        long count = getLogCount(level, messageForPattern(regex));
        if (count == 0) {
            failWithMessage(
                    "Expected level %s to contain a log message matching regex `%s`, but it did not.\n\nLog messages found:%n%s",
                    level, regex, eventsToLogMessage());
        }

        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if (!super.equals(o)) return false;
        LevelAssert that = (LevelAssert) o;
        return level == that.level;
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), level);
    }

    private String eventsToLogMessage() {
        return loggingEventsSupplier.get().stream()
                .map(e -> "- " + e)
                .collect(Collectors.joining("\n"));
    }

    private String eventsToLogMessage(Level level) {
        return loggingEventsSupplier.get().stream()
                .filter(event -> level.equals(event.getLevel()))
                .map(e -> "- " + e)
                .collect(Collectors.joining("\n"));
    }
}