test: improve gherkin test suite only relying on the newest version, with data loading

pom.xml

@@ -168,6 +168,20 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.19.2</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>dev.cel</groupId>
+            <artifactId>cel</artifactId>
+            <version>0.10.1</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <dependencyManagement>

src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java

@@ -138,11 +138,21 @@ private <T> ProviderEvaluation<T> getEvaluation(
         }
         Flag<?> flag = flags.get(key);
         if (flag == null) {
-            throw new FlagNotFoundError("flag " + key + "not found");
+            throw new FlagNotFoundError("flag " + key + " not found");
         }
         T value;
+        Reason reason = Reason.STATIC;
         if (flag.getContextEvaluator() != null) {
-            value = (T) flag.getContextEvaluator().evaluate(flag, evaluationContext);
+            try {
+                value = (T) flag.getContextEvaluator().evaluate(flag, evaluationContext);
+                reason = Reason.TARGETING_MATCH;
+            } catch (Exception e) {
+                value = null;
+            }
+            if (value == null) {
+                value = (T) flag.getVariants().get(flag.getDefaultVariant());
+                reason = Reason.DEFAULT;
+            }
         } else if (!expectedType.isInstance(flag.getVariants().get(flag.getDefaultVariant()))) {
             throw new TypeMismatchError("flag " + key + "is not of expected type");
         } else {
@@ -151,7 +161,7 @@ private <T> ProviderEvaluation<T> getEvaluation(
         return ProviderEvaluation.<T>builder()
                 .value(value)
                 .variant(flag.getDefaultVariant())
-                .reason(Reason.STATIC.toString())
+                .reason(reason.toString())
                 .flagMetadata(flag.getFlagMetadata())
                 .build();
     }

src/test/java/dev/openfeature/sdk/e2e/EvaluationTest.java → src/test/java/dev/openfeature/sdk/e2e/GherkinSpecTest.java

@@ -5,6 +5,7 @@
 import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
 
 import org.junit.platform.suite.api.ConfigurationParameter;
+import org.junit.platform.suite.api.ExcludeTags;
 import org.junit.platform.suite.api.IncludeEngines;
 import org.junit.platform.suite.api.SelectDirectories;
 import org.junit.platform.suite.api.Suite;
@@ -15,4 +16,5 @@
 @ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
 @ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "dev.openfeature.sdk.e2e.steps")
 @ConfigurationParameter(key = OBJECT_FACTORY_PROPERTY_NAME, value = "io.cucumber.picocontainer.PicoFactory")
-public class EvaluationTest {}
+@ExcludeTags({"deprecated"})
+public class GherkinSpecTest {}

src/test/java/dev/openfeature/sdk/e2e/steps/ContextSteps.java

@@ -8,6 +8,8 @@
 import dev.openfeature.sdk.Hook;
 import dev.openfeature.sdk.HookContext;
 import dev.openfeature.sdk.ImmutableContext;
+import dev.openfeature.sdk.ImmutableStructure;
+import dev.openfeature.sdk.MutableContext;
 import dev.openfeature.sdk.OpenFeatureAPI;
 import dev.openfeature.sdk.ThreadLocalTransactionContextPropagator;
 import dev.openfeature.sdk.Value;
@@ -101,4 +103,31 @@ public void contextEntriesForEachLevelFromAPILevelDownToTheLevelWithKeyAndValue(
             }
         }
     }
+
+    @Given("a context containing a key {string} with null value")
+    public void a_context_containing_a_key_with_null_value(String key)
+            throws ClassNotFoundException, InstantiationException {
+        a_context_containing_a_key_with_type_and_with_value(key, "String", null);
+    }
+
+    @Given("a context containing a key {string}, with type {string} and with value {string}")
+    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));
+        state.context = new MutableContext(state.context.getTargetingKey(), map);
+    }
+
+    @Given("a context containing a targeting key with value {string}")
+    public void a_context_containing_a_targeting_key_with_value(String string) {
+        state.context.setTargetingKey(string);
+    }
+
+    @Given("a context containing a nested property with outer key {string} and inner key {string}, with value {string}")
+    public void a_context_containing_a_nested_property_with_outer_key_and_inner_key_with_value(
+            String outer, String inner, String value) {
+        Map<String, Value> innerMap = new HashMap<>();
+        innerMap.put(inner, new Value(value));
+        state.context.add(outer, new ImmutableStructure(innerMap));
+    }
 }

src/test/java/dev/openfeature/sdk/e2e/steps/FlagStepDefinitions.java

@@ -2,6 +2,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import dev.openfeature.sdk.ErrorCode;
 import dev.openfeature.sdk.FlagEvaluationDetails;
 import dev.openfeature.sdk.ImmutableMetadata;
 import dev.openfeature.sdk.Value;
