fix: various custom operator conformance fixes (#1778)

toddbaert · web-flow · commit cced215af4ec · 2026-04-30T17:01:46.000-04:00
Signed-off-by: Todd Baert &lt;todd.baert@dynatrace.com&gt;
diff --git a/.gitmodules b/.gitmodules
@@ -4,7 +4,6 @@
 [submodule "providers/flagd/test-harness"]
 	path = providers/flagd/test-harness
 	url = https://github.com/open-feature/test-harness.git
-	branch = v3.5.0
 [submodule "providers/flagd/spec"]
 	path = providers/flagd/spec
 	url = https://github.com/open-feature/spec.git
@@ -17,4 +16,3 @@
 [submodule "tools/flagd-api-testkit/test-harness"]
 	path = tools/flagd-api-testkit/test-harness
 	url = https://github.com/open-feature/test-harness.git
-	branch = v3.5.0
diff --git a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunFileTest.java b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunFileTest.java
@@ -36,8 +36,7 @@
     "events",
     "contextEnrichment",
     "fractional-v1",
-    "deprecated",
-    "operator-errors"
+    "deprecated"
 })
 @Testcontainers
 public class RunFileTest {
diff --git a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunInProcessTest.java b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunInProcessTest.java
@@ -28,7 +28,7 @@
 @ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "dev.openfeature.contrib.providers.flagd.e2e.steps")
 @ConfigurationParameter(key = OBJECT_FACTORY_PROPERTY_NAME, value = "io.cucumber.picocontainer.PicoFactory")
 @IncludeTags("in-process")
-@ExcludeTags({"unixsocket", "fractional-v1", "deprecated", "operator-errors"})
+@ExcludeTags({"unixsocket", "fractional-v1", "deprecated"})
 @Testcontainers
 public class RunInProcessTest {
 
diff --git a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunRpcTest.java b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunRpcTest.java
@@ -28,7 +28,7 @@
 @ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "dev.openfeature.contrib.providers.flagd.e2e.steps")
 @ConfigurationParameter(key = OBJECT_FACTORY_PROPERTY_NAME, value = "io.cucumber.picocontainer.PicoFactory")
 @IncludeTags({"rpc"})
