feat(test-support): add thenExpectAuditSequenceStrict(#762)

Author: davidfrigolet

core/flamingock-test-support/src/main/java/io/flamingock/support/validation/impl/AuditEntryExpectation.java

@@ -30,11 +30,11 @@
  * against expected definitions. Users should not interact with this class directly;
  * they should use {@link AuditEntryDefinition} instead.</p>
  */
-class AuditEntryExpectation {
+public class AuditEntryExpectation {
 
     private final AuditEntryDefinition definition;
 
-    AuditEntryExpectation(AuditEntryDefinition definition) {
+    public AuditEntryExpectation(AuditEntryDefinition definition) {
         this.definition = definition;
     }
 
@@ -48,7 +48,7 @@ class AuditEntryExpectation {
      * @param actual the actual audit entry to compare against
      * @return list of field mismatch errors (empty if all match)
      */
-    List<FieldMismatchError> compareWith(AuditEntry actual) {
+    public List<FieldMismatchError> compareWith(AuditEntry actual) {
         List<FieldMismatchError> errors = new ArrayList<>();
 
         // Required fields - always verified

core/flamingock-test-support/src/main/java/io/flamingock/support/validation/impl/AuditSequenceStrictValidator.java

@@ -15,33 +15,111 @@
  */
 package io.flamingock.support.validation.impl;
 
+import io.flamingock.internal.common.core.audit.AuditEntry;
 import io.flamingock.internal.common.core.audit.AuditReader;
 import io.flamingock.support.domain.AuditEntryDefinition;
 import io.flamingock.support.validation.SimpleValidator;
-import io.flamingock.support.validation.error.ValidationResult;
+import io.flamingock.support.validation.error.*;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
+/**
+ * Validator that performs strict sequence validation of audit entries.
+ *
+ * <p>This validator verifies that the actual audit entries match the expected
+ * sequence exactly, both in count and in field values. Checking:</p>
+ * <ul>
+ *   <li>Exact count match between expected and actual entries</li>
+ *   <li>Strict field-by-field validation for each entry at each index</li>
+ *   <li>Order preservation (expected[0] must match actual[0], etc.)</li>
+ * </ul>
+ */
 public class AuditSequenceStrictValidator implements SimpleValidator {
 
     private static final String VALIDATOR_NAME = "Audit Sequence (Strict)";
 
     private final AuditReader auditReader;
     private final List<AuditEntryExpectation> expectations;
-
+    private final List<AuditEntry> actualEntries;
 
     public AuditSequenceStrictValidator(AuditReader auditReader, AuditEntryDefinition... definitions) {
         this.auditReader = auditReader;
         this.expectations = Arrays.stream(definitions)
                 .map(AuditEntryExpectation::new)
                 .collect(Collectors.toList());
+        this.actualEntries = auditReader.getAuditHistory();
+    }
+
+    /**
+     * Internal constructor for direct list initialization (used by tests).
+     */
+    AuditSequenceStrictValidator(List<AuditEntryDefinition> expectedDefinitions, List<AuditEntry> actualEntries, AuditReader auditReader) {
+        this.expectations = expectedDefinitions != null
+                ? expectedDefinitions.stream()
+                .map(AuditEntryExpectation::new)
+                .collect(Collectors.toList())
+                : new ArrayList<>();
+        this.auditReader = auditReader;
+        this.actualEntries = actualEntries != null ? actualEntries : new ArrayList<>();
     }
 
     @Override
     public ValidationResult validate() {
-        // TODO: Implement actual validation logic
-        return ValidationResult.success(VALIDATOR_NAME);
+        List<ValidationError> allErrors = new ArrayList<>();
+
+        int expectedSize = expectations.size();
+        int actualSize = actualEntries.size();
+
+        if (expectedSize != actualSize) {
+            allErrors.add(new CountMismatchError(getExpectedChangeIds(), getActualChangeIds()));
+        }
+
+        allErrors.addAll(getValidationErrors(expectations, actualEntries));
+
+        if (allErrors.isEmpty()) {
+            return ValidationResult.success(VALIDATOR_NAME);
+        }
+
+        return ValidationResult.failure(VALIDATOR_NAME, allErrors.toArray(new ValidationError[0]));
+    }
+
+    private static List<ValidationError> getValidationErrors(List<AuditEntryExpectation> expectedEntries, List<AuditEntry> actualEntries) {
+        List<ValidationError> allErrors = new ArrayList<>();
+        if (expectedEntries.isEmpty()) {
+            return allErrors;
+        }
+        int actualSize = actualEntries.size();
+        int limit = Math.max(expectedEntries.size(), actualSize);
+
+        for (int i = 0; i < limit; i++) {
+            AuditEntryExpectation expected = i < expectedEntries.size() ? expectedEntries.get(i) : null;
+            AuditEntry actual = i < actualEntries.size() ? actualEntries.get(i) : null;
+            if( expected != null && actual != null) {
+               allErrors.addAll(expected.compareWith(actual));
+            } else if( expected != null) {
+               AuditEntryDefinition def = expected.getDefinition();
+                allErrors.add(new MissingEntryError(i, def.getChangeId(), def.getState()));
+            } else {
+                assert actual != null;
+                allErrors.add(new UnexpectedEntryError(i, actual.getTaskId(), actual.getState()));
+            }
+           
+        }
+        return allErrors;
+    }
+
+    private List<String> getExpectedChangeIds() {
+        return expectations.stream()
+                .map(exp -> exp.getDefinition().getChangeId())
+                .collect(Collectors.toList());
+    }
+
+    private List<String> getActualChangeIds() {
+        return actualEntries.stream()
+                .map(AuditEntry::getTaskId)
+                .collect(Collectors.toList());
     }
 }