Merge pull request #5 from open-feature/eval-context

Evaluation Context support

Author: Justin Abrahms

lib/src/main/java/dev/openfeature/javasdk/EvaluationContext.java

@@ -1,4 +1,94 @@
 package dev.openfeature.javasdk;
 
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+
+@ToString @EqualsAndHashCode
+@SuppressWarnings("PMD.BeanMembersShouldSerialize")
 public class EvaluationContext {
+    @Setter @Getter private String targetingKey;
+    private final Map<String, Integer> integerAttributes;
+    private final Map<String, String> stringAttributes;
+
+    EvaluationContext() {
+        this.targetingKey = "";
+        this.integerAttributes = new HashMap<>();
+        this.stringAttributes = new HashMap<>();
+    }
+
+    public void addStringAttribute(String key, String value) {
+        stringAttributes.put(key, value);
+    }
+
+    public String getStringAttribute(String key) {
+        return stringAttributes.get(key);
+    }
+
+    public void addIntegerAttribute(String key, Integer value) {
+        integerAttributes.put(key, value);
+    }
+
+    public Integer getIntegerAttribute(String key) {
+        return integerAttributes.get(key);
+    }
+
+    public Boolean getBooleanAttribute(String key) {
+        return Boolean.valueOf(stringAttributes.get(key));
+    }
+
+    public void addBooleanAttribute(String key, Boolean b) {
+        stringAttributes.put(key, b.toString());
+    }
+
+    public void addDatetimeAttribute(String key, ZonedDateTime value) {
+        this.stringAttributes.put(key, value.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+    }
+
+    // TODO: addStructure or similar.
+
+    public ZonedDateTime getDatetimeAttribute(String key) {
+        String attr = this.stringAttributes.get(key);
+        if (attr == null) {
+            return null;
+        }
+        return ZonedDateTime.parse(attr, DateTimeFormatter.ISO_ZONED_DATE_TIME);
+    }
+
+    /**
+     * Merges two EvaluationContext objects with the second overriding the first in case of conflict.
+     */
+    public static EvaluationContext merge(EvaluationContext ctx1, EvaluationContext ctx2) {
+        EvaluationContext ec = new EvaluationContext();
+        for (Map.Entry<String, Integer> e : ctx1.integerAttributes.entrySet()) {
+            ec.addIntegerAttribute(e.getKey(), e.getValue());
+        }
+
+        for (Map.Entry<String, Integer> e : ctx2.integerAttributes.entrySet()) {
+            ec.addIntegerAttribute(e.getKey(), e.getValue());
+        }
+
+        for (Map.Entry<String, String> e : ctx1.stringAttributes.entrySet()) {
+            ec.addStringAttribute(e.getKey(), e.getValue());
+        }
+
+        for (Map.Entry<String, String> e : ctx2.stringAttributes.entrySet()) {
+            ec.addStringAttribute(e.getKey(), e.getValue());
+        }
+        if (ctx1.getTargetingKey() != null) {
+            ec.setTargetingKey(ctx1.getTargetingKey());
+        }
+
+        if (ctx2.getTargetingKey() != null) {
+            ec.setTargetingKey(ctx2.getTargetingKey());
+        }
+
+        return ec;
+    }
 }

lib/src/main/java/dev/openfeature/javasdk/Hook.java

@@ -2,9 +2,13 @@
 
 import com.google.common.collect.ImmutableMap;
 
+import java.util.Optional;
+
 // TODO: interface? or abstract class?
 public abstract class Hook<T> {
-    public void before(HookContext<T> ctx, ImmutableMap<String, Object> hints) {}
+    public Optional<EvaluationContext> before(HookContext<T> ctx, ImmutableMap<String, Object> hints) {
+        return Optional.empty();
+    }
     public void after(HookContext<T> ctx, FlagEvaluationDetails<T> details, ImmutableMap<String, Object> hints) {}
     public void error(HookContext<T> ctx, Exception error, ImmutableMap<String, Object> hints) {}
     public void finallyAfter(HookContext<T> ctx, ImmutableMap<String, Object> hints) {}

lib/src/main/java/dev/openfeature/javasdk/HookContext.java

@@ -3,8 +3,9 @@
 import lombok.Builder;
 import lombok.NonNull;
 import lombok.Value;
+import lombok.With;
 
-@Value @Builder
+@Value @Builder @With
 public class HookContext<T> {
     @NonNull String flagKey;
     @NonNull FlagValueType type;

lib/src/main/java/dev/openfeature/javasdk/OpenFeatureClient.java

@@ -11,6 +11,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 
 @SuppressWarnings("PMD.DataflowAnomalyAnalysis")
 public class OpenFeatureClient implements Client {
@@ -34,11 +35,12 @@ public void registerHooks(Hook... hooks) {
 
     <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key, T defaultValue, EvaluationContext ctx, FlagEvaluationOptions options) {
         FeatureProvider provider = this.openfeatureApi.getProvider();
+        ImmutableMap<String, Object> hints = options.getHookHints();
         if (ctx == null) {
             ctx = new EvaluationContext();
         }
 
-        ImmutableMap<String, Object> hints = options.getHookHints();
+        // merge of: API.context, client.context, invocation.context
 
         // TODO: Context transformation?
         HookContext hookCtx = HookContext.from(key, type, this, ctx, defaultValue);
@@ -56,13 +58,15 @@ <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key, T defa
 
         FlagEvaluationDetails<T> details = null;
         try {
-            this.beforeHooks(hookCtx, mergedHooks, hints);
+            EvaluationContext ctxFromHook = this.beforeHooks(hookCtx, mergedHooks, hints);
+            EvaluationContext invocationContext = EvaluationContext.merge(ctxFromHook, ctx);
 
             ProviderEvaluation<T> providerEval;
             if (type == FlagValueType.BOOLEAN) {
                 // TODO: Can we guarantee that defaultValue is a boolean? If not, how to we handle that?
-                providerEval = (ProviderEvaluation<T>) provider.getBooleanEvaluation(key, (Boolean) defaultValue, ctx, options);
+                providerEval = (ProviderEvaluation<T>) provider.getBooleanEvaluation(key, (Boolean) defaultValue, invocationContext, options);
             } else {
+                // TODO: Support other flag types.
                 throw new GeneralError("Unknown flag type");
             }
 
@@ -106,13 +110,17 @@ private <T> void afterHooks(HookContext hookContext, FlagEvaluationDetails<T> de
         }
     }
 
-    private HookContext beforeHooks(HookContext hookCtx, List<Hook> hooks, ImmutableMap<String, Object> hints) {
+    private EvaluationContext beforeHooks(HookContext hookCtx, List<Hook> hooks, ImmutableMap<String, Object> hints) {
         // These traverse backwards from normal.
+        EvaluationContext ctx = hookCtx.getCtx();
         for (Hook hook : Lists.reverse(hooks)) {
-            hook.before(hookCtx, hints);
-            // TODO: Merge returned context w/ hook context object
+            Optional<EvaluationContext> newCtx = hook.before(hookCtx, hints);
+            if (newCtx != null && newCtx.isPresent()) {
+                ctx = EvaluationContext.merge(ctx, newCtx.get());
+                hookCtx = hookCtx.withCtx(ctx);
+            }
         }
-        return hookCtx;
+        return ctx;
     }
 
     @Override
@@ -162,12 +170,12 @@ public String getStringValue(String key, String defaultValue, EvaluationContext
 
     @Override
     public FlagEvaluationDetails<String> getStringDetails(String key, String defaultValue) {
-        return getStringDetails(key, defaultValue,  new EvaluationContext());
+        return getStringDetails(key, defaultValue,  null);
     }
 
     @Override
     public FlagEvaluationDetails<String> getStringDetails(String key, String defaultValue, EvaluationContext ctx) {
-        return getStringDetails(key, defaultValue,  new EvaluationContext(), FlagEvaluationOptions.builder().build());
+        return getStringDetails(key, defaultValue, ctx, FlagEvaluationOptions.builder().build());
     }
 
     @Override

lib/src/test/java/dev/openfeature/javasdk/DeveloperExperienceTest.java

@@ -41,7 +41,7 @@ class DeveloperExperienceTest {
         api.setProvider(new NoOpProvider());
         Client client = api.getClient();
         client.registerHooks(clientHook);
-        Boolean retval = client.getBooleanValue(flagKey, false, new EvaluationContext(),
+        Boolean retval = client.getBooleanValue(flagKey, false, null,
                 FlagEvaluationOptions.builder().hook(evalHook).build());
         verify(clientHook, times(1)).finallyAfter(any(), any());
         verify(evalHook, times(1)).finallyAfter(any(), any());

lib/src/test/java/dev/openfeature/javasdk/EvalContextTests.java

@@ -0,0 +1,45 @@
+package dev.openfeature.javasdk;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class EvalContextTests {
+    @Specification(spec="Evaluation Context", number="3.1",
+            text="The `evaluation context` structure **MUST** define an optional `targeting key` field of " +
+                    "type string, identifying the subject of the flag evaluation.")
+    @Test void requires_targeting_key() {
+        EvaluationContext ec = new EvaluationContext();
+        ec.setTargetingKey("targeting-key");
+        assertEquals("targeting-key", ec.getTargetingKey());
+    }
+
+    @Specification(spec="Evaluation Context", number="3.2", text="The evaluation context MUST support the inclusion of " +
+            "custom fields, having keys of type `string`, and " +
+            "values of type `boolean | string | number | datetime | structure`.")
+    @Test void eval_context() {
+        EvaluationContext ec = new EvaluationContext();
+
+        ec.addStringAttribute("str", "test");
+        assertEquals("test", ec.getStringAttribute("str"));
+
+        ec.addBooleanAttribute("bool", true);
+        assertEquals(true, ec.getBooleanAttribute("bool"));
+
+        ec.addIntegerAttribute("int", 4);
+        assertEquals(4, ec.getIntegerAttribute("int"));
+
+        ZonedDateTime dt = ZonedDateTime.now();
+        ec.addDatetimeAttribute("dt", dt);
+        assertEquals(dt, ec.getDatetimeAttribute("dt"));
+    }
+
+    @Specification(spec="Evaluation Context", number="3.2", text="The evaluation context MUST support the inclusion of " +
+            "custom fields, having keys of type `string`, and " +
+            "values of type `boolean | string | number | datetime | structure`.")
+    @Disabled("Structure support")
+    @Test void eval_context__structure() {}
+}

lib/src/test/java/dev/openfeature/javasdk/FlagEvaluationSpecTests.java

@@ -1,6 +1,5 @@
 package dev.openfeature.javasdk;
 
-import dev.openfeature.javasdk.*;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
@@ -132,6 +131,7 @@ Client _client() {
             "unhandled error, etc) the reason field in the evaluation details SHOULD indicate an error.")
     @Disabled
     @Test void detail_flags() {
+        // TODO: Add tests re: detail functions.
         throw new NotImplementedException();
     }