From 495b5832e84b415a414ce5b85a307d59e47455c3 Mon Sep 17 00:00:00 2001
From: liran2000 <liran2000@gmail.com>
Date: Mon, 18 Mar 2024 08:26:38 +0200
Subject: [PATCH] add MutableContextTest for test coverage

Signed-off-by: liran2000 <liran2000@gmail.com>
---
 .../openfeature/sdk/MutableContextTest.java   | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 src/test/java/dev/openfeature/sdk/MutableContextTest.java

diff --git a/src/test/java/dev/openfeature/sdk/MutableContextTest.java b/src/test/java/dev/openfeature/sdk/MutableContextTest.java
new file mode 100644
index 000000000..655cc85d5
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/MutableContextTest.java
@@ -0,0 +1,105 @@
+package dev.openfeature.sdk;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static dev.openfeature.sdk.EvaluationContext.TARGETING_KEY;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MutableContextTest {
+
+    @DisplayName("targeting key should be changed from the overriding context")
+    @Test
+    void shouldChangeTargetingKeyFromOverridingContext() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        attributes.put("key1", new Value("val1"));
+        attributes.put("key2", new Value("val2"));
+        EvaluationContext ctx = new MutableContext("targeting key", attributes);
+        EvaluationContext overriding = new MutableContext("overriding_key");
+        EvaluationContext merge = ctx.merge(overriding);
+        assertEquals("overriding_key", merge.getTargetingKey());
+    }
+
+    @DisplayName("targeting key should not changed from the overriding context if missing")
+    @Test
+    void shouldRetainTargetingKeyWhenOverridingContextTargetingKeyValueIsEmpty() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        attributes.put("key1", new Value("val1"));
+        attributes.put("key2", new Value("val2"));
+        EvaluationContext ctx = new MutableContext("targeting_key", attributes);
+        EvaluationContext overriding = new MutableContext("");
+        EvaluationContext merge = ctx.merge(overriding);
+        assertEquals("targeting_key", merge.getTargetingKey());
+    }
+    @DisplayName("missing targeting key should return null")
+    @Test
+    void missingTargetingKeyShould() {
+        EvaluationContext ctx = new MutableContext();
+        assertEquals(null, ctx.getTargetingKey());
+    }
+
+    @DisplayName("Merge should retain all the attributes from the existing context when overriding context is null")
+    @Test
+    void mergeShouldReturnAllTheValuesFromTheContextWhenOverridingContextIsNull() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        attributes.put("key1", new Value("val1"));
+        attributes.put("key2", new Value("val2"));
+        EvaluationContext ctx = new MutableContext("targeting_key", attributes);
+        EvaluationContext merge = ctx.merge(null);
+        assertEquals("targeting_key", merge.getTargetingKey());
+        assertArrayEquals(new Object[]{"key1", "key2", TARGETING_KEY}, merge.keySet().toArray());
+    }
+
+    @DisplayName("Merge should retain subkeys from the existing context when the overriding context has the same targeting key")
+    @Test
+    void mergeShouldRetainItsSubkeysWhenOverridingContextHasTheSameKey() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        HashMap<String, Value> overridingAttributes = new HashMap<>();
+        HashMap<String, Value> key1Attributes = new HashMap<>();
+        HashMap<String, Value> ovKey1Attributes = new HashMap<>();
+
+        key1Attributes.put("key1_1", new Value("val1_1"));
+        attributes.put("key1", new Value(new ImmutableStructure(key1Attributes)));
+        attributes.put("key2", new Value("val2"));
+        ovKey1Attributes.put("overriding_key1_1", new Value("overriding_val_1_1"));
+        overridingAttributes.put("key1", new Value(new ImmutableStructure(ovKey1Attributes)));
+        
+        EvaluationContext ctx = new MutableContext("targeting_key", attributes);
+        EvaluationContext overriding = new MutableContext("targeting_key", overridingAttributes);
+        EvaluationContext merge = ctx.merge(overriding);
+        assertEquals("targeting_key", merge.getTargetingKey());
+        assertArrayEquals(new Object[]{"key1", "key2", TARGETING_KEY}, merge.keySet().toArray());
+        
+        Value key1 = merge.getValue("key1");
+        assertTrue(key1.isStructure());
+        
+        Structure value = key1.asStructure();
+        assertArrayEquals(new Object[]{"key1_1","overriding_key1_1"}, value.keySet().toArray());
+    }
+    
+    @DisplayName("Merge should retain subkeys from the existing context when the overriding context doesn't have targeting key")
+    @Test
+    void mergeShouldRetainItsSubkeysWhenOverridingContextHasNoTargetingKey() {
+        HashMap<String, Value> attributes = new HashMap<>();
+        HashMap<String, Value> key1Attributes = new HashMap<>();
+
+        key1Attributes.put("key1_1", new Value("val1_1"));
+        attributes.put("key1", new Value(new ImmutableStructure(key1Attributes)));
+        attributes.put("key2", new Value("val2"));
+        
+        EvaluationContext ctx = new MutableContext(attributes);
+        EvaluationContext overriding = new MutableContext();
+        EvaluationContext merge = ctx.merge(overriding);
+        assertArrayEquals(new Object[]{"key1", "key2"}, merge.keySet().toArray());
+        
+        Value key1 = merge.getValue("key1");
+        assertTrue(key1.isStructure());
+        
+        Structure value = key1.asStructure();
+        assertArrayEquals(new Object[]{"key1_1"}, value.keySet().toArray());
+    }
+}