http: contain exactly correctly marks nodes (#1595)

Author: MykolaGolubyev

webtau-core-groovy/src/test/groovy/org/testingisdocumenting/webtau/expectation/equality/AnyValueMatcherTest.groovy

@@ -33,6 +33,6 @@ class AnyValueMatcherTest {
 
         code {
             value.shouldNotBe anyValue
-        } should throwException("anyValue matches every value")
+        } should throwException(contain("anyValue matches every value"))
     }
 }

webtau-core/src/main/java/org/testingisdocumenting/webtau/data/datanode/DataNodeIdParsedPathPart.java

@@ -16,31 +16,11 @@
 
 package org.testingisdocumenting.webtau.data.datanode;
 
-public class DataNodeIdParsedPathPart {
+public record DataNodeIdParsedPathPart(
+        DataNodeIdParsedPathPart.PartType type, Integer idx,
+        String childName) {
     public enum PartType {
         PEER,
         CHILD
     }
-
-    private final PartType type;
-    private final Integer idx;
-    private final String childName;
-
-    public DataNodeIdParsedPathPart(PartType type, Integer idx, String childName) {
-        this.type = type;
-        this.idx = idx;
-        this.childName = childName;
-    }
-
-    public PartType getType() {
-        return type;
-    }
-
-    public Integer getIdx() {
-        return idx;
-    }
-
-    public String getChildName() {
-        return childName;
-    }
 }

webtau-core/src/main/java/org/testingisdocumenting/webtau/data/datanode/ValueExtractorByPath.java

@@ -29,15 +29,13 @@ public static <R> R extractFromMapOrList(Object mapOrList, String path) {
 
         List<DataNodeIdParsedPathPart> parts = DataNodeIdPathParser.parse(path);
         for (DataNodeIdParsedPathPart part : parts) {
-            switch (part.getType()) {
+            switch (part.type()) {
                 case PEER:
-                    if (!(result instanceof List)) {
+                    if (!(result instanceof List<?> list)) {
                         return null;
                     }
 
-                    List<?> list = (List<?>) result;
-
-                    int idx = part.getIdx();
+                    int idx = part.idx();
                     if (idx < 0) {
                         idx = list.size() + idx;
                     }
@@ -53,7 +51,7 @@ public static <R> R extractFromMapOrList(Object mapOrList, String path) {
                         return null;
                     }
 
-                    result = ((Map<String, ?>) result).get(part.getChildName());
+                    result = ((Map<String, ?>) result).get(part.childName());
                     break;
             }
         }
@@ -66,14 +64,10 @@ public static DataNode extractFromDataNode(DataNode dataNode, String path) {
 
         List<DataNodeIdParsedPathPart> parts = DataNodeIdPathParser.parse(path);
         for (DataNodeIdParsedPathPart part : parts) {
-            switch (part.getType()) {
-                case PEER:
-                    result = result.get(part.getIdx());
-                    break;
-                case CHILD:
-                    result = result.get(part.getChildName());
-                    break;
-            }
+            result = switch (part.type()) {
+                case PEER -> result.get(part.idx());
+                case CHILD -> result.get(part.childName());
+            };
         }
 
         return result;

webtau-core/src/main/java/org/testingisdocumenting/webtau/data/traceable/TraceableValue.java

@@ -63,6 +63,10 @@ public void updateCheckLevel(CheckLevel newCheckLevel) {
         }
     }
 
+    public void forceCheckLevel(CheckLevel newCheckLevel) {
+        checkLevel = newCheckLevel;
+    }
+
     public CheckLevel getCheckLevel() {
         return checkLevel;
     }
@@ -122,30 +126,20 @@ private Object convertToStringForPrint(Object value) {
     }
 
     private String printSurroundWith() {
-        switch (getCheckLevel()) {
-            case FuzzyFailed:
-            case ExplicitFailed:
-                return "**";
-            case ExplicitPassed:
-                return "__";
-            case FuzzyPassed:
-                return "~~";
-            default:
-                return "";
-        }
+        return switch (getCheckLevel()) {
+            case FuzzyFailed, ExplicitFailed -> "**";
+            case ExplicitPassed -> "__";
+            case FuzzyPassed -> "~~";
+            default -> "";
+        };
     }
     private Object[] valuePrintStyle() {
-        switch (getCheckLevel()) {
-            case FuzzyFailed:
-            case ExplicitFailed:
-                return FAIL_STYLE;
-            case FuzzyPassed:
-            case ExplicitPassed:
-                return PASS_STYLE;
-            default:
-                return new Color[]{value == null ?
-                        UNKNOWN_COLOR :
-                        TypeUtils.isString(value) ? STRING_COLOR : NUMBER_COLOR};
-        }
+        return switch (getCheckLevel()) {
+            case FuzzyFailed, ExplicitFailed -> FAIL_STYLE;
+            case FuzzyPassed, ExplicitPassed -> PASS_STYLE;
+            default -> new Color[]{value == null ?
+                    UNKNOWN_COLOR :
+                    TypeUtils.isString(value) ? STRING_COLOR : NUMBER_COLOR};
+        };
     }
 }

webtau-docs/znai/release-notes/2.4/add-2024-05-14-http-contain-exactly-markers.md

@@ -0,0 +1 @@
+* Fix: [containExactly](matchers/contain-exactly) in [HTTP](HTTP/introduction) correctly marks passed and failed nodes in the output

webtau-http-groovy/src/test/groovy/org/testingisdocumenting/webtau/http/HttpGroovyTest.groovy

@@ -1047,6 +1047,45 @@ class HttpGroovyTest extends HttpTestBase {
         http.doc.capture("end-point-list-contain-exactly-matchers")
     }
 
+    @Test
+    void "contain exactly objects with single failed"() {
+        code {
+            http.get("/end-point-large-list") {
+                body.should containExactly(
+                        [id: "id3", k1: "v31", k2: "v32"],
+                        [id: "id1", k1: "v11", k2: "v12"],
+                        [id: "id4", k1: "v41", k2: "v42_"],
+                        [id: "id2", k1: "v21", k2: "v22"],
+                )
+            }
+        } should throwException(AssertionError)
+
+        http.doc.capture("end-point-large-list-contain-exactly-matchers-single-failed")
+
+        def body = http.lastValidationResult.bodyNode
+
+        def isPassed = {idx, key ->
+            body.get(idx).get(key).traceableValue.checkLevel.should == CheckLevel.ExplicitPassed
+        }
+
+        def isFailed = {idx, key ->
+            body.get(idx).get(key).traceableValue.checkLevel.should == CheckLevel.ExplicitFailed
+        }
+
+        isPassed(0, "id")
+        isPassed(0, "k1")
+        isPassed(0, "k2")
+        isPassed(1, "id")
+        isPassed(1, "k1")
+        isPassed(1, "k2")
+        isPassed(2, "id")
+        isPassed(2, "k1")
+        isPassed(2, "k2")
+        isPassed(3, "id")
+        isPassed(3, "k1")
+        isFailed(3, "k2")
+    }
+
     @Test
     void "contain containing all matcher"() {
         http.get("/prices") {

webtau-http/src/main/java/org/testingisdocumenting/webtau/http/Http.java

@@ -1066,8 +1066,17 @@ private <R> R validateAndRecord(HttpValidationResult validationResult,
             @Override
             public Flow onValueMismatch(ValueMatcher valueMatcher, ValuePath actualPath, Object actualValue, TokenizedMessage message) {
                 validationResult.addMismatch(new ValuePathMessage(actualPath, () -> message).buildFullMessage());
+
+                // some matchers would try multiple times to match values, and they may be incorrectly marked as failed
+                // we force override all the matched paths from the final matcher result
+                reApplyValuePassBasedOnMatcherPaths(body, valueMatcher.matchedPaths());
                 return ExpectationHandler.Flow.PassToNext;
             }
+
+            @Override
+            public void onValueMatch(ValueMatcher valueMatcher, ValuePath actualPath, Object actualValue) {
+                reApplyValuePassBasedOnMatcherPaths(body, valueMatcher.matchedPaths());
+            }
         };
 
         // 1. validate using user provided validation block
@@ -1180,6 +1189,14 @@ private Integer defaultExpectedStatusCodeByRequest(HttpValidationResult validati
         };
     }
 
+    private static void reApplyValuePassBasedOnMatcherPaths(DataNode node, Set<ValuePath> matchedPaths) {
+        for (ValuePath matchedPath : matchedPaths) {
+            String matchedPathWithoutBodyPrefix = matchedPath.getPath().substring("body".length());
+            DataNode dataNode = ValueExtractorByPath.extractFromDataNode(node, matchedPathWithoutBodyPrefix);
+            dataNode.getTraceableValue().forceCheckLevel(CheckLevel.ExplicitPassed);
+        }
+    }
+
     private HttpResponse request(String method, String fullUrl,
                                  HttpHeader requestHeader,
                                  HttpRequestBody requestBody) {