-@ExcludeTags({"unixsocket", "fractional-v1", "deprecated", "operator-errors"})
+@ExcludeTags({"unixsocket", "fractional-v1", "deprecated"})
 @Testcontainers
 public class RunRpcTest {
 
diff --git a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ContextSteps.java b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ContextSteps.java
@@ -18,7 +18,28 @@ public ContextSteps(State state) {
     public void a_context_containing_a_key_with_type_and_with_value(String key, String type, String value)
             throws ClassNotFoundException, InstantiationException {
         Map<String, Value> map = state.context.asMap();
-        map.put(key, new Value(value));
+        Value typedValue;
+        switch (type) {
+            case "Integer":
+                long longVal = Long.parseLong(value);
+                if (longVal >= Integer.MIN_VALUE && longVal <= Integer.MAX_VALUE) {
+                    typedValue = new Value((int) longVal);
+                } else {
+                    // value exceeds int range; store as string to preserve precision
+                    typedValue = new Value(value);
+                }
+                break;
+            case "Float":
+                typedValue = new Value(Double.parseDouble(value));
+                break;
+            case "Boolean":
+                typedValue = new Value(Boolean.parseBoolean(value));
+                break;
+            default:
+                typedValue = new Value(value);
+                break;
+        }
+        map.put(key, typedValue);
         state.context = new MutableContext(state.context.getTargetingKey(), map);
     }
 
diff --git a/providers/flagd/test-harness b/providers/flagd/test-harness
@@ -1 +1 @@
-Subproject commit ff2fbe6c6584953cb2753ae9188d1cee14f7f57f
+Subproject commit b507289c45fca9c2d312c7231929e5b95eae62bb
diff --git a/tools/flagd-api-testkit/test-harness b/tools/flagd-api-testkit/test-harness
@@ -1 +1 @@
-Subproject commit ff2fbe6c6584953cb2753ae9188d1cee14f7f57f
+Subproject commit b507289c45fca9c2d312c7231929e5b95eae62bb
diff --git a/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/model/FlagParser.java b/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/model/FlagParser.java
@@ -16,7 +16,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 
@@ -28,7 +27,6 @@ public class FlagParser {
     private static final String FLAG_KEY = "flags";
     private static final String METADATA_KEY = "metadata";
     private static final String EVALUATOR_KEY = "$evaluators";
-    private static final String REPLACER_FORMAT = "\"\\$ref\":(\\s)*\"%s\"";
     private static final ObjectMapper MAPPER = new ObjectMapper();
     private static JsonSchema SCHEMA_VALIDATOR;
 
@@ -116,32 +114,23 @@ private static Map<String, Object> parseMetadata(TreeNode metadataNode) throws J
 
     private static String transposeEvaluators(final String configuration) throws IOException {
         try (JsonParser parser = MAPPER.createParser(configuration)) {
-            final Map<String, Pattern> patternMap = new HashMap<>();
             final TreeNode treeNode = parser.readValueAsTree();
             final TreeNode evaluators = treeNode.get(EVALUATOR_KEY);
 
             if (evaluators == null || evaluators.size() == 0) {
                 return configuration;
             }
 
-            String replacedConfigurations = configuration;
+            // round-trip to normalize whitespace so we can use plain string matching
+            String replacedConfigurations = MAPPER.writeValueAsString(MAPPER.readTree(configuration));
             final Iterator<String> evalFields = evaluators.fieldNames();
 
             while (evalFields.hasNext()) {
                 final String evalName = evalFields.next();
-                // first replace outmost brackets
                 final String evaluator = evaluators.get(evalName).toString();
-                final String replacer = evaluator.substring(1, evaluator.length() - 1);
+                final String refPattern = "{\"$ref\":\"" + evalName + "\"}";
 
-                final String replacePattern = String.format(REPLACER_FORMAT, evalName);
-
-                // then derive pattern
-                final Pattern regReplace =
-                        patternMap.computeIfAbsent(replacePattern, s -> Pattern.compile(replacePattern));
-
-                // finally replace all references
-                replacedConfigurations =
-                        regReplace.matcher(replacedConfigurations).replaceAll(replacer);
+                replacedConfigurations = replacedConfigurations.replace(refPattern, evaluator);
             }
 
             return replacedConfigurations;
diff --git a/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/targeting/Fractional.java b/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/targeting/Fractional.java
@@ -5,7 +5,6 @@
 import io.github.jamsesso.jsonlogic.evaluator.expressions.PreEvaluatedArgumentsExpression;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
@@ -25,33 +24,38 @@ public String key() {
     }
 
     @Override
+    @SuppressWarnings("unchecked") // json-logic-java's PreEvaluatedArgumentsExpression uses raw List
     public Object evaluate(List arguments, Object data, String jsonPath) throws JsonLogicEvaluationException {
         if (arguments.size() < 1) {
             return null;
         }
 
         final Operator.FlagProperties properties = new Operator.FlagProperties(data);
 
-        // check optional string target in first arg
-        Object arg1 = arguments.get(0);
-
         final String bucketBy;
-        final Object[] distributions;
+        final List<Object> distributions;
 
-        if (arg1 instanceof String) {
+        // json-logic pre-evaluation flattens a single-entry fractional
+        // e.g. [["single",1]] becomes ["single", 1]; detect and re-wrap
+        if (isFlattened(arguments)) {
+            if (properties.getTargetingKey() == null) {
+                log.debug("Missing fallback targeting key");
+                return null;
+            }
+            bucketBy = properties.getFlagKey() + properties.getTargetingKey();
+            distributions = List.of(arguments);
+        } else if (arguments.get(0) instanceof String) {
             // first arg is a String, use for bucketing
-            bucketBy = (String) arg1;
-            Object[] source = arguments.toArray();
-            distributions = Arrays.copyOfRange(source, 1, source.length);
+            bucketBy = (String) arguments.get(0);
+            distributions = arguments.subList(1, arguments.size());
         } else {
             // fallback to targeting key if present
             if (properties.getTargetingKey() == null) {
                 log.debug("Missing fallback targeting key");
                 return null;
             }
-
             bucketBy = properties.getFlagKey() + properties.getTargetingKey();
-            distributions = arguments.toArray();
+            distributions = arguments;
         }
 
         final List<FractionProperty> propertyList = new ArrayList<>();
@@ -93,6 +97,19 @@ private static Object distributeValue(
         return distributeValueFromHash(mmrHash, propertyList, totalWeight, jsonPath);
     }
 
+    /**
+     * Checks if arguments have been flattened by json-logic pre-evaluation.
+     * A flattened list contains no List elements (e.g. ["single", 1] instead of [["single", 1]]).
+     */
+    private static boolean isFlattened(List<?> arguments) {
+        for (Object arg : arguments) {
+            if (arg instanceof List) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     static Object distributeValueFromHash(
             final int hash, final List<FractionProperty> propertyList, final int totalWeight, final String jsonPath)
             throws JsonLogicEvaluationException {
diff --git a/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/targeting/SemVer.java b/tools/flagd-core/src/main/java/dev/openfeature/contrib/tools/flagd/core/targeting/SemVer.java
@@ -49,17 +49,25 @@ public Object evaluate(List arguments, Object data, String jsonPath) throws Json
             return null;
         }
 
-        for (int i = 0; i < 3; i++) {
-            if (!(arguments.get(i) instanceof String)) {
-                log.debug("Invalid argument type. Require Strings");
-                return null;
-            }
+        // arg 1 and arg 3 must be strings or numbers (coerced to string)
+        // arg 2 must be a string (operator)
+        final String arg1Str = coerceToString(arguments.get(0));
+        final String arg3Str = coerceToString(arguments.get(2));
+
+        if (arg1Str == null || arg3Str == null) {
+            log.debug("Arguments 1 and 3 must be strings or numbers");
+            return null;
+        }
+
+        if (!(arguments.get(1) instanceof String)) {
+            log.debug("Argument 2 (operator) must be a string");
+            return null;
         }
 
         // arg 1 should be a SemVer
         final Semver arg1Parsed;
 
-        if ((arg1Parsed = Semver.parse((String) arguments.get(0))) == null) {
+        if ((arg1Parsed = normalizeVersion(arg1Str)) == null) {
             log.debug("Argument one is not a valid SemVer");
             return null;
         }
@@ -75,14 +83,58 @@ public Object evaluate(List arguments, Object data, String jsonPath) throws Json
         // arg 3 should be a SemVer
         final Semver arg3Parsed;
 
-        if ((arg3Parsed = Semver.parse((String) arguments.get(2))) == null) {
+        if ((arg3Parsed = normalizeVersion(arg3Str)) == null) {
             log.debug("Argument three is not a valid SemVer");
             return null;
         }
 
         return compare(arg2Parsed, arg1Parsed, arg3Parsed, jsonPath);
     }
 
+    /**
+     * Coerce a value to a string representation suitable for semver parsing.
+     */
+    private static String coerceToString(Object value) {
+        if (value instanceof String) {
+            return (String) value;
+        }
+        if (value instanceof Number) {
+            Number num = (Number) value;
+            double dub = num.doubleValue();
+            if (dub == Math.floor(dub) && !Double.isInfinite(dub)) {
+                return String.valueOf(num.longValue());
+            }
+            return String.valueOf(dub);
+        }
+        return null;
+    }
+
+    /**
+     * Parse a semver string, handling v-prefix (case-insensitive) and partial versions.
+     */
+    private static Semver normalizeVersion(String version) {
+        // strip v/V prefix
+        String stripped = version;
+        if (stripped.startsWith("v") || stripped.startsWith("V")) {
+            stripped = stripped.substring(1);
+        }
+
+        // try strict parse first
+        Semver result = Semver.parse(stripped);
+        if (result != null) {
+            return result;
+        }
+
+        // fall back to coerce for partial versions (fewer than 2 dots)
+        // do not coerce strings that have too many parts (e.g. "2.0.0.0")
+        long dotCount = stripped.chars().filter(c -> c == '.').count();
+        if (dotCount < 2) {
+            return Semver.coerce(stripped);
+        }
+
+        return null;
+    }
+
     private static boolean compare(final String operator, final Semver arg1, final Semver arg2, final String jsonPath)
             throws JsonLogicEvaluationException {
 
diff --git a/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/e2e/FlagdCoreEvaluatorTest.java b/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/e2e/FlagdCoreEvaluatorTest.java
@@ -11,7 +11,7 @@
  * configuration. Registered as an {@link dev.openfeature.contrib.tools.flagd.api.testkit.EvaluatorFactory}
  * via {@code META-INF/services}.
  */
-@ExcludeTags({"fractional-v1"})
+@ExcludeTags({"fractional-v1", "evaluator-refs-whitespace", "non-existent-evaluator-ref"})
 public class FlagdCoreEvaluatorTest extends AbstractEvaluatorTest {
 
     @Override
diff --git a/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/FractionalTest.java b/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/FractionalTest.java
@@ -4,6 +4,7 @@
 import static dev.openfeature.contrib.tools.flagd.core.targeting.Operator.FLAG_KEY;
 import static dev.openfeature.contrib.tools.flagd.core.targeting.Operator.TARGET_KEY;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Named.named;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 
@@ -19,6 +20,7 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.converter.ArgumentConversionException;
 import org.junit.jupiter.params.converter.ConvertWith;
@@ -80,4 +82,72 @@ static class TestData {
         @JsonProperty("rule")
         List<Object> rule;
     }
+
+    @Test
+    void missingBucketKeyReturnsNull() throws JsonLogicEvaluationException {
+        // no targeting key in data; bucket key var resolves to null
+        Fractional fractional = new Fractional();
+
+        Map<String, Object> data = new HashMap<>();
+        Map<String, String> flagdProperties = new HashMap<>();
+        flagdProperties.put(FLAG_KEY, "flagA");
+        data.put(FLAGD_PROPS_KEY, flagdProperties);
+        // no TARGET_KEY set
+
+        List<Object> rule = List.of(
+                // bucket key is a null var result (simulated by being a non-string, non-list)
+                List.of("one", 50), List.of("two", 50));
+
+        // bucketing key is null, so fractional falls back to flagKey + targetingKey
+        // but targetingKey is null, so it should return null
+        assertNull(fractional.evaluate(rule, data, "path"));
+    }
+
+    @Test
+    void singleEntryFractionalWithNonStringVariant() throws JsonLogicEvaluationException {
+        // simulates pre-evaluation flattening of [[100, 1]] -> [100, 1]
+        Fractional fractional = new Fractional();
+
+        Map<String, Object> data = new HashMap<>();
+        data.put(TARGET_KEY, "user");
+        Map<String, String> flagdProperties = new HashMap<>();
+        flagdProperties.put(FLAG_KEY, "flagA");
+        data.put(FLAGD_PROPS_KEY, flagdProperties);
+
+        List<Object> rule = List.of(100, 1);
+
+        assertEquals(100, fractional.evaluate(rule, data, "path"));
+    }
+
+    @Test
+    void singleEntryFractionalWithStringVariant() throws JsonLogicEvaluationException {
+        // simulates pre-evaluation flattening of [["single", 1]] -> ["single", 1]
+        // "single" looks like a bucketing key but is actually the variant
+        Fractional fractional = new Fractional();
+
+        Map<String, Object> data = new HashMap<>();
+        data.put(TARGET_KEY, "user");
+        Map<String, String> flagdProperties = new HashMap<>();
+        flagdProperties.put(FLAG_KEY, "flagA");
+        data.put(FLAGD_PROPS_KEY, flagdProperties);
+
+        List<Object> rule = List.of("single", 1);
+
+        assertEquals("single", fractional.evaluate(rule, data, "path"));
+    }
+
+    @Test
+    void zeroWeightsReturnsNull() throws JsonLogicEvaluationException {
+        Fractional fractional = new Fractional();
+
+        Map<String, Object> data = new HashMap<>();
+        data.put(TARGET_KEY, "user");
+        Map<String, String> flagdProperties = new HashMap<>();
+        flagdProperties.put(FLAG_KEY, "flagA");
+        data.put(FLAGD_PROPS_KEY, flagdProperties);
+
+        List<Object> rule = List.of(List.of("one", 0), List.of("two", 0));
+
+        assertNull(fractional.evaluate(rule, data, "path"));
+    }
 }
diff --git a/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/SemVerTest.java b/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/SemVerTest.java
diff --git a/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/StringCompTest.java b/tools/flagd-core/src/test/java/dev/openfeature/contrib/tools/flagd/core/targeting/StringCompTest.java
