Bael 8832 (#18020)

* BAEL-8832 add pattern to assert log

* update containsPattern

Author: wynnteo

testing-modules/testing-assertions/src/test/java/com/baeldung/junit/log/BusinessWorkerUnitTest.java

@@ -2,6 +2,9 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.List;
+import java.util.regex.Pattern;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -12,6 +15,7 @@
 import ch.qos.logback.classic.LoggerContext;
 
 public class BusinessWorkerUnitTest {
+
     private static MemoryAppender memoryAppender;
     private static final String LOGGER_NAME = "com.baeldung.junit.log";
     private static final String MSG = "This is a test message!!!";
@@ -37,12 +41,54 @@ public void cleanUp() {
     public void test() {
         BusinessWorker worker = new BusinessWorker();
         worker.generateLogs(MSG);
-        
+
         // I check that I only have 4 messages (all but trace)
         assertThat(memoryAppender.countEventsForLogger(LOGGER_NAME)).isEqualTo(4);
         // I look for a specific message at a specific level, and I only have 1
-        assertThat(memoryAppender.search(MSG, Level.INFO).size()).isEqualTo(1);
+        assertThat(memoryAppender.search(MSG, Level.INFO)
+            .size()).isEqualTo(1);
         // I check that the entry that is not present is the trace level
         assertThat(memoryAppender.contains(MSG, Level.TRACE)).isFalse();
     }
+
+    @Test
+    public void whenMultipleLogLevel_thenReturnExpectedResult() {
+        BusinessWorker worker = new BusinessWorker();
+        worker.generateLogs("Transaction started for Order ID: 1001");
+        assertThat(memoryAppender.countEventsForLogger(LOGGER_NAME)).isEqualTo(4);
+        assertThat(memoryAppender.search("Transaction started", Level.INFO)
+            .size()).isEqualTo(1);
+        assertThat(memoryAppender.search("Transaction started", Level.WARN)
+            .size()).isEqualTo(1);
+        assertThat(memoryAppender.search("Transaction started", Level.ERROR)
+            .size()).isEqualTo(1);
+        assertThat(memoryAppender.search("Transaction started", Level.TRACE)).isEmpty();
+    }
+
+    @Test
+    public void whenUsingPattern_thenReturnExpectedResult() {
+        BusinessWorker worker = new BusinessWorker();
+        worker.generateLogs("Order processed successfully for Order ID: 12345");
+
+        Pattern orderPattern = Pattern.compile(".*Order ID: \\d{5}.*");
+
+        assertThat(memoryAppender.containsPattern(orderPattern, Level.INFO)).isTrue();
+        assertThat(memoryAppender.containsPattern(orderPattern, Level.WARN)).isTrue();
+        assertThat(memoryAppender.containsPattern(orderPattern, Level.ERROR)).isTrue();
+        assertThat(memoryAppender.containsPattern(orderPattern, Level.TRACE)).isFalse();
+    }
+
+    @Test
+    public void whenUsingMultiplePatterns_thenReturnExpectedResult() {
+        BusinessWorker worker = new BusinessWorker();
+        worker.generateLogs("User Login: username=user123, timestamp=2024-11-25T10:15:30");
+
+        List<Pattern> patterns = List.of(
+            Pattern.compile(".*username=user\\w+.*"),
+            Pattern.compile(".*timestamp=\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}.*")
+        );
+
+        assertThat(memoryAppender.containsPatterns(patterns, Level.INFO)).isTrue();
+        assertThat(memoryAppender.containsPatterns(patterns, Level.WARN)).isTrue();
+    }
 }

testing-modules/testing-assertions/src/test/java/com/baeldung/junit/log/MemoryAppender.java

@@ -2,6 +2,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import ch.qos.logback.classic.Level;
@@ -13,32 +14,38 @@
  * Convenient appender to be able to check slf4j invocations
  */
 public class MemoryAppender extends ListAppender<ILoggingEvent> {
+
     public void reset() {
         this.list.clear();
     }
 
     public boolean contains(String string, Level level) {
         return this.list.stream()
-          .anyMatch(event -> event.toString().contains(string) 
-            && event.getLevel().equals(level));
+            .anyMatch(event -> event.toString()
+                .contains(string) && event.getLevel()
+                .equals(level));
     }
 
     public int countEventsForLogger(String loggerName) {
         return (int) this.list.stream()
-          .filter(event -> event.getLoggerName().contains(loggerName)).count();
+            .filter(event -> event.getLoggerName()
+                .contains(loggerName))
+            .count();
     }
 
     public List<ILoggingEvent> search(String string) {
         return this.list.stream()
-          .filter(event -> event.toString().contains(string))
-          .collect(Collectors.toList());
+            .filter(event -> event.toString()
+                .contains(string))
+            .collect(Collectors.toList());
     }
 
     public List<ILoggingEvent> search(String string, Level level) {
         return this.list.stream()
-          .filter(event -> event.toString().contains(string) 
-            && event.getLevel().equals(level))
-          .collect(Collectors.toList());
+            .filter(event -> event.toString()
+                .contains(string) && event.getLevel()
+                .equals(level))
+            .collect(Collectors.toList());
     }
 
     public int getSize() {
@@ -48,4 +55,15 @@ public int getSize() {
     public List<ILoggingEvent> getLoggedEvents() {
         return Collections.unmodifiableList(this.list);
     }
+
+    public boolean containsPattern(Pattern pattern, Level level) {
+        return this.list.stream()
+            .filter(event -> event.getLevel().equals(level))
+            .anyMatch(event -> pattern.matcher(event.getFormattedMessage()).matches());
+    }
+
+    public boolean containsPatterns(List<Pattern> patternList, Level level) {
+        return patternList.stream()
+            .allMatch(pattern -> containsPattern(pattern, level));
+    }
 }