Fixed #1558 - sub-matchers in matchesJsonPath are now compared against each item in the list of results from the expression rather than just the string rendition except if the sub-matcher is equalToJson, in which case this is still the behaviour we want.

Tom Akehurst · Tom Akehurst · commit 2350bad637b5 · 2021-07-13T17:51:08.000+01:00
diff --git a/src/main/java/com/github/tomakehurst/wiremock/client/WireMock.java b/src/main/java/com/github/tomakehurst/wiremock/client/WireMock.java
@@ -217,6 +217,11 @@ public static StringValuePattern matchingXPath(String value, StringValuePattern
         return new MatchesXPathPattern(value, valuePattern);
     }
 
+    // Use this with the date/time matchers to avoid an explicit cast
+    public static MatchesXPathPattern matchesXPathWithSubMatcher(String value, StringValuePattern valuePattern) {
+	    return new MatchesXPathPattern(value, valuePattern);
+    }
+
     public static StringValuePattern containing(String value) {
         return new ContainsPattern(value);
     }
diff --git a/src/main/java/com/github/tomakehurst/wiremock/matching/MatchesJsonPathPattern.java b/src/main/java/com/github/tomakehurst/wiremock/matching/MatchesJsonPathPattern.java
@@ -18,13 +18,17 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.github.tomakehurst.wiremock.common.Json;
+import com.github.tomakehurst.wiremock.common.ListOrSingle;
 import com.jayway.jsonpath.JsonPath;
 import com.jayway.jsonpath.PathNotFoundException;
 
