add targeting key extraction for in-process provider

Signed-off-by: Kavindu Dodanduwa <[email protected]>

Author: Kavindu-Dodan

Diff for: providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/process/targeting/Operator.java

@@ -1,15 +1,15 @@
 package dev.openfeature.contrib.providers.flagd.resolver.process.targeting;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.time.Instant;
-
 import dev.openfeature.sdk.EvaluationContext;
 import io.github.jamsesso.jsonlogic.JsonLogic;
 import io.github.jamsesso.jsonlogic.JsonLogicException;
 import lombok.Getter;
 
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
 /**
  * Targeting operator wraps JsonLogic handlers and expose a simple API for
  * external layers.
@@ -46,49 +46,57 @@ public Object apply(final String flagKey, final String targetingRule, final Eval
         long unixTimestamp = Instant.now().getEpochSecond();
         flagdProperties.put(TIME_STAMP, unixTimestamp);
 
-        final Map<String, Object> valueMap = ctx.asObjectMap();
-        valueMap.put(FLAGD_PROPS_KEY, flagdProperties);
+        final Map<String, Object> targetingCtxData = ctx.asObjectMap();
+
+        // asObjectMap() does not provide explicitly set targeting key (ex:- new ImmutableContext("TargetingKey") ).
+        // Hence, we add this explicitly here for targeting rule processing.
+        targetingCtxData.put(TARGET_KEY, ctx.getTargetingKey());
+        targetingCtxData.put(FLAGD_PROPS_KEY, flagdProperties);
 
         try {
-            return jsonLogicHandler.apply(targetingRule, valueMap);
+            return jsonLogicHandler.apply(targetingRule, targetingCtxData);
         } catch (JsonLogicException e) {
             throw new TargetingRuleException("Error evaluating json logic", e);
         }
     }
 
+    /**
+     * A utility class to extract well-known properties such as flag key, targeting key and timestamp from json logic
+     * evaluation context data for further processing at evaluators.
+     */
     @Getter
     static class FlagProperties {
-        private final Object flagKey;
-        private final Object timestamp;
-        private final String targetingKey;
+        private Object flagKey = null;
+        private Object timestamp = null;
+        private String targetingKey = null;
 
         FlagProperties(Object from) {
-            if (from instanceof Map) {
-                Map<?, ?> dataMap = (Map<?, ?>) from;
-
-                this.flagKey = extractSubPropertyFromFlagd(dataMap, FLAG_KEY);
-                this.timestamp = extractSubPropertyFromFlagd(dataMap, TIME_STAMP);
-
-                final Object targetKey = dataMap.get(TARGET_KEY);
-                
-                if (targetKey instanceof String) {
-                    targetingKey = (String) targetKey;
-                } else {
-                    targetingKey = null;
-                }
-                
-            } else {
-                flagKey = null;
-                timestamp = null;
-                targetingKey = null;
+            if (!(from instanceof Map)) {
+                return;
+            }
+
+            final Map<?, ?> dataMap = (Map<?, ?>) from;
+            final Object targetKey = dataMap.get(TARGET_KEY);
+            if (targetKey instanceof String) {
+                targetingKey = (String) targetKey;
+            }
+
+            final Map<?, ?> flagdPropertyMap = flagdPropertyMap(dataMap);
+            if (flagdPropertyMap == null){
+                return;
             }
+
+            this.flagKey = flagdPropertyMap.get(FLAG_KEY);
+            this.timestamp = flagdPropertyMap.get(TIME_STAMP);
         }
 
-        private static Object extractSubPropertyFromFlagd(Map<?, ?> dataMap, String propertyName) {
-            return Optional.ofNullable(dataMap.get(FLAGD_PROPS_KEY))
-                    .filter(flagdProps -> flagdProps instanceof Map)
-                    .map(flagdProps -> ((Map<?, ?>) flagdProps).get(propertyName))
-                    .orElse(null);
-        } 
+        private static Map<?, ?> flagdPropertyMap(Map<?, ?> dataMap) {
+            Object o = dataMap.get(FLAGD_PROPS_KEY);
+            if (o instanceof Map) {
+                return (Map<?, ?>) o;
+            }
+
+            return null;
+        }
     }
 }

