Add tests to verify unwrapping of nested contexts

Signed-off-by: christian.lutnik <christian.lutnik@dynatrace.com>

Author: chrfwow

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

@@ -235,19 +235,37 @@ public Map<String, Value> asUnmodifiableMap() {
 
     @Override
     public Map<String, Object> asObjectMap() {
-        // Build the object map directly from the resolved attribute map,
-        // so this stays consistent with equals/hashCode and asMap().
-        Map<String, Value> resolved = getResolvedMap();
-        if (resolved.isEmpty()) {
+        if (keySet != null && keySet.isEmpty()) {
             return new HashMap<>(0);
         }
 
-        HashMap<String, Object> map = HashMapUtils.forEntries(resolved.size());
-        for (Map.Entry<String, Value> entry : resolved.entrySet()) {
-            Value value = entry.getValue();
-            // Value is responsible for exposing the underlying Java representation.
-            map.put(entry.getKey(), value == null ? null : value.asObject());
+        HashMap<String, Object> map;
+        if (keySet != null) {
+            // use helper to size the map based on expected entries
+            map = HashMapUtils.forEntries(keySet.size());
+        } else {
+            map = new HashMap<>();
+        }
+
+        if (apiContext != null) {
+            map.putAll(apiContext.asObjectMap());
+        }
+        if (transactionContext != null) {
+            map.putAll(transactionContext.asObjectMap());
         }
+        if (clientContext != null) {
+            map.putAll(clientContext.asObjectMap());
+        }
+        if (invocationContext != null) {
+            map.putAll(invocationContext.asObjectMap());
+        }
+        if (hookContexts != null) {
+            for (int i = 0; i < hookContexts.size(); i++) {
+                EvaluationContext hookContext = hookContexts.get(i);
+                map.putAll(hookContext.asObjectMap());
+            }
+        }
+
         return map;
     }
 

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

@@ -1,6 +1,11 @@
 package dev.openfeature.sdk;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Map;
 import java.util.Set;
@@ -151,7 +156,7 @@ void keySetIsGeneratedCorrectly() {
                     "api",
                     "override",
                     "targetingKey" // expected, even though not explicitly set
-                    );
+            );
 
             assertEquals(expectedKeys, layeredContext.keySet());
             // cached key set
@@ -192,7 +197,7 @@ void mapIsGeneratedCorrectly() {
                     "api", new Value("api"),
                     "override", new Value("hook"),
                     "targetingKey", new Value("hook-level") // expected, even though not explicitly set
-                    );
+            );
 
             assertEquals(expectedKeys, layeredContext.asMap());
             assertEquals(expectedKeys, layeredContext.asUnmodifiableMap());
@@ -239,7 +244,7 @@ void mapIsGeneratedCorrectly() {
                     "api", "api",
                     "override", "hook",
                     "targetingKey", "hook-level" // expected, even though not explicitly set in map
-                    );
+            );
 
             assertEquals(expectedKeys, layeredContext.asObjectMap());
         }
@@ -257,6 +262,61 @@ void creatingMapWithCachedNonEmptyKeySetWorks() {
             assertNotNull(layeredContext.keySet());
             assertEquals(apiContext.asObjectMap(), layeredContext.asObjectMap());
         }
+
+        @Test
+        void nestedContextsAreUnwrappedCorrectly() {
+            var innerApiContext = new ImmutableContext(Map.of("inner", new Value("api")));
+            var outerApiContext = new ImmutableContext(Map.of("outer", new Value(innerApiContext)));
+
+            var innerClientContext = new ImmutableContext(Map.of("inner", new Value("client")));
+            var outerClientContext = new ImmutableContext(Map.of("outer", new Value(innerClientContext)));
+            var layeredContext = new LayeredEvaluationContext(outerApiContext, null, outerClientContext, null);
+
+            var objectMap = layeredContext.asObjectMap();
+
+            assertEquals(Map.of("outer", Map.of("inner", "client")), objectMap);
+        }
+
+        @Test
+        void nestedHookContextsAreUnwrappedCorrectly() {
+            var innerApiContext = new ImmutableContext(Map.of("inner", new Value("api")));
+            var outerApiContext = new ImmutableContext(Map.of("outer", new Value(innerApiContext)));
+
+            var innerClientContext = new ImmutableContext(Map.of("inner", new Value("client")));
+            var outerClientContext = new ImmutableContext(Map.of("outer", new Value(innerClientContext)));
+            var layeredContext = new LayeredEvaluationContext(outerApiContext, null, outerClientContext, null);
+
+            var innerHookContext = new ImmutableContext(Map.of("inner", new Value("hook")));
+            var outerHookContext = new ImmutableContext(Map.of("outer", new Value(innerHookContext)));
+
+            layeredContext.putHookContext(outerHookContext);
+
+            var objectMap = layeredContext.asObjectMap();
+
+            assertEquals(Map.of("outer", Map.of("inner", "hook")), objectMap);
+        }
+
+        @Test
+        void objectMapIsMutable() {
+            LayeredEvaluationContext layeredContext =
+                    new LayeredEvaluationContext(apiContext, transactionContext, clientContext, invocationContext);
+
+            var objectMap = layeredContext.asObjectMap();
+            assertDoesNotThrow(() -> objectMap.put("a", "b"));
+            assertEquals("b", objectMap.get("a"));
+        }
+
+        @Test
+        void mutatingObjectMapHasNoSideEffects() {
+            LayeredEvaluationContext layeredContext =
+                    new LayeredEvaluationContext(apiContext, transactionContext, clientContext, invocationContext);
+
+            var objectMap1 = layeredContext.asObjectMap();
+            objectMap1.put("a", "b");
+
+            var objectMap2 = layeredContext.asObjectMap();
+            assertNull(objectMap2.get("a"));
+        }
     }
 
     @Nested