From affee720ea6852d93d28bb218f084a120b708247 Mon Sep 17 00:00:00 2001
From: Topbadger <29448132+topbadger@users.noreply.github.com>
Date: Mon, 13 Mar 2023 20:10:37 +0000
Subject: [PATCH] Added static helper method and method overloads to make
 assertions using the PredicateBuilder more fluent.

---
 .../valfirst/slf4jtest/TestLoggerAssert.java  | 31 +++++++++++++
 .../slf4jtest/TestLoggerAssertionsTest.java   | 44 +++++++++++++++++++
 2 files changed, 75 insertions(+)

diff --git a/src/main/java/com/github/valfirst/slf4jtest/TestLoggerAssert.java b/src/main/java/com/github/valfirst/slf4jtest/TestLoggerAssert.java
index 12bb550a..7ac0ad44 100644
--- a/src/main/java/com/github/valfirst/slf4jtest/TestLoggerAssert.java
+++ b/src/main/java/com/github/valfirst/slf4jtest/TestLoggerAssert.java
@@ -97,6 +97,17 @@ public TestLoggerAssert hasLogged(Predicate<LoggingEvent> predicate) {
         return hasLogged(predicate, "Failed to find log matching predicate");
     }
 
+    /**
+     * Uses the supplied {@link PredicateBuilder} to construct the predicate with which to Verify that
+     * a matching {@link LoggingEvent} has been logged by the test logger.
+     *
+     * @param predicate the {@link PredicateBuilder} to use to construct the test predicate
+     * @return a {@link TestLoggerAssert} for chaining
+     */
+    public TestLoggerAssert hasLogged(PredicateBuilder predicate) {
+        return hasLogged(predicate.build());
+    }
+
     /**
      * Verify that a log message, at a specific level, has not been logged by the test logger.
      *
@@ -150,6 +161,22 @@ public TestLoggerAssert hasNotLogged(Predicate<LoggingEvent> predicate) {
         return this;
     }
 
+    /**
+     * Uses the supplied {@link PredicateBuilder} to construct the predicate with which to Verify that
+     * a matching {@link LoggingEvent} has _not_ been logged by the test logger.
+     *
+     * @param predicate the {@link PredicateBuilder} to use to construct the test predicate
+     * @return a {@link TestLoggerAssert} for chaining
+     */
+    public TestLoggerAssert hasNotLogged(PredicateBuilder predicate) {
+        findEvent(predicate.build())
+                .ifPresent(
+                        loggingEvent ->
+                                failWithMessage("Found %s, even though we expected not to", loggingEvent));
+
+        return this;
+    }
+
     /**
      * Convenience method for a {@link LevelAssert} from a provided test logger.
      *
@@ -204,6 +231,10 @@ public static class PredicateBuilder {
         private Predicate<LoggingEvent> throwablePredicate = IGNORE_PREDICATE;
         private Predicate<LoggingEvent> levelPredicate = IGNORE_PREDICATE;
 
+        public static PredicateBuilder aLog() {
+            return new PredicateBuilder();
+        }
+
         public PredicateBuilder withLevel(Level level) {
             levelPredicate = event -> event.getLevel().equals(level);
             return this;
diff --git a/src/test/java/com/github/valfirst/slf4jtest/TestLoggerAssertionsTest.java b/src/test/java/com/github/valfirst/slf4jtest/TestLoggerAssertionsTest.java
index 9c6cf4c8..e995d65e 100644
--- a/src/test/java/com/github/valfirst/slf4jtest/TestLoggerAssertionsTest.java
+++ b/src/test/java/com/github/valfirst/slf4jtest/TestLoggerAssertionsTest.java
@@ -3,6 +3,7 @@
 import static com.github.valfirst.slf4jtest.LoggingEvent.warn;
 import static com.github.valfirst.slf4jtest.TestLoggerAssert.MdcComparator.CONTAINING;
 import static com.github.valfirst.slf4jtest.TestLoggerAssert.MdcComparator.IGNORING;
+import static com.github.valfirst.slf4jtest.TestLoggerAssert.PredicateBuilder.aLog;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
@@ -187,6 +188,28 @@ void failsWhenPredicateDoesNotMatch() {
             }
         }
 
+        @Nested
+        class UsingPredicateBuilder {
+
+            @Test
+            void passesWhenPredicateMatches() {
+                eventsStubbing.thenReturn(ImmutableList.of(warn("A message")));
+                assertThatNoException()
+                        .isThrownBy(() -> loggerAssert.hasLogged(aLog().withMessage("A message")));
+            }
+
+            @Test
+            void failsWhenPredicateDoesNotMatch() {
+                LoggingEvent loggingEvent = warn("A different message");
+                eventsStubbing.thenReturn(ImmutableList.of(loggingEvent));
+
+                assertThatThrownBy(() -> loggerAssert.hasLogged(aLog().withMessage("A message")))
+                        .isInstanceOf(AssertionError.class)
+                        .hasMessage(
+                                "Failed to find log matching predicate" + loggerContainedMessage(loggingEvent));
+            }
+        }
+
         abstract class TestCase {
 
             abstract TestLoggerAssert performAssert(
@@ -415,6 +438,27 @@ void failsWhenPredicateMatches() {
             }
         }
 
+        @Nested
+        class UsingPredicateBuilder {
+            @Test
+            void passesWhenPredicateDoesNotMatch() {
+                eventsStubbing.thenReturn(ImmutableList.of(warn("A message")));
+
+                assertThatNoException()
+                        .isThrownBy(() -> loggerAssert.hasNotLogged(aLog().withMessage("Unexpected")));
+            }
+
+            @Test
+            void failsWhenPredicateMatches() {
+                LoggingEvent loggingEvent = warn("A message");
+                eventsStubbing.thenReturn(ImmutableList.of(loggingEvent));
+
+                assertThatThrownBy(() -> loggerAssert.hasNotLogged(aLog().withMessage("A message")))
+                        .isInstanceOf(AssertionError.class)
+                        .hasMessage("Found " + loggingEvent + ", even though we expected not to");
+            }
+        }
+
         abstract class TestCase {
             abstract TestLoggerAssert performAssert(
                     TestLoggerAssert loggerAssert, Level level, String message, Object... arguments);