Fix hasContext matcher with property/list in logical operator

Author: dirkbolte

src/main/java/org/wiremock/extensions/state/extensions/requestmatcher/StateRequestMatcher.java

@@ -109,31 +109,31 @@ public MatchResult match(Request request, Parameters parameters) {
             if (validationMessage != null) {
                 throw createConfigurationError(validationMessage);
             }
-            return matchContext(model, parameters, matcher);
+            return matchContext(model, matcher);
 
         } catch (IllegalArgumentException ex) {
             throw createConfigurationError("You have to specify 'hasContext' or 'hasNotContext'");
         }
     }
 
-    private MatchResult matchContext(Map<String, Object> model, Parameters parameters, BaseRequestMatcher matcher) {
+    private MatchResult matchContext(Map<String, Object> model, BaseRequestMatcher matcher) {
         if (matcher instanceof BaseContextMatcher) {
-            return matchContext(model, parameters, (BaseContextMatcher) matcher);
+            return matchContext(model, (BaseContextMatcher) matcher);
         } else if (matcher instanceof Not) {
-            var matchResult = matchContext(model, parameters, ((Not) matcher).getBaseRequestMatcher());
+            var matchResult = matchContext(model, ((Not) matcher).getBaseRequestMatcher());
             return MatchResult.partialMatch(1.0 - matchResult.getDistance());
         } else if (matcher instanceof And) {
             var containedMatcher = ((And) matcher).getBaseRequestMatcher();
             var matchResults = containedMatcher
                 .stream()
-                .map(it -> matchContext(model, parameters, it))
+                .map(it -> matchContext(model, it))
                 .collect(Collectors.toList());
             return MatchResult.aggregate(matchResults);
         } else if (matcher instanceof Or) {
             var containedMatcher = ((Or) matcher).getBaseRequestMatcher();
             var matchResults = containedMatcher
                 .stream()
-                .map(it -> matchContext(model, parameters, it))
+                .map(it -> matchContext(model, it))
                 .filter(MatchResult::isExactMatch)
                 .collect(Collectors.toList());
             return matchResults.stream().findFirst().orElseGet(MatchResult::noMatch);
@@ -142,10 +142,10 @@ private MatchResult matchContext(Map<String, Object> model, Parameters parameter
         }
     }
 
-    private MatchResult matchContext(Map<String, Object> model, Parameters parameters, BaseContextMatcher matcher) {
+    private MatchResult matchContext(Map<String, Object> model, BaseContextMatcher matcher) {
         var template = matcher.getContextTemplate();
         if (matcher instanceof HasContext) {
-            return hasContext(model, parameters, template);
+            return hasContext(model, matcher.unmappedFields(), template);
         } else if (matcher instanceof HasNotContext) {
             return hasNotContext(model, template);
         } else {
@@ -162,7 +162,7 @@ private MatchResult hasContext(Map<String, Object> model, Parameters parameters,
                     logger().info(context, "hasContext matched");
                     return MatchResult.exactMatch();
                 } else {
-                    return calculateMatch(model, context, matchers);
+                     return calculateMatch(model, context, matchers);
                 }
             }).orElseGet(MatchResult::noMatch);
     }

src/main/java/org/wiremock/extensions/state/extensions/requestmatcher/model/BaseContextMatcher.java

@@ -1,6 +1,14 @@
 package org.wiremock.extensions.state.extensions.requestmatcher.model;
 
+import com.github.tomakehurst.wiremock.extension.Parameters;
+
+import java.util.Map;
+
 public interface BaseContextMatcher {
     String getContextTemplate();
 
+    default Parameters unmappedFields() {
+        return Parameters.empty();
+    }
+
 }

src/main/java/org/wiremock/extensions/state/extensions/requestmatcher/model/HasContext.java

@@ -1,27 +1,40 @@
 package org.wiremock.extensions.state.extensions.requestmatcher.model;
 
+import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.github.tomakehurst.wiremock.extension.Parameters;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class HasContext implements BaseRequestMatcher, BaseContextMatcher {
     private final String contextTemplate;
+    private final Parameters unmappedFields = Parameters.empty();
 
     public HasContext(@JsonProperty("hasContext") String contextTemplate) {
         this.contextTemplate = contextTemplate;
     }
 
+    @JsonAnySetter
+    public void setUnmappedField(String key, Object value) {
+        unmappedFields.put(key, value);
+    }
+
     @Override
     public String getContextTemplate() {
         return contextTemplate;
     }
 
     @Override
     public String assertValid() {
-        if(contextTemplate == null) {
+        if (contextTemplate == null) {
             return "'hasContext' must be specified";
         } else {
             return null;
         }
     }
+
+    @Override
+    public Parameters unmappedFields() {
+        return unmappedFields;
+    }
 }

src/test/java/org/wiremock/extensions/state/functionality/StateRequestMatcherTest.java

@@ -358,6 +358,17 @@ void test_onePositive_oneNegative_fail() {
 
             getAndAssertContextMatcher(context, HttpStatus.SC_NOT_FOUND);
         }
+
+        @DisplayName("fails when all matcher with nested property matcher fail")
+        @Test
+        void test_allNegative_property_matcher_fail() {
+            var context = postAndAssertContextValue("a context value");
+
+            createGetStub(Map.of("or", List.of(Map.of("hasNotContext", context), Map.of("hasContext", context, "property", Map.of("contextValue", Map.of("equalTo", "another context value"))))));
+
+            getAndAssertContextMatcher(context, HttpStatus.SC_NOT_FOUND);
+        }
+
     }
 
     @DisplayName("with matcher 'or'")
@@ -379,6 +390,16 @@ void test_onePositive_oneNegative_ok() {
             getAndAssertContextMatcher(context, HttpStatus.SC_OK);
         }
 
+        @DisplayName("succeeds when one matcher's nested property matcher succeeds")
+        @Test
+        void test_onePositive_oneNegative_property_matcher_ok() {
+            var context = postAndAssertContextValue("a context value");
+
+            createGetStub(Map.of("or", List.of(Map.of("hasContext", context, "property", Map.of("stateValue", Map.of("equalTo", "a context value"))), Map.of("hasContext", randomAlphabetic(5)))));
+
+            getAndAssertContextMatcher(context, HttpStatus.SC_OK);
+        }
+
         @DisplayName("succeeds when nested matchers succeed")
         @Test
         void test_nestedMatchers_ok() {
@@ -394,7 +415,17 @@ void test_nestedMatchers_ok() {
         void test_allNegative_fail() {
             var context = postAndAssertContextValue(randomAlphabetic(5));
 
-            createGetStub(Map.of("and", List.of(Map.of("hasNotContext", context), Map.of("hasContext", randomAlphabetic(5)))));
+            createGetStub(Map.of("or", List.of(Map.of("hasNotContext", context), Map.of("hasContext", randomAlphabetic(5)))));
+
+            getAndAssertContextMatcher(context, HttpStatus.SC_NOT_FOUND);
+        }
+
+        @DisplayName("fails when all matcher with nested property matcher fail")
+        @Test
+        void test_allNegative_property_matcher_fail() {
+            var context = postAndAssertContextValue("a context value");
+
+            createGetStub(Map.of("or", List.of(Map.of("hasNotContext", context), Map.of("hasContext", context, "property", Map.of("stateValue", Map.of("equalTo", "another context value"))))));
 
             getAndAssertContextMatcher(context, HttpStatus.SC_NOT_FOUND);
         }