Diff for: providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/process/InProcessResolverTest.java

@@ -34,6 +34,7 @@
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.FLAG_WIH_IF_IN_TARGET;
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.FLAG_WIH_INVALID_TARGET;
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.FLAG_WIH_SHORTHAND_TARGETING;
+import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.FLAG_WITH_TARGETING_KEY;
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.INT_FLAG;
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.OBJECT_FLAG;
 import static dev.openfeature.contrib.providers.flagd.resolver.process.MockFlags.VARIANT_MISMATCH_FLAG;
@@ -333,6 +334,25 @@ public void targetingUnmatchedEvaluationFlag() throws Exception {
         assertEquals(Reason.DEFAULT.toString(), providerEvaluation.getReason());
     }
 
+    @Test
+    public void explicitTargetingKeyHandling() throws NoSuchFieldException, IllegalAccessException {
+        // given
+        final Map<String, FeatureFlag> flagMap = new HashMap<>();
+        flagMap.put("stringFlag", FLAG_WITH_TARGETING_KEY);
+
+        InProcessResolver inProcessResolver = getInProcessResolverWth(new MockStorage(flagMap), providerState -> {
+        });
+
+        // when
+        ProviderEvaluation<String> providerEvaluation =
+                inProcessResolver.stringEvaluation("stringFlag", "loop", new MutableContext("xyz"));
+
+        // then
+        assertEquals("binetAlg", providerEvaluation.getValue());
+        assertEquals("binet", providerEvaluation.getVariant());
+        assertEquals(Reason.TARGETING_MATCH.toString(), providerEvaluation.getReason());
+    }
+
     @Test
     public void targetingErrorEvaluationFlag() throws Exception {
         // given

Diff for: providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/process/MockFlags.java

@@ -73,6 +73,9 @@ public class MockFlags {
     static final FeatureFlag FLAG_WIH_IF_IN_TARGET = new FeatureFlag("ENABLED", "loop", stringVariants,
             "{\"if\":[{\"in\":[\"@faas.com\",{\"var\":[\"email\"]}]},\"binet\",null]}");
 
+    static final FeatureFlag FLAG_WITH_TARGETING_KEY = new FeatureFlag("ENABLED", "loop", stringVariants,
+            "{\"if\":[{\"==\":[{\"var\":\"targetingKey\"},\"xyz\"]},\"binet\",null]}");
+
     // flag with incorrect targeting rule
     static final FeatureFlag FLAG_WIH_INVALID_TARGET = new FeatureFlag("ENABLED", "loop", stringVariants,
             "{if this, then that}");

Diff for: providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/process/targeting/OperatorTest.java

@@ -1,5 +1,6 @@
 package dev.openfeature.contrib.providers.flagd.resolver.process.targeting;
 
+import static dev.openfeature.contrib.providers.flagd.resolver.process.targeting.Operator.TARGET_KEY;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -64,13 +65,15 @@ void testFlagPropertiesConstructor() {
         flagdProperties.put(Operator.TIME_STAMP, 1634000000L);
 
         Map<String, Object> dataMap = new HashMap<>();
+        dataMap.put(TARGET_KEY, "myTargetingKey");
         dataMap.put(Operator.FLAGD_PROPS_KEY, flagdProperties);
 
         // When
         Operator.FlagProperties flagProperties = new Operator.FlagProperties(dataMap);
 
         // Then
         assertEquals("some-key", flagProperties.getFlagKey());
+        assertEquals("myTargetingKey", flagProperties.getTargetingKey());
         assertEquals(1634000000L, flagProperties.getTimestamp());
     }