-import java.util.Collection;
-import java.util.Map;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static com.github.tomakehurst.wiremock.common.LocalNotifier.notifier;
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.toList;
 
 @JsonSerialize(using = JsonPathPatternJsonSerializer.class)
 public class MatchesJsonPathPattern extends PathPattern {
@@ -84,22 +88,25 @@ protected MatchResult isSimpleMatch(String value) {
 
     protected MatchResult isAdvancedMatch(String value) {
         try {
-            String expressionResult = getExpressionResult(value);
+            ListOrSingle<String> expressionResult = getExpressionResult(value);
 
             // Bit of a hack, but otherwise empty array results aren't matched as absent()
-            if ("[ ]".equals(expressionResult) && valuePattern.getClass().isAssignableFrom(AbsentPattern.class)) {
-                expressionResult = null;
+            if ((expressionResult == null || expressionResult.isEmpty()) && AbsentPattern.class.isAssignableFrom(valuePattern.getClass())) {
+                expressionResult = ListOrSingle.of((String) null);
             }
 
-            return valuePattern.match(expressionResult);
+            return expressionResult.stream()
+                    .map(valuePattern::match)
+                    .min(Comparator.comparingDouble(MatchResult::getDistance))
+                    .orElse(MatchResult.noMatch());
         } catch (SubExpressionException e) {
             notifier().info(e.getMessage());
             return MatchResult.noMatch();
         }
     }
 
     @Override
-    public String getExpressionResult(final String value) {
+    public ListOrSingle<String> getExpressionResult(final String value) {
         // For performance reason, don't try to parse XML value
         if (value != null && value.trim().startsWith("<")) {
             final String message = String.format(
@@ -128,13 +135,16 @@ public String getExpressionResult(final String value) {
             throw new SubExpressionException(message, e);
         }
 
-        String expressionResult;
-        if (obj instanceof Number || obj instanceof String || obj instanceof Boolean) {
-            expressionResult = String.valueOf(obj);
-        } else if (obj instanceof Map || obj instanceof Collection) {
-            expressionResult = Json.write(obj);
+        ListOrSingle<String> expressionResult;
+        if (obj instanceof Map || EqualToJsonPattern.class.isAssignableFrom(valuePattern.getClass())) {
+            expressionResult = ListOrSingle.of(Json.write(obj));
+        } else if (obj instanceof List) {
+            final List<String> stringValues = ((List<?>) obj).stream().map(Object::toString).collect(toList());
+            expressionResult = ListOrSingle.of(stringValues);
+        } else if (obj instanceof Number || obj instanceof String || obj instanceof Boolean) {
+            expressionResult = ListOrSingle.of(String.valueOf(obj));
         } else {
-            expressionResult = null;
+            expressionResult = ListOrSingle.of();
         }
 
         return expressionResult;
diff --git a/src/main/java/com/github/tomakehurst/wiremock/matching/MatchesXPathPattern.java b/src/main/java/com/github/tomakehurst/wiremock/matching/MatchesXPathPattern.java
@@ -27,6 +27,7 @@
 import java.util.Comparator;
 import java.util.Map;
 import java.util.SortedSet;
+import java.util.stream.Collectors;
 
 import static com.github.tomakehurst.wiremock.common.LocalNotifier.notifier;
 import static com.google.common.base.MoreObjects.firstNonNull;
@@ -95,24 +96,17 @@ protected MatchResult isAdvancedMatch(String value) {
     }
 
     @Override
-    public String getExpressionResult(String value) {
+    public ListOrSingle<String> getExpressionResult(String value) {
         ListOrSingle<XmlNode> nodeList = findXmlNodes(value);
         if (nodeList == null || nodeList.size() == 0) {
-            return null;
-        }
-
-        SortedSet<Pair<XmlNode, MatchResult>> results = newTreeSet(new Comparator<Pair<XmlNode, MatchResult>>() {
-            @Override
-            public int compare(Pair<XmlNode, MatchResult> one, Pair<XmlNode, MatchResult> two) {
-                return one.b.compareTo(two.b);
-            }
-        });
-
-        for (XmlNode node: nodeList) {
-            results.add(new Pair<>(node, valuePattern.match(node.toString())));
+            return ListOrSingle.of();
         }
 
-        return results.last().a.toString();
+        return ListOrSingle.of(
+                nodeList.stream()
+                .map(XmlNode::toString)
+                .collect(Collectors.toList())
+        );
     }
 
     private ListOrSingle<XmlNode> findXmlNodes(String value) {
diff --git a/src/main/java/com/github/tomakehurst/wiremock/matching/PathPattern.java b/src/main/java/com/github/tomakehurst/wiremock/matching/PathPattern.java
@@ -17,7 +17,9 @@
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.github.tomakehurst.wiremock.common.ListOrSingle;
 
+import java.util.List;
 import java.util.Objects;
 
 public abstract class PathPattern extends StringValuePattern {
@@ -49,7 +51,7 @@ public MatchResult match(String value) {
 
     protected abstract MatchResult isSimpleMatch(String value);
     protected abstract MatchResult isAdvancedMatch(String value);
-    public abstract String getExpressionResult(String value);
+    public abstract ListOrSingle<String> getExpressionResult(String value);
 
     @Override
     public boolean equals(Object o) {
diff --git a/src/main/java/com/github/tomakehurst/wiremock/verification/diff/Diff.java b/src/main/java/com/github/tomakehurst/wiremock/verification/diff/Diff.java
@@ -16,6 +16,7 @@
 package com.github.tomakehurst.wiremock.verification.diff;
 
 import com.github.tomakehurst.wiremock.common.Json;
+import com.github.tomakehurst.wiremock.common.ListOrSingle;
 import com.github.tomakehurst.wiremock.common.Urls;
 import com.github.tomakehurst.wiremock.common.xml.Xml;
 import com.github.tomakehurst.wiremock.http.*;
@@ -248,13 +249,14 @@ private void addBodySection(List<ContentPattern<?>> bodyPatterns, Body body, Imm
                 if (PathPattern.class.isAssignableFrom(pattern.getClass())) {
                     PathPattern pathPattern = (PathPattern) pattern;
                     if (!pathPattern.isSimple()) {
-                        String expressionResult = pathPattern.getExpressionResult(body.asString());
+                        ListOrSingle<String> expressionResult = pathPattern.getExpressionResult(body.asString());
+                        String expressionResultString = expressionResult != null && !expressionResult.isEmpty() ? expressionResult.toString() : null;
                         String printedExpectedValue =
                                 pathPattern.getExpected() +
                                         " [" + pathPattern.getValuePattern().getName() + "] " +
                                         pathPattern.getValuePattern().getExpected();
-                        if (expressionResult != null) {
-                            builder.add(new DiffLine<>("Body", pathPattern.getValuePattern(), expressionResult, printedExpectedValue));
+                        if (expressionResultString != null) {
+                            builder.add(new DiffLine<>("Body", pathPattern.getValuePattern(), expressionResultString, printedExpectedValue));
                         } else {
                             builder.add(new DiffLine<>("Body", pathPattern, formattedBody, printedExpectedValue));
                         }
diff --git a/src/test/java/com/github/tomakehurst/wiremock/matching/MatchesJsonPathPatternTest.java b/src/test/java/com/github/tomakehurst/wiremock/matching/MatchesJsonPathPatternTest.java
@@ -410,6 +410,23 @@ public void treatsAnEmptyArrayExpressionResultAsAbsent() {
         assertTrue(result.isExactMatch());
     }
 
+    @Test
+    public void matchesCorrectlyWhenSubMatcherIsUsedAndExpressionReturnsASingleItemArray() {
+        String json = "{\n" +
+                "   \"searchCriteria\": {\n" +
+                "      \"customerId\": \"104903\",\n" +
+                "      \"date\": \"01/01/2021\"\n" +
+                "   }\n" +
+                "}";
+
+        MatchResult result = matchingJsonPath(
+                "$.searchCriteria[?(@.customerId == '104903')].date",
+                equalToDateTime("2021-01-01T00:00:00").actualFormat("dd/MM/yyyy"))
+            .match(json);
+
+        assertTrue(result.isExactMatch());
+    }
+
     private void expectInfoNotification(final String message) {
         final Notifier notifier = context.mock(Notifier.class);
         context.checking(new Expectations() {{
diff --git a/src/test/java/com/github/tomakehurst/wiremock/matching/MatchesXPathPatternTest.java b/src/test/java/com/github/tomakehurst/wiremock/matching/MatchesXPathPatternTest.java
@@ -182,6 +182,28 @@ public void matchesComplexElementAgainstValuePattern() {
         assertThat(pattern.match(xml).isExactMatch(), is(true));
     }
 
+    @Test
+    public void matchesCorrectlyWhenSubMatcherIsDateEquality() {
+        String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
+                "<soapenv:Envelope>\n" +
+                "    <soapenv:Body>\n" +
+                "        <Retrieve>\n" +
+                "            <Policy>\n" +
+                "                <EffectiveDate Val=\"01/01/2021\" />\n" +
+                "                <Policy Val=\"ABC123\" />\n" +
+                "            </Policy>\n" +
+                "        </Retrieve>\n" +
+                "    </soapenv:Body>\n" +
+                "</soapenv:Envelope>";
+
+        StringValuePattern pattern = WireMock.matchesXPathWithSubMatcher(
+                "//*[local-name() = 'EffectiveDate']/@Val",
+                equalToDateTime("2021-01-01T00:00:00").actualFormat("dd/MM/yyyy")
+        );
+
+        assertThat(pattern.match(xml).isExactMatch(), is(true));
+    }
+
     @Test
     public void deserialisesCorrectlyWithoutNamespaces() {
         String json = "{ \"matchesXPath\" : \"/stuff:outer/stuff:inner[.=111]\" }";

Original file line number	Diff line number	Diff line change
`@@ -217,6 +217,11 @@ public static StringValuePattern matchingXPath(String value, StringValuePattern`
`217`	`217`	`return new MatchesXPathPattern(value, valuePattern);`
`218`	`218`	`}`
`219`	`219`
	`220`	`+ // Use this with the date/time matchers to avoid an explicit cast`
	`221`	`+ public static MatchesXPathPattern matchesXPathWithSubMatcher(String value, StringValuePattern valuePattern) {`
	`222`	`+ return new MatchesXPathPattern(value, valuePattern);`
	`223`	`+ }`
	`224`	`+`
`220`	`225`	`public static StringValuePattern containing(String value) {`
`221`	`226`	`return new ContainsPattern(value);`
`222`	`227`	`}`