refactor: rename test from 'decide_holdoutApplied_basic' to 'decide_with_holdout' to accurately reflect the functionality being tested

Author: muzahidul-opti

core-api/src/test/java/com/optimizely/ab/OptimizelyUserContextTest.java

@@ -2102,7 +2102,7 @@ OptimizelyDecision callDecideWithIncludeReasons(String flagKey) {
     }
 
     @Test
-    public void decide_holdoutApplied_basic() throws Exception {
+    public void decide_with_holdout() throws Exception {
         Optimizely optWithHoldout = createOptimizelyWithHoldouts();
         // pick a flag that is eligible for basic_holdout. Using boolean_feature from config.
         String flagKey = "boolean_feature";
@@ -2139,4 +2139,114 @@ public void decide_holdoutApplied_basic() throws Exception {
             .build();
         eventHandler.expectImpression(experimentId, variationId, userId, Collections.emptyMap(), metadata);
     }
+
+    @Test
+    public void decide_for_keys_with_holdout() throws Exception {
+        Optimizely optWithHoldout = createOptimizelyWithHoldouts();
+        String userId = "user123";
+        Map<String, Object> attrs = new HashMap<>();
+        attrs.put("$opt_bucketing_id", "ppid300002"); // deterministic bucketing used in prior holdout test
+        OptimizelyUserContext user = optWithHoldout.createUserContext(userId, attrs);
+
+        List<String> flagKeys = Arrays.asList(
+            "boolean_feature",                    // previously validated basic_holdout membership
+            "double_single_variable_feature",     // also subject to global/basic holdout
+            "integer_single_variable_feature"     // also subject to global/basic holdout
+        );
+
+        Map<String, OptimizelyDecision> decisions = user.decideForKeys(flagKeys, Collections.singletonList(OptimizelyDecideOption.INCLUDE_REASONS));
+        assertEquals(3, decisions.size());
+
+        String holdoutExperimentId = "10075323428"; // basic_holdout id
+        String variationId = "$opt_dummy_variation_id";
+        String variationKey = "ho_off_key";
+        String expectedReason = "User (" + userId + ") is in variation (" + variationKey + ") of holdout (basic_holdout).";
+
+        for (String flagKey : flagKeys) {
+            OptimizelyDecision d = decisions.get(flagKey);
+            assertNotNull(d);
+            assertEquals(flagKey, d.getFlagKey());
+            assertEquals(variationKey, d.getVariationKey());
+            assertFalse(d.getEnabled());
+            assertTrue("Expected holdout reason for flag " + flagKey, d.getReasons().contains(expectedReason));
+            DecisionMetadata metadata = new DecisionMetadata.Builder()
+                .setFlagKey(flagKey)
+                .setRuleKey("basic_holdout")
+                .setRuleType("holdout")
+                .setVariationKey(variationKey)
+                .setEnabled(false)
+                .build();
+            // attributes map expected empty (reserved $opt_ attribute filtered out)
+            eventHandler.expectImpression(holdoutExperimentId, variationId, userId, Collections.emptyMap(), metadata);
+        }
+
+        // At least one log message confirming holdout membership
+        logbackVerifier.expectMessage(Level.INFO, expectedReason);
+    }
+
+    @Test
+    public void decide_all_with_holdout() throws Exception {
+
+        Optimizely optWithHoldout = createOptimizelyWithHoldouts();
+        String userId = "user123";
+        Map<String, Object> attrs = new HashMap<>();
+        // ppid120000 buckets user into holdout_included_flags
+        attrs.put("$opt_bucketing_id", "ppid120000");
+        OptimizelyUserContext user = optWithHoldout.createUserContext(userId, attrs);
+
+        // All flag keys present in holdouts-project-config.json
+        List<String> allFlagKeys = Arrays.asList(
+            "boolean_feature",
+            "double_single_variable_feature",
+            "integer_single_variable_feature",
+            "boolean_single_variable_feature",
+            "string_single_variable_feature",
+            "multi_variate_feature",
+            "multi_variate_future_feature",
+            "mutex_group_feature"
+        );
+
+        // Flags INCLUDED in holdout_included_flags (only these should be holdout decisions)
+        List<String> includedInHoldout = Arrays.asList(
+            "boolean_feature",
+            "double_single_variable_feature",
+            "integer_single_variable_feature"
+        );
+
+        Map<String, OptimizelyDecision> decisions = user.decideAll(Arrays.asList(
+            OptimizelyDecideOption.INCLUDE_REASONS,
+            OptimizelyDecideOption.DISABLE_DECISION_EVENT
+        ));
+        assertEquals(allFlagKeys.size(), decisions.size());
+
+        String holdoutExperimentId = "1007543323427"; // holdout_included_flags id
+        String variationId = "$opt_dummy_variation_id";
+        String variationKey = "ho_off_key";
+        String expectedReason = "User (" + userId + ") is in variation (" + variationKey + ") of holdout (holdout_included_flags).";
+
+        int holdoutCount = 0;
+        for (String flagKey : allFlagKeys) {
+            OptimizelyDecision d = decisions.get(flagKey);
+            assertNotNull("Missing decision for flag " + flagKey, d);
+            if (includedInHoldout.contains(flagKey)) {
+                // Should be holdout decision
+                assertEquals(variationKey, d.getVariationKey());
+                assertFalse(d.getEnabled());
+                assertTrue("Expected holdout reason for flag " + flagKey, d.getReasons().contains(expectedReason));
+                DecisionMetadata metadata = new DecisionMetadata.Builder()
+                    .setFlagKey(flagKey)
+                    .setRuleKey("holdout_included_flags")
+                    .setRuleType("holdout")
+                    .setVariationKey(variationKey)
+                    .setEnabled(false)
+                    .build();
+                holdoutCount++;
+            } else {
+                // Should NOT be a holdout decision
+                assertFalse("Non-included flag should not have holdout reason: " + flagKey, d.getReasons().contains(expectedReason));
+            }
+        }
+        assertEquals("Expected exactly the included flags to be in holdout", includedInHoldout.size(), holdoutCount);
+        logbackVerifier.expectMessage(Level.INFO, expectedReason);
+    }
 }