@@ -63,6 +64,11 @@ public void the_resolved_details_value_should_be(String value) {
         assertThat(state.evaluation.getValue()).isEqualTo(Utils.convert(value, state.flag.type));
     }
 
+    @Then("the flag key should be {string}")
+    public void the_flag_key_should_be(String key) {
+        assertThat(state.evaluation.getFlagKey()).isEqualTo(key);
+    }
+
     @Then("the reason should be {string}")
     public void the_reason_should_be(String reason) {
         assertThat(state.evaluation.getReason()).isEqualTo(reason);
@@ -73,6 +79,20 @@ public void the_variant_should_be(String variant) {
         assertThat(state.evaluation.getVariant()).isEqualTo(variant);
     }
 
+    @Then("the error-code should be {string}")
+    public void the_error_code_should_be(String errorCode) {
+        if (errorCode.isEmpty()) {
+            assertThat(state.evaluation.getErrorCode()).isNull();
+        } else {
+            assertThat(state.evaluation.getErrorCode()).isEqualTo(ErrorCode.valueOf(errorCode));
+        }
+    }
+
+    @Then("the error message should contain {string}")
+    public void the_error_error_message_should_contain(String errorCode) {
+        assertThat(state.evaluation.getErrorMessage()).contains(errorCode);
+    }
+
     @Then("the resolved metadata value \"{}\" with type \"{}\" should be \"{}\"")
     public void theResolvedMetadataValueShouldBe(String key, String type, String value)
             throws NoSuchFieldException, IllegalAccessException {

src/test/java/dev/openfeature/sdk/e2e/steps/StepDefinitions.java

@@ -21,6 +21,7 @@
 import java.util.Map;
 import lombok.SneakyThrows;
 
+@Deprecated
 public class StepDefinitions {
 
     private static Client client;

src/test/java/dev/openfeature/sdk/testutils/TestFlagsUtils.java

@@ -1,18 +1,25 @@
 package dev.openfeature.sdk.testutils;
 
-import static dev.openfeature.sdk.Structure.mapToStructure;
-
-import com.google.common.collect.ImmutableMap;
+import com.fasterxml.jackson.core.StreamReadFeature;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
 import dev.openfeature.sdk.ImmutableMetadata;
-import dev.openfeature.sdk.Value;
+import dev.openfeature.sdk.providers.memory.ContextEvaluator;
 import dev.openfeature.sdk.providers.memory.Flag;
-import java.util.HashMap;
+import dev.openfeature.sdk.testutils.jackson.ContextEvaluatorDeserializer;
+import dev.openfeature.sdk.testutils.jackson.ImmutableMetadataDeserializer;
+import dev.openfeature.sdk.testutils.jackson.InMemoryFlagMixin;
+import java.io.IOException;
+import java.nio.file.Paths;
 import java.util.Map;
 import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * Test flags utils.
  */
+@Slf4j
 @UtilityClass
 public class TestFlagsUtils {
 
@@ -31,81 +38,27 @@ public class TestFlagsUtils {
      * @return map of flags
      */
     public static Map<String, Flag<?>> buildFlags() {
-        Map<String, Flag<?>> flags = new HashMap<>();
-        flags.put(
-                BOOLEAN_FLAG_KEY,
-                Flag.builder()
-                        .variant("on", true)
-                        .variant("off", false)
-                        .defaultVariant("on")
-                        .build());
-        flags.put(
-                STRING_FLAG_KEY,
-                Flag.builder()
-                        .variant("greeting", "hi")
-                        .variant("parting", "bye")
-                        .defaultVariant("greeting")
-                        .build());
-        flags.put(
-                INT_FLAG_KEY,
-                Flag.builder()
-                        .variant("one", 1)
-                        .variant("ten", 10)
-                        .defaultVariant("ten")
-                        .build());
-        flags.put(
-                FLOAT_FLAG_KEY,
-                Flag.builder()
-                        .variant("tenth", 0.1)
-                        .variant("half", 0.5)
-                        .defaultVariant("half")
-                        .build());
-        flags.put(
-                OBJECT_FLAG_KEY,
-                Flag.builder()
-                        .variant("empty", new HashMap<>())
-                        .variant(
-                                "template",
-                                new Value(mapToStructure(ImmutableMap.of(
-                                        "showImages", new Value(true),
-                                        "title", new Value("Check out these pics!"),
-                                        "imagesPerPage", new Value(100)))))
-                        .defaultVariant("template")
-                        .build());
-        flags.put(
-                CONTEXT_AWARE_FLAG_KEY,
-                Flag.<String>builder()
-                        .variant("internal", "INTERNAL")
-                        .variant("external", "EXTERNAL")
-                        .defaultVariant("external")
-                        .contextEvaluator((flag, evaluationContext) -> {
-                            if (new Value(false).equals(evaluationContext.getValue("customer"))) {
-                                return (String) flag.getVariants().get("internal");
-                            } else {
-                                return (String) flag.getVariants().get(flag.getDefaultVariant());
-                            }
-                        })
-                        .build());
-        flags.put(
-                WRONG_FLAG_KEY,
-                Flag.builder()
-                        .variant("one", "uno")
-                        .variant("two", "dos")
-                        .defaultVariant("one")
-                        .build());
-        flags.put(
-                METADATA_FLAG_KEY,
-                Flag.builder()
-                        .variant("on", true)
-                        .variant("off", false)
-                        .defaultVariant("on")
-                        .flagMetadata(ImmutableMetadata.builder()
-                                .addString("string", "1.0.2")
-                                .addInteger("integer", 2)
-                                .addBoolean("boolean", true)
-                                .addDouble("float", 0.1d)
-                                .build())
-                        .build());
-        return flags;
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.configure(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION.mappedFeature(), true);
+        objectMapper.addMixIn(Flag.class, InMemoryFlagMixin.class);
+        objectMapper.addMixIn(Flag.FlagBuilder.class, InMemoryFlagMixin.FlagBuilderMixin.class);
+
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(ImmutableMetadata.class, new ImmutableMetadataDeserializer());
+        module.addDeserializer(ContextEvaluator.class, new ContextEvaluatorDeserializer());
+        objectMapper.registerModule(module);
+
+        Map<String, Flag<?>> flagsJson;
+        try {
+            flagsJson = objectMapper.readValue(
+                    Paths.get("spec/specification/assets/gherkin/test-flags.json")
+                            .toFile(),
+                    new TypeReference<>() {});
+
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        return flagsJson;
     }
 }

src/test/java/dev/openfeature/sdk/testutils/jackson/CelContextEvaluator.java

@@ -0,0 +1,54 @@
+package dev.openfeature.sdk.testutils.jackson;
+
+import dev.cel.common.types.SimpleType;
+import dev.cel.compiler.CelCompiler;
+import dev.cel.compiler.CelCompilerFactory;
+import dev.cel.runtime.CelRuntime;
+import dev.cel.runtime.CelRuntimeFactory;
+import dev.openfeature.sdk.EvaluationContext;
+import dev.openfeature.sdk.providers.memory.ContextEvaluator;
+import dev.openfeature.sdk.providers.memory.Flag;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CelContextEvaluator<T> implements ContextEvaluator<T> {
+    private final CelRuntime.Program program;
+
+    public CelContextEvaluator(String expression) {
+        try {
+            CelRuntime celRuntime =
+                    CelRuntimeFactory.standardCelRuntimeBuilder().build();
+            CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder()
+                    .addVar("customer", SimpleType.STRING)
+                    .addVar("email", SimpleType.STRING)
+                    .addVar("dummy", SimpleType.STRING)
+                    .setResultType(SimpleType.STRING)
+                    // Add other variables you expect
+                    .build();
+
+            var ast = celCompiler.compile(expression).getAst();
+            this.program = celRuntime.createProgram(ast);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to compile CEL expression: " + expression, e);
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T evaluate(Flag flag, EvaluationContext evaluationContext) {
+        try {
+            Map<String, Object> objectMap = new HashMap<>(Map.of("email", ""));
+            if (evaluationContext != null) {
+                // Evaluate with context
+                objectMap.putAll(evaluationContext.asObjectMap());
+            }
+
+            Object result = program.eval(objectMap);
+
+            String stringResult = (String) result;
+            return (T) flag.getVariants().get(stringResult);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/test/java/dev/openfeature/sdk/testutils/jackson/ContextEvaluatorDeserializer.java

@@ -0,0 +1,25 @@
+package dev.openfeature.sdk.testutils.jackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonNode;
+import dev.openfeature.sdk.providers.memory.ContextEvaluator;
+import java.io.IOException;
+
+public class ContextEvaluatorDeserializer extends JsonDeserializer<ContextEvaluator<?>> {
+    @Override
+    public ContextEvaluator<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+        JsonNode node = p.getCodec().readTree(p);
+
+        if (node.isTextual()) {
+            return new CelContextEvaluator<>(node.asText());
+        }
+
+        if (node.isObject() && node.has("expression")) {
+            return new CelContextEvaluator<>(node.get("expression").asText());
+        }
+
+        return null;
+    }
+}