Adding matcher for property existence/non-existence (#42)

dirkbolte · web-flow · commit 29f0ebc588d8 · 2023-09-02T22:26:09.000+02:00
- corrected handling of all matchers using numbers: a non-numeric value will now result in a non-match (no error logs will be posted as they might be plenty based on the stubs that are configured)  ## References - TODO  ## Submitter checklist - [ ] Recommended: Join [WireMock Slack](https://slack.wiremock.org/) to get any help in `#help-contributing` or a project-specific channel like `#wiremock-java` - [ ] The PR request is well described and justified, including the body and the references - [ ] The PR title represents the desired changelog entry - [ ] The repository's code style is followed (see the contributing guide) - [ ] Test coverage that demonstrates that the change works as expected - [ ] For new features, there's necessary documentation in this pull request or in a subsequent PR to [wiremock.org](https://github.com/wiremock/wiremock.org)
diff --git a/README.md b/README.md
@@ -617,6 +617,36 @@ behavior for requests with and without a matching context. The parameter support
 }
 ```
 
+### Property existence match
+
+In addition to the existence of a context, you can check for the existence or absence of a property
+within that context. The following matchers are available:
+
+- `hasProperty`
+- `hasNotProperty`
+
+As for other matchers, templating is supported.
+
+```json
+{
+  "request": {
+    "method": "GET",
+    "urlPattern": "/test/[^\/]+/[^\/]+",
+    "customMatcher": {
+      "name": "state-matcher",
+      "parameters": {
+        "hasContext": "{{request.pathSegments.[1]}}",
+        "hasProperty": "{{request.pathSegments.[2]}}"
+      }
+    }
+  },
+  "response": {
+    "status": 200
+  }
+}
+```
+
+
 ### Context update count match
 
 Whenever the serve event listener `recordState` is processed, the internal context update counter is increased. The number can be used
@@ -626,7 +656,7 @@ for request matching as well. The following matchers are available:
 - `updateCountLessThan`
 - `updateCountMoreThan`
 
-As for other matchers, templating is supported.
+As for other matchers, templating is supported. In case the provided value for this check is not numeric, it is handled as non-matching. No error will be reported or logged.
 
 ```json
 {
@@ -656,7 +686,7 @@ for request matching as well. The following matchers are available:
 - `listSizeLessThan`
 - `listSizeMoreThan`
 
-As for other matchers, templating is supported.
+As for other matchers, templating is supported. In case the provided value for this check is not numeric, it is handled as non-matching. No error will be reported or logged.
 
 ```json
 {
diff --git a/src/main/java/org/wiremock/extensions/state/extensions/StateRequestMatcher.java b/src/main/java/org/wiremock/extensions/state/extensions/StateRequestMatcher.java
@@ -34,6 +34,8 @@
 import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
+import static com.github.tomakehurst.wiremock.common.LocalNotifier.notifier;
+
 /**
  * Request matcher for state.
  * <p>
@@ -51,12 +53,12 @@ public StateRequestMatcher(ContextManager contextManager, TemplateEngine templat
         this.templateEngine = templateEngine;
     }
 
-    private static List<Map.Entry<CountMatcher, Object>> getMatches(Parameters parameters) {
+    private static List<Map.Entry<ContextMatcher, Object>> getMatches(Parameters parameters) {
         return parameters
             .entrySet()
             .stream()
-            .filter(it -> CountMatcher.from(it.getKey()) != null)
-            .map(it -> Map.entry(CountMatcher.from(it.getKey()), it.getValue()))
+            .filter(it -> ContextMatcher.from(it.getKey()) != null)
+            .map(it -> Map.entry(ContextMatcher.from(it.getKey()), it.getValue()))
             .collect(Collectors.toUnmodifiableList());
     }
 
@@ -78,7 +80,7 @@ public MatchResult match(Request request, Parameters parameters) {
     private MatchResult hasContext(Map<String, Object> model, Parameters parameters, String template) {
         return contextManager.getContext(renderTemplate(model, template))
             .map(context -> {
-                List<Map.Entry<CountMatcher, Object>> matchers = getMatches(parameters);
+                List<Map.Entry<ContextMatcher, Object>> matchers = getMatches(parameters);
                 if (matchers.isEmpty()) {
                     return MatchResult.exactMatch();
                 } else {
@@ -87,11 +89,11 @@ private MatchResult hasContext(Map<String, Object> model, Parameters parameters,
             }).orElseGet(MatchResult::noMatch);
     }
 
-    private MatchResult calculateMatch(Map<String, Object> model, Context context, List<Map.Entry<CountMatcher, Object>> matchers) {
+    private MatchResult calculateMatch(Map<String, Object> model, Context context, List<Map.Entry<ContextMatcher, Object>> matchers) {
         model.put("context", ContextTemplateModel.from(context));
         var result = matchers
             .stream()
-            .map(it -> it.getKey().evaluate(context, Long.valueOf(renderTemplate(model, it.getValue().toString()))))
+            .map(it -> it.getKey().evaluate(context, renderTemplate(model, it.getValue().toString())))
             .filter(it -> !it)
             .count();
 
@@ -111,26 +113,40 @@ String renderTemplate(Object context, String value) {
         return templateEngine.getUncachedTemplate(value).apply(context);
     }
 
-    private enum CountMatcher {
-        updateCountEqualTo((Context context, Long value) -> context.getUpdateCount().equals(value)),
-        updateCountLessThan((Context context, Long value) -> context.getUpdateCount() < value),
-        updateCountMoreThan((Context context, Long value) -> context.getUpdateCount() > value),
-        listSizeEqualTo((Context context, Long value) -> context.getList().size() == value),
-        listSizeLessThan((Context context, Long value) -> context.getList().size() < value),
-        listSizeMoreThan((Context context, Long value) -> context.getList().size() > value);
+    private enum ContextMatcher {
+
+        hasProperty((Context c, String stringValue) -> c.getProperties().containsKey(stringValue)),
+        hasNotProperty((Context c, String stringValue) -> !c.getProperties().containsKey(stringValue)),
+        updateCountEqualTo((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getUpdateCount().equals(value))),
+        updateCountLessThan((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getUpdateCount() < value)),
+        updateCountMoreThan((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getUpdateCount() > value)),
+        listSizeEqualTo((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getList().size() == value)),
+        listSizeLessThan((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getList().size() < value)),
+        listSizeMoreThan((Context c, String stringValue) -> withConvertedNumber(c, stringValue, (context, value) -> context.getList().size() > value));
 
-        private final BiFunction<Context, Long, Boolean> evaluator;
+        private final BiFunction<Context, String, Boolean> evaluator;
 
-        CountMatcher(BiFunction<Context, Long, Boolean> evaluator) {
+        ContextMatcher(BiFunction<Context, String, Boolean> evaluator) {
             this.evaluator = evaluator;
         }
 
-        public static CountMatcher from(String from) {
+        public static ContextMatcher from(String from) {
             return Arrays.stream(values()).filter(it -> it.name().equals(from)).findFirst().orElse(null);
         }
 
-        public boolean evaluate(Context context, Long value) {
+        private static boolean withConvertedNumber(Context context, String stringValue, BiFunction<Context, Long, Boolean> evaluator) {
+            try {
+                var longValue = Long.valueOf(stringValue);
+                return evaluator.apply(context, longValue);
+            } catch (NumberFormatException ex) {
+                return false;
+            }
+
+        }
+
+        public boolean evaluate(Context context, String value) {
             return this.evaluator.apply(context, value);
         }
+
     }
 }
diff --git a/src/main/java/org/wiremock/extensions/state/internal/StateRequestMatcherParameters.java b/src/main/java/org/wiremock/extensions/state/internal/StateRequestMatcherParameters.java
@@ -0,0 +1,80 @@
+package org.wiremock.extensions.state.internal;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class StateRequestMatcherParameters {
+    String hasContext;
+
+    String hasNotContext;
+    String updateCountEqualTo;
+    String updateCountLessThan;
+    String updateCountMoreThan;
+    String listSizeEqualTo;
+    String listSizeLessThan;
+    String listSizeMoreThan;
+
+    public String getHasNotContext() {
+        return hasNotContext;
+    }
+
+    public void setHasNotContext(String hasNotContext) {
+        this.hasNotContext = hasNotContext;
+    }
+
+    public String getHasContext() {
+        return hasContext;
+    }
+
+    public void setHasContext(String hasContext) {
+        this.hasContext = hasContext;
+    }
+
+    public String getUpdateCountEqualTo() {
+        return updateCountEqualTo;
+    }
+
+    public void setUpdateCountEqualTo(String updateCountEqualTo) {
+        this.updateCountEqualTo = updateCountEqualTo;
+    }
+
+    public String getUpdateCountLessThan() {
+        return updateCountLessThan;
+    }
+
+    public void setUpdateCountLessThan(String updateCountLessThan) {
+        this.updateCountLessThan = updateCountLessThan;
+    }
+
+    public String getUpdateCountMoreThan() {
+        return updateCountMoreThan;
+    }
+
+    public void setUpdateCountMoreThan(String updateCountMoreThan) {
+        this.updateCountMoreThan = updateCountMoreThan;
+    }
+
+    public String getListSizeEqualTo() {
+        return listSizeEqualTo;
+    }
+
+    public void setListSizeEqualTo(String listSizeEqualTo) {
+        this.listSizeEqualTo = listSizeEqualTo;
+    }
+
+    public String getListSizeLessThan() {
+        return listSizeLessThan;
+    }
+
+    public void setListSizeLessThan(String listSizeLessThan) {
+        this.listSizeLessThan = listSizeLessThan;
+    }
+
+    public String getListSizeMoreThan() {
+        return listSizeMoreThan;
+    }
+
+    public void setListSizeMoreThan(String listSizeMoreThan) {
+        this.listSizeMoreThan = listSizeMoreThan;
+    }
+}
diff --git a/src/test/java/org/wiremock/extensions/state/functionality/StateRequestMatcherTest.java b/src/test/java/org/wiremock/extensions/state/functionality/StateRequestMatcherTest.java
