Allow empty string as a valid targeting key

The OpenFeature spec defines targeting key as "a string" with no
restriction on empty strings. The TARGETING_KEY_MISSING error code
is for when a key is "not provided" (null), not when it's an empty
string.

Previously, MutableContext rejected empty strings by checking
`!targetingKey.trim().isEmpty()`, treating them the same as null.
This made it impossible to distinguish between "not provided" and
"explicitly set to empty string".

Changes:
- Remove isEmpty check from constructor and setTargetingKey()
- Empty string is now stored and returned by getTargetingKey()
- Null still results in no targeting key being set
- Updated tests to reflect new behavior
- Added explicit tests for empty string targeting key

Signed-off-by: Leo Romanovsky <leo.romanovsky@datadoghq.com>

Author: leoromanovsky

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

@@ -36,14 +36,14 @@ public MutableContext(Map<String, Value> attributes) {
 
     /**
      * Create a mutable context with given targetingKey and attributes provided. TargetingKey should be non-null
-     * and non-empty to be accepted.
+     * to be accepted. Empty string is a valid targeting key value.
      *
      * @param targetingKey targeting key
      * @param attributes   evaluation context attributes
      */
     public MutableContext(String targetingKey, Map<String, Value> attributes) {
         this.structure = new MutableStructure(new HashMap<>(attributes));
-        if (targetingKey != null && !targetingKey.trim().isEmpty()) {
+        if (targetingKey != null) {
             this.structure.attributes.put(TARGETING_KEY, new Value(targetingKey));
         }
     }
@@ -85,10 +85,11 @@ public MutableContext add(String key, List<Value> value) {
     }
 
     /**
-     * Override or set targeting key for this mutable context. Value should be non-null and non-empty to be accepted.
+     * Override or set targeting key for this mutable context. Value should be non-null to be accepted.
+     * Empty string is a valid targeting key value.
      */
     public MutableContext setTargetingKey(String targetingKey) {
-        if (targetingKey != null && !targetingKey.trim().isEmpty()) {
+        if (targetingKey != null) {
             this.add(TARGETING_KEY, targetingKey);
         }
         return this;

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

@@ -40,16 +40,17 @@ void shouldChangeTargetingKeyFromOverridingContext() {
         assertEquals("overriding_key", merge.getTargetingKey());
     }
 
-    @DisplayName("targeting key should not changed from the overriding context if missing")
+    @DisplayName("targeting key should be changed from the overriding context even if empty string")
     @Test
-    void shouldRetainTargetingKeyWhenOverridingContextTargetingKeyValueIsEmpty() {
+    void shouldOverrideTargetingKeyWhenOverridingContextTargetingKeyIsEmptyString() {
         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());
+        // Empty string is a valid targeting key and should override
+        assertEquals("", merge.getTargetingKey());
     }
 
     @DisplayName("missing targeting key should return null")
@@ -59,6 +60,21 @@ void missingTargetingKeyShould() {
         assertEquals(null, ctx.getTargetingKey());
     }
 
+    @DisplayName("empty string is a valid targeting key via constructor")
+    @Test
+    void emptyStringIsValidTargetingKeyViaConstructor() {
+        EvaluationContext ctx = new MutableContext("");
+        assertEquals("", ctx.getTargetingKey());
+    }
+
+    @DisplayName("empty string is a valid targeting key via setter")
+    @Test
+    void emptyStringIsValidTargetingKeyViaSetter() {
+        MutableContext ctx = new MutableContext();
+        ctx.setTargetingKey("");
+        assertEquals("", ctx.getTargetingKey());
+    }
+
     @DisplayName("Merge should retain all the attributes from the existing context when overriding context is null")
     @Test
     void mergeShouldReturnAllTheValuesFromTheContextWhenOverridingContextIsNull() {