feat(fractional): support nested JSON Logic expressions as bucket variant names

The operator already recurses into array elements via evaluator.evaluate(),
so nested expressions (if, var, fractional) in bucket variant positions
worked at runtime. The only blocker was the JSON Schema enforcing
"type": "string" for fractionalWeightArg[0].

Change fractionalWeightArg first element to oneOf[string, anyRule] so
the schema accepts JSON Logic objects as variant names in strict mode.

Also:
- pub mod fractional (was private) to allow direct access in tests
- Add integration tests for nested if, nested fractional, and var
  as bucket variant names (closes #30)
- Add statistical distribution uniformity test (mirrors Java PR #1740)
- Add boundary-key test (mirrors Java PR #1740 edgeCasesDoNotThrow)

Signed-off-by: Simon Schrottner <simon.schrottner@aepfli.at>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Signed-off-by: Simon Schrottner <simon.schrottner@dynatrace.com>

Author: aepfli

schemas/targeting.json

@@ -461,8 +461,15 @@
       "maxItems": 2,
       "items": [
         {
-          "description": "If this bucket is randomly selected, this string is used to as a key to retrieve the associated value from the \"variants\" object.",
-          "type": "string"
+          "description": "If this bucket is randomly selected, this value (or the string result of evaluating this JSON Logic expression) is used as a key to retrieve the associated value from the \"variants\" object.",
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "$ref": "#/definitions/anyRule"
+            }
+          ]
         },
         {
           "description": "Weighted distribution for this variant key.",

src/operators/mod.rs

@@ -21,7 +21,7 @@
 //! - `sem_ver.rs`: Semantic version comparison
 
 mod common;
-mod fractional;
+pub mod fractional;
 mod sem_ver;
 
 pub use fractional::FractionalOperator;

tests/integration_tests.rs

@@ -1463,3 +1463,201 @@ fn test_update_state_flag_set_metadata_replaces_on_second_call() {
     assert_eq!(m2.get("env"), Some(&json!("production")));
     assert_eq!(m2.get("owner"), Some(&json!("team-a")));
 }
+
+// ============================================================================
+// Nested fractional argument evaluation (flagd#1676)
+// ============================================================================
+
+/// Helper: create a strict evaluator and load config, panicking on failure.
+fn strict_eval_with(config: &str) -> FlagEvaluator {
+    let mut eval = FlagEvaluator::new(ValidationMode::Strict);
+    let resp = eval.update_state(config).unwrap();
+    assert!(resp.success, "update_state failed: {:?}", resp.error);
+    eval
+}
+
+#[test]
+fn test_nested_if_in_bucket_variant_name() {
+    use serde_json::json;
+    // Variant name is a {"if": ...} expression — same email maps to the same bucket,
+    // but the resolved variant depends on the locale context field.
+    let config = json!({
+        "flags": {
+            "color-flag": {
+                "state": "ENABLED",
+                "variants": {"red": "#FF0000", "grey": "#808080", "blue": "#0000FF"},
+                "defaultVariant": "grey",
+                "targeting": {
+                    "fractional": [
+                        {"var": "email"},
+                        [{"if": [{"in": [{"var": "locale"}, ["us", "ca"]]}, "red", "grey"]}, 50],
+                        ["blue", 50]
+                    ]
+                }
+            }
+        }
+    });
+    let eval = strict_eval_with(&config.to_string());
+
+    // jon@company.com hashes into the first bucket (verified by gherkin v2 test)
+    let ctx_us = json!({"email": "jon@company.com", "locale": "us"});
+    let ctx_de = json!({"email": "jon@company.com", "locale": "de"});
+
+    let res_us = eval.evaluate_flag("color-flag", ctx_us);
+    let res_de = eval.evaluate_flag("color-flag", ctx_de);
+
+    // Same email → same bucket, but different locale → different resolved variant
+    assert_eq!(
+        res_us.variant.as_deref(),
+        Some("red"),
+        "US locale should resolve to 'red'"
+    );
+    assert_eq!(
+        res_de.variant.as_deref(),
+        Some("grey"),
+        "DE locale should resolve to 'grey'"
+    );
+}
+
+#[test]
+fn test_nested_fractional_inside_fractional() {
+    use serde_json::json;
+    // Nested fractional: outer splits on email 50/50, inner splits on tier 50/50.
+    let config = json!({
+        "flags": {
+            "experiment": {
+                "state": "ENABLED",
+                "variants": {"red": 1, "blue": 2, "green": 3, "yellow": 4},
+                "defaultVariant": "red",
+                "targeting": {
+                    "fractional": [
+                        {"var": "email"},
+                        [{"fractional": [{"var": "tier"}, ["red", 50], ["blue", 50]]}, 50],
+                        [{"fractional": [{"var": "tier"}, ["green", 50], ["yellow", 50]]}, 50]
+                    ]
+                }
+            }
+        }
+    });
+    let eval = strict_eval_with(&config.to_string());
+
+    // All combinations should resolve to one of the four valid variants
+    for email in ["a@x.com", "b@x.com", "c@x.com", "d@x.com", "e@x.com"] {
+        for tier in ["free", "pro", "enterprise"] {
+            let ctx = json!({"email": email, "tier": tier});
+            let res = eval.evaluate_flag("experiment", ctx);
+            assert!(
+                ["red", "blue", "green", "yellow"].contains(&res.variant.as_deref().unwrap_or("")),
+                "email={email} tier={tier} → unexpected variant {:?}",
+                res.variant
+            );
+        }
+    }
+}
+
+#[test]
+fn test_nested_var_in_bucket_variant_name() {
+    use serde_json::json;
+    // Variant name is a {"var": "preferred_color"} — each user carries their own preference.
+    let config = json!({
+        "flags": {
+            "theme-flag": {
+                "state": "ENABLED",
+                "variants": {"dark": "dark-theme", "light": "light-theme"},
+                "defaultVariant": "light",
+                "targeting": {
+                    "fractional": [
+                        {"var": "email"},
+                        [{"var": "preferred_theme"}, 50],
+                        ["light", 50]
+                    ]
+                }
+            }
+        }
+    });
+    let eval = strict_eval_with(&config.to_string());
+
+    // jon@company.com hashes into first bucket; preferred_theme drives the variant
+    let ctx_dark = json!({"email": "jon@company.com", "preferred_theme": "dark"});
+    let ctx_light = json!({"email": "jon@company.com", "preferred_theme": "light"});
+
+    let res_dark = eval.evaluate_flag("theme-flag", ctx_dark);
+    let res_light = eval.evaluate_flag("theme-flag", ctx_light);
+
+    assert_eq!(res_dark.variant.as_deref(), Some("dark"));
+    assert_eq!(res_light.variant.as_deref(), Some("light"));
+}
+
+// ============================================================================
+// Statistical distribution test (mirrors Java PR #1740 statistics() test)
+// ============================================================================
+
+#[test]
+fn test_fractional_distribution_uniformity() {
+    use flagd_evaluator::operators::fractional::fractional;
+    use serde_json::json;
+
+    // 16 equal-weight buckets totalling i32::MAX (matches Java test exactly)
+    let total_weight: u64 = i32::MAX as u64;
+    let buckets_count: u64 = 16;
+    let weight = total_weight / buckets_count;
+    let remainder = total_weight - weight * (buckets_count - 1);
+
+    let mut bucket_defs: Vec<serde_json::Value> = Vec::new();
+    for i in 0..buckets_count - 1 {
+        bucket_defs.push(json!(format!("{}", i)));
+        bucket_defs.push(serde_json::Value::Number(weight.into()));
+    }
+    bucket_defs.push(json!(format!("{}", buckets_count - 1)));
+    bucket_defs.push(serde_json::Value::Number(remainder.into()));
+
+    let mut hits = vec![0u64; buckets_count as usize];
+
+    // 100k sequential keys — dense sample, fast, and tight enough for 10% tolerance.
+    for i in 0u64..100_000 {
+        let key = format!("{}", i);
+        let bucket_str = fractional(&key, &bucket_defs).unwrap();
+        let bucket_idx: usize = bucket_str.parse().unwrap();
+        hits[bucket_idx] += 1;
+    }
+
+    let min = *hits.iter().min().unwrap();
+    let max = *hits.iter().max().unwrap();
+    let delta = max - min;
+
+    let sample_size: u64 = 100_000;
+    let expected_per_bucket = sample_size / buckets_count;
+    let tolerance = expected_per_bucket / 10; // 10% tolerance
+
+    assert!(
+        delta < tolerance,
+        "Distribution imbalance too large: max={max} min={min} delta={delta} (tolerance={tolerance}). hits={hits:?}"
+    );
+}
+
+#[test]
+fn test_fractional_boundary_hashes_do_not_panic() {
+    use flagd_evaluator::operators::fractional::fractional;
+    use serde_json::json;
+
+    let buckets = vec![
+        json!("a"),
+        json!(4),
+        json!("b"),
+        json!(4),
+        json!("c"),
+        json!(4),
+        json!("d"),
+        json!(4),
+    ];
+
+    // Keys chosen to produce boundary-adjacent hash values
+    for key in ["", "0", "a", "\0", "ffffffff"] {
+        let result = fractional(key, &buckets);
+        assert!(result.is_ok(), "key={key:?} should not error: {:?}", result);
+        assert!(
+            ["a", "b", "c", "d"].contains(&result.unwrap().as_str()),
+            "key={key:?} must map to a valid bucket"
+        );
+    }
+}