refactor: auditEntryExpectation validations

Author: dieppa

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

@@ -22,10 +22,14 @@
 import io.flamingock.internal.common.core.audit.AuditEntry;
 import io.flamingock.support.stages.ThenStage;
 import io.flamingock.support.stages.WhenStage;
+import io.flamingock.support.validation.error.FieldMismatchError;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
 
 import static io.flamingock.internal.common.core.audit.AuditEntry.Status.APPLIED;
 import static io.flamingock.internal.common.core.audit.AuditEntry.Status.FAILED;
@@ -466,6 +470,131 @@ public AuditEntryExpectation withTargetSystemId(String targetSystemId) {
         return this;
     }
 
+    // ==================== Comparison Logic ====================
+
+    /**
+     * Compares this expectation against an actual audit entry.
+     *
+     * <p>Returns a list of field mismatches (empty if all expected fields match).
+     * Only fields with non-null expected values are verified, except for
+     * {@code changeId} and {@code status} which are always verified.</p>
+     *
+     * <p>Timestamp verification supports two modes:</p>
+     * <ul>
+     *   <li>Exact match: when {@code expectedCreatedAt} is set</li>
+     *   <li>Range match: when {@code timestampAfter} and/or {@code timestampBefore} are set</li>
+     * </ul>
+     *
+     * @param actual the actual audit entry to compare against
+     * @return list of field mismatch errors (empty if all match)
+     */
+    public List<FieldMismatchError> compareWith(AuditEntry actual) {
+        List<FieldMismatchError> errors = new ArrayList<>();
+
+        // Required fields - always verified
+        if (!expectedChangeId.equals(actual.getTaskId())) {
+            errors.add(new FieldMismatchError("changeId", expectedChangeId, actual.getTaskId()));
+        }
+
+        if (expectedState != actual.getState()) {
+            errors.add(new FieldMismatchError("status",
+                    expectedState.name(),
+                    actual.getState() != null ? actual.getState().name() : null));
+        }
+
+        // Optional fields - verified when non-null
+        if (expectedExecutionId != null && !expectedExecutionId.equals(actual.getExecutionId())) {
+            errors.add(new FieldMismatchError("executionId", expectedExecutionId, actual.getExecutionId()));
+        }
+
+        if (expectedStageId != null && !expectedStageId.equals(actual.getStageId())) {
+            errors.add(new FieldMismatchError("stageId", expectedStageId, actual.getStageId()));
+        }
+
+        if (expectedAuthor != null && !expectedAuthor.equals(actual.getAuthor())) {
+            errors.add(new FieldMismatchError("author", expectedAuthor, actual.getAuthor()));
+        }
+
+        if (expectedClassName != null && !expectedClassName.equals(actual.getClassName())) {
+            errors.add(new FieldMismatchError("className", expectedClassName, actual.getClassName()));
+        }
+
+        if (expectedMethodName != null && !expectedMethodName.equals(actual.getMethodName())) {
+            errors.add(new FieldMismatchError("methodName", expectedMethodName, actual.getMethodName()));
+        }
+
+        if (expectedMetadata != null && !Objects.equals(expectedMetadata, actual.getMetadata())) {
+            errors.add(new FieldMismatchError("metadata",
+                    String.valueOf(expectedMetadata),
+                    String.valueOf(actual.getMetadata())));
+        }
+
+        if (expectedExecutionMillis != null && expectedExecutionMillis != actual.getExecutionMillis()) {
+            errors.add(new FieldMismatchError("executionMillis",
+                    String.valueOf(expectedExecutionMillis),
+                    String.valueOf(actual.getExecutionMillis())));
+        }
+
+        if (expectedExecutionHostname != null && !expectedExecutionHostname.equals(actual.getExecutionHostname())) {
+            errors.add(new FieldMismatchError("executionHostname", expectedExecutionHostname, actual.getExecutionHostname()));
+        }
+
+        if (expectedErrorTrace != null && !expectedErrorTrace.equals(actual.getErrorTrace())) {
+            errors.add(new FieldMismatchError("errorTrace", expectedErrorTrace, actual.getErrorTrace()));
+        }
+
+        if (expectedTargetSystemId != null && !expectedTargetSystemId.equals(actual.getTargetSystemId())) {
+            errors.add(new FieldMismatchError("targetSystemId", expectedTargetSystemId, actual.getTargetSystemId()));
+        }
+
+        // Timestamp verification
+        compareTimestamp(actual, errors);
+
+        return errors;
+    }
+
+    private void compareTimestamp(AuditEntry actual, List<FieldMismatchError> errors) {
+        if (expectedCreatedAt != null) {
+            // Exact match mode
+            if (!expectedCreatedAt.equals(actual.getCreatedAt())) {
+                errors.add(new FieldMismatchError("createdAt",
+                        expectedCreatedAt.toString(),
+                        actual.getCreatedAt() != null ? actual.getCreatedAt().toString() : null));
+            }
+        } else if (timestampAfter != null || timestampBefore != null) {
+            // Range match mode
+            LocalDateTime actualTimestamp = actual.getCreatedAt();
+            if (actualTimestamp == null) {
+                errors.add(new FieldMismatchError("createdAt",
+                        formatTimestampRange(),
+                        null));
+            } else {
+                boolean afterOk = timestampAfter == null ||
+                        actualTimestamp.isAfter(timestampAfter) ||
+                        actualTimestamp.isEqual(timestampAfter);
+                boolean beforeOk = timestampBefore == null ||
+                        actualTimestamp.isBefore(timestampBefore) ||
+                        actualTimestamp.isEqual(timestampBefore);
+
+                if (!afterOk || !beforeOk) {
+                    errors.add(new FieldMismatchError("createdAt",
+                            formatTimestampRange(),
+                            actualTimestamp.toString()));
+                }
+            }
+        }
+    }
+
+    private String formatTimestampRange() {
+        if (timestampAfter != null && timestampBefore != null) {
+            return String.format("between %s and %s", timestampAfter, timestampBefore);
+        } else if (timestampAfter != null) {
+            return String.format("after %s", timestampAfter);
+        } else {
+            return String.format("before %s", timestampBefore);
+        }
+    }
+
     // ==================== Getters (for verification logic) ====================
 
     /** Returns the expected execution ID. */