added immutable context implementation.

Signed-off-by: thiyagu06 <[email protected]>

Author: thiyagu06

src/main/java/dev/openfeature/sdk/ImmutableContext.java

@@ -0,0 +1,112 @@
+package dev.openfeature.sdk;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Delegate;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The EvaluationContext is a container for arbitrary contextual data
+ * that can be used as a basis for dynamic evaluation.
+ * The MutableContext is an EvaluationContext implementation which is not threadsafe, and whose attributes can
+ * be modified after instantiation.
+ */
+@ToString
+@SuppressWarnings("PMD.BeanMembersShouldSerialize")
+public class ImmutableContext implements EvaluationContext {
+
+    @Getter
+    private String targetingKey;
+    @Delegate(excludes = HideDelegateAddMethods.class)
+    private final MutableStructure structure;
+
+    public ImmutableContext() {
+        this.structure = new MutableStructure();
+        this.targetingKey = "";
+    }
+
+    public ImmutableContext(Map<String, Value> attributes) {
+        HashMap<String, Value> copy = new HashMap<>(attributes);
+        this.structure = new MutableStructure(copy);
+        this.targetingKey = "";
+    }
+
+    public ImmutableContext(String targetingKey, Map<String, Value> attributes) {
+        this(attributes);
+        this.targetingKey = targetingKey;
+    }
+
+    @Override
+    public void setTargetingKey(String targetingKey) {
+        throw new UnsupportedOperationException("changing of targeting key is not allowed");
+    }
+
+    /**
+     * Merges this EvaluationContext objects with the second overriding the this in
+     * case of conflict.
+     *
+     * @param overridingContext overriding context
+     * @return resulting merged context
+     */
+    @Override
+    public EvaluationContext merge(EvaluationContext overridingContext) {
+        if (overridingContext == null) {
+            return new ImmutableContext(this.asMap());
+        }
+        String targetingKey = "";
+        if (this.getTargetingKey() != null && !this.getTargetingKey().trim().equals("")) {
+            targetingKey = this.getTargetingKey();
+        }
+
+        if (overridingContext.getTargetingKey() != null && !overridingContext.getTargetingKey().trim().equals("")) {
+            targetingKey = overridingContext.getTargetingKey();
+        }
+        Map<String, Value> merged = new HashMap<>();
+
+        merged.putAll(this.asMap());
+        merged.putAll(overridingContext.asMap());
+        return new ImmutableContext(targetingKey, merged);
+    }
+
+    /**
+     * Hidden class to tell Lombok not to copy these methods over via delegation.
+     */
+    private static class HideDelegateAddMethods {
+        public MutableStructure add(String ignoredKey, Boolean ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, Double ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, String ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, Value ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, Integer ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, List<Value> ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, MutableStructure ignoredValue) {
+            return null;
+        }
+
+        public MutableStructure add(String ignoredKey, Instant ignoredValue) {
+            return null;
+        }
+    }
+}

src/main/java/dev/openfeature/sdk/OpenFeatureClient.java

@@ -93,7 +93,7 @@ private <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key
         FlagEvaluationOptions flagOptions = ObjectUtils.defaultIfNull(options,
                 () -> FlagEvaluationOptions.builder().build());
         Map<String, Object> hints = Collections.unmodifiableMap(flagOptions.getHookHints());
-        ctx = ObjectUtils.defaultIfNull(ctx, () -> new MutableContext());
+        ctx = ObjectUtils.defaultIfNull(ctx, () -> new ImmutableContext());
 
 
         FlagEvaluationDetails<T> details = null;
@@ -120,10 +120,10 @@ private <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key
             // merge of: API.context, client.context, invocation.context
             apiContext = openfeatureApi.getEvaluationContext() != null
                     ? openfeatureApi.getEvaluationContext()
-                    : new MutableContext();
+                    : new ImmutableContext();
             clientContext = this.getEvaluationContext() != null
                     ? this.getEvaluationContext()
-                    : new MutableContext();
+                    : new ImmutableContext();
 
             EvaluationContext ctxFromHook = hookSupport.beforeHooks(type, hookCtx, mergedHooks, hints);
 

src/test/java/dev/openfeature/sdk/ImmutableContextTest.java

@@ -0,0 +1,30 @@
+package dev.openfeature.sdk;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class ImmutableContextTest {
+
+    @Test
+    @DisplayName("Mutating targeting key is not allowed on Immutable Context")
+    void shouldThrowUnsupportedExceptionWhenMutatingTargetingKey() {
+        EvaluationContext ctx = new ImmutableContext("targeting key", new HashMap<>());
+        assertThrows(UnsupportedOperationException.class, () -> ctx.setTargetingKey(""));
+    }
+
+    @DisplayName("attributes mutation should not affect the immutable context")
+    @Test
+    void shouldCreateCopyOfAttributesForImmutableContext() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        attributes.put("key1", new Value("val1"));
+        attributes.put("key2", new Value("val2"));
+        EvaluationContext ctx = new ImmutableContext("targeting key", attributes);
+        attributes.put("key3", new Value("val3"));
+        assertArrayEquals(ctx.keySet().toArray(), new Object[]{"key1", "key2"});
+    }
+}

src/test/java/dev/openfeature/sdk/OpenFeatureClientTest.java

@@ -37,8 +37,7 @@ void mergeContextTest() {
         String flag = "feature key";
         boolean defaultValue = false;
         String targetingKey = "targeting key";
-        EvaluationContext ctx = new MutableContext(targetingKey);
-
+        EvaluationContext ctx = new ImmutableContext(targetingKey, new HashMap<>());
         OpenFeatureAPI api = mock(OpenFeatureAPI.class);
         FeatureProvider mockProvider = mock(FeatureProvider.class);
         // this makes it so that true is returned only if the targeting key set at the client level is honored