Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

35.7 KB
Raw Blame
use std::sync::Arc;

use feature_flags::flags::config_v2::{
    Config, Outcome, ParseError, RolloutMiss, MAX_CONFIG_BYTES, MAX_OBJECT_DEPTH, MAX_VARIANTS,
};
use feature_flags::flags::feature_flag_list::PreparedFlags;
use feature_flags::flags::flag_models::{
    EvaluationMetadata, FeatureFlag, FeatureFlagRow, HypercacheFlagsWrapper,
    PreparedFlagDefinitions,
};
use feature_flags::properties::property_models::OperatorType;
use serde_json::{json, Value};

#[path = "test_config_v2/fixtures.rs"]
mod fixtures;

fn config() -> Value {
    json!({
        "version": 2, "return_type": "boolean", "default_value": false,
        "rules": [{
            "id": "11111111-1111-4111-8111-111111111111", "rule_type": "percentage_rollout",
            "targeting": {"properties": []}, "value": true, "rollout_percentage": 33.33,
            "on_rollout_miss": "continue", "assignment_algorithm": "sha1_60_v1", "seed": "example-seed"
        }]
    })
}

fn read(filters: Value) -> FeatureFlag {
    serde_json::from_value(json!({
        "id": 1, "team_id": 1, "key": "example", "active": true, "version": 42, "filters": filters
    }))
    .unwrap()
}

fn read_raw(document: &str) -> FeatureFlag {
    serde_json::from_str(&format!(
        r#"{{"id":1,"team_id":1,"key":"example","active":true,"filters":{document}}}"#
    ))
    .unwrap()
}

fn result(flag: &FeatureFlag) -> &Result<Config, ParseError> {
    flag.filters
        .non_v1
        .as_deref()
        .and_then(|config| config.parsed_v2.as_ref())
        .expect("recognized v2 must retain its parse result")
}

#[test]
fn original_numeric_tokens_control_precision_and_survive_cache_round_trips() {
    for hundredths in 0..=10_000 {
        for number in [
            format!("{}.{:02}", hundredths / 100, hundredths % 100),
            format!("{hundredths}e-2"),
            if hundredths == 0 {
                "0e-27".to_owned()
            } else {
                format!("{hundredths}0000000000000000000000000e-27")
            },
        ] {
            let document = config().to_string().replace("33.33", &number);
            let flag = read_raw(&document);
            let parsed = result(&flag)
                .as_ref()
                .unwrap_or_else(|error| panic!("{number}: {error:?}"));
            match parsed.rules[0].outcome {
                Outcome::PercentageRollout {
                    rollout_percentage, ..
                } => assert_eq!(
                    rollout_percentage,
                    number.parse::<f64>().unwrap(),
                    "{number}"
                ),
                _ => unreachable!(),
            }
        }
    }
    for (number, accepted) in [
        ("33.33", true),
        ("3333e-2", true),
        ("0.0001e2", true),
        ("33.330000000000000000000000000000000000000", true),
        ("33.330000000000000001", false),
        ("100.000000000000000001", false),
        ("1e-400", false),
        ("1e400", false),
    ] {
        let document = config().to_string().replace("33.33", number);
        let flag = read_raw(&document);
        assert_eq!(result(&flag).is_ok(), accepted, "{number}");
        let round_trip = serde_json::to_string(&flag).unwrap();
        assert!(round_trip.contains(number), "{number}");
        let decoded: FeatureFlag = serde_json::from_str(&round_trip).unwrap();
        assert_eq!(result(&decoded).is_ok(), accepted, "{number}");
    }
}

#[test]
fn version_discriminator_rounds_to_binary64() {
    for digits in 15..=80 {
        for number in [
            format!("0.{}", "9".repeat(digits)),
            format!("1.{}1", "0".repeat(digits)),
            format!("1.{}", "9".repeat(digits)),
            format!("2.{}1", "0".repeat(digits)),
        ] {
            let document = config()
                .to_string()
                .replace("\"version\":2", &format!("\"version\":{number}"));
            let flag = read_raw(&document);
            let expected = number.parse::<f64>().unwrap();
            assert_eq!(flag.filters.non_v1.is_none(), expected == 1.0, "{number}");
            if let Some(non_v1) = &flag.filters.non_v1 {
                assert_eq!(non_v1.parsed_v2.is_some(), expected == 2.0, "{number}");
            }
        }
    }
    for (number, recognized_v2) in [
        ("2.0", true),
        ("20e-1", true),
        ("2.0000000000000001", true),
        ("1.0000000000000001", false),
    ] {
        let document = config()
            .to_string()
            .replace("\"version\":2", &format!("\"version\":{number}"));
        let flag = read_raw(&document);
        assert_eq!(flag.filters.non_v1.is_some(), recognized_v2, "{number}");
        if recognized_v2 {
            assert!(result(&flag).is_ok());
            assert!(serde_json::to_string(&flag).unwrap().contains(number));
        }
    }
}

#[test]
fn raw_v2_constraints_reject_duplicates_and_underflow_only_in_the_affected_flag() {
    for (raw, field) in [
        (r#"{"version":2,"version":2,"return_type":"boolean","default_value":null,"rules":[]}"#.to_owned(), "json_keys_unique"),
        (config().to_string().replace("\"value\":true", "\"value\":false,\"value\":true"), "json_keys_unique"),
        (config().to_string().replace("\"properties\":[]", r#""properties":[{"key":"example","key":"other","type":"person"}]"#), "json_keys_unique"),
        (config().to_string().replace("\"properties\":[]", r#""properties":[{"key":"example","type":"person","value":{"items":[{"x":1,"\u0078":2}]}}]"#), "json_keys_unique"),
        (config().to_string().replace("\"seed\":", r#""metadata":{"nested":{"x":1,"x":2}},"seed":"#), "json_keys_unique"),
    ] {
        let flag = read_raw(&raw);
        assert_eq!(result(&flag).as_ref().unwrap_err(), &ParseError::Malformed(field), "{raw}");
        let encoded = serde_json::to_string(&flag).unwrap();
        assert!(encoded.contains(&raw));
        let wrapper = format!(r#"{{"flags":[{encoded},{{"id":2,"team_id":1,"key":"healthy","filters":{{"groups":[{{"rollout_percentage":100}}]}}}}],"evaluation_metadata":{{"dependency_stages":[[1,2]],"flags_with_missing_deps":[],"transitive_deps":{{}}}}}}"#);
        let wrapper: HypercacheFlagsWrapper = serde_json::from_str(&wrapper).unwrap();
        assert!(result(&wrapper.flags[0]).is_err());
        assert_eq!(wrapper.flags[1].filters.groups.len(), 1);
    }
    for (number, valid) in [
        ("1e-400", false),
        ("-1e-400", false),
        ("1e400", false),
        ("-1e400", false),
        ("5e-324", true),
        ("-5e-324", true),
        ("0e-400", true),
        ("-0.0", true),
    ] {
        for property in [
            format!(r#"{{"key":"example","type":"person","operator":"gt","value":{number}}}"#),
            format!(r#"{{"key":"example","type":"person","value":{{"nested":[{number}]}}}}"#),
        ] {
            let raw = config()
                .to_string()
                .replace("\"properties\":[]", &format!("\"properties\":[{property}]"));
            let flag = read_raw(&raw);
            assert_eq!(result(&flag).is_ok(), valid, "{number}");
            if !valid {
                assert_eq!(
                    result(&flag).as_ref().unwrap_err(),
                    &ParseError::Malformed("number_is_binary64")
                );
            }
        }
    }
    let mut document = config();
    document["rules"][0]["metadata"] = json!({"rollout_percentage": 0.001, "text": "\"duplicate\":1,\"duplicate\":1e-400 \\ braces{}[]", "distinct": [{"same":1},{"same":2}]});
    assert!(result(&read(document)).is_ok());
    let legacy = read_raw(r#"{"groups":[],"extra":{"key":1,"key":2,"tiny":1e-400}}"#);
    assert!(legacy.filters.non_v1.is_none());
    assert_eq!(legacy.filters.extra["extra"]["key"], 2);
    assert_eq!(legacy.filters.extra["extra"]["tiny"].as_f64(), Some(0.0));
}

#[test]
fn supported_values_and_order_survive_the_reader() {
    for default in [json!(true), json!(false), Value::Null] {
        for percentage in [0.0, 0.01, 1.01, 33.33, 99.99, 100.0] {
            for policy in ["continue", "return_default"] {
                let mut document = config();
                document["default_value"] = default.clone();
                document["rules"][0]["rollout_percentage"] = json!(percentage);
                document["rules"][0]["on_rollout_miss"] = json!(policy);
                document["rules"].as_array_mut().unwrap().push(json!({
                    "id": "22222222-2222-4222-8222-222222222222", "rule_type": "targeted_release",
                    "targeting": {"properties": []}, "value": false,
                    "description": "Example display text", "metadata": {"opaque": [null, {"anything": true}]}
                }));
                let flag = read(document.clone());
                let parsed = result(&flag).as_ref().unwrap();
                assert_eq!(
                    parsed.default_value,
                    (!default.is_null()).then(|| default.clone())
                );
                assert_eq!(parsed.rules.len(), 2);
                assert_eq!(parsed.rules[0].id.to_string(), document["rules"][0]["id"]);
                match &parsed.rules[0].outcome {
                    Outcome::PercentageRollout {
                        value,
                        rollout_percentage,
                        on_rollout_miss,
                        seed,
                    } => {
                        assert_eq!(*value, json!(true));
                        assert_eq!(*rollout_percentage, percentage);
                        assert_eq!(
                            *on_rollout_miss,
                            if policy == "continue" {
                                RolloutMiss::Continue
                            } else {
                                RolloutMiss::ReturnDefault
                            }
                        );
                        assert_eq!(seed, "example-seed");
                    }
                    other => panic!("unexpected outcome {other:?}"),
                }
                assert!(matches!(
                    parsed.rules[1].outcome,
                    Outcome::TargetedRelease {
                        value: Value::Bool(false)
                    }
                ));
                assert_eq!(serde_json::to_value(&flag).unwrap()["filters"], document);
            }
        }
        let flag = read(
            json!({"version": 2.0, "return_type": "boolean", "default_value": default, "rules": []}),
        );
        assert!(result(&flag).as_ref().unwrap().rules.is_empty());
        assert_eq!(flag.version, Some(42));
    }
}

#[test]
fn required_and_closed_fields_fail_without_losing_the_original_document() {
    for pointer in [
        "/return_type",
        "/default_value",
        "/rules",
        "/rules/0/id",
        "/rules/0/rule_type",
        "/rules/0/targeting",
        "/rules/0/targeting/properties",
        "/rules/0/value",
        "/rules/0/rollout_percentage",
        "/rules/0/on_rollout_miss",
        "/rules/0/assignment_algorithm",
        "/rules/0/seed",
    ] {
        let mut document = config();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        document
            .pointer_mut(parent)
            .unwrap()
            .as_object_mut()
            .unwrap()
            .remove(key);
        let flag = read(document.clone());
        assert!(
            matches!(result(&flag), Err(ParseError::Malformed(_))),
            "{pointer}"
        );
        assert!(serde_json::to_string(&flag)
            .unwrap()
            .contains(&format!("\"filters\":{document}")));
    }
    for (pointer, value) in [
        ("/groups", json!(false)),
        ("/multivariate", json!("bad-v1")),
        ("/unknown", json!(true)),
        ("/rules/0/unknown", json!(true)),
        ("/rules/0/targeting/unknown", json!(true)),
        ("/default_value", json!(0)),
        ("/default_value", json!("false")),
        ("/rules", Value::Null),
        ("/rules", json!({})),
        ("/rules/0", Value::Null),
        ("/rules/0/targeting", json!([])),
        ("/rules/0/targeting/properties", Value::Null),
        ("/rules/0/value", Value::Null),
        ("/rules/0/value", json!(1)),
        ("/rules/0/id", json!("11111111111141118111111111111111")),
        (
            "/rules/0/id",
            json!("urn:uuid:11111111-1111-4111-8111-111111111111"),
        ),
        ("/rules/0/id", json!("zzzzzzzz-1111-4111-8111-111111111111")),
        ("/rules/0/seed", json!("")),
        ("/rules/0/seed", json!("é".repeat(401))),
        ("/rules/0/seed", Value::Null),
        ("/rules/0/description", Value::Null),
        ("/rules/0/metadata", json!([])),
        ("/rules/0/assign_by", json!("device_id")),
        ("/rules/0/assign_by", Value::Null),
        ("/rules/0/assignment_algorithm", json!("future")),
        ("/rules/0/on_rollout_miss", json!("ignore")),
        ("/rules/0/on_rollout_miss", Value::Null),
        ("/rules/0/rule_type", json!("variant_rollout")),
        ("/aggregation_group_type_index", Value::Null),
        ("/rules/0/rollout_percentage", json!(-0.01)),
        ("/rules/0/rollout_percentage", json!(100.01)),
        ("/rules/0/rollout_percentage", json!(33.333)),
        ("/rules/0/rollout_percentage", json!(33.33000000000001)),
        ("/rules/0/rollout_percentage", json!(1e-30)),
        ("/rules/0/rollout_percentage", json!(true)),
        ("/rules/0/rollout_percentage", json!("33.33")),
    ] {
        let mut document = config();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        if let Some(map) = document.pointer_mut(parent).unwrap().as_object_mut() {
            map.insert(key.to_owned(), value);
        } else {
            *document.pointer_mut(pointer).unwrap() = value;
        }
        let flag = read(document.clone());
        assert!(
            matches!(result(&flag), Err(ParseError::Malformed(_))),
            "{pointer}"
        );
        assert!(serde_json::to_string(&flag)
            .unwrap()
            .contains(&format!("\"filters\":{document}")));
    }
}

#[test]
fn semantic_limits_and_duplicate_ids_are_enforced() {
    let mut document = config();
    document["rules"][0]["seed"] = json!("é".repeat(400));
    assert!(result(&read(document.clone())).is_ok());
    let repeated = document["rules"][0].clone();
    document["rules"].as_array_mut().unwrap().push(repeated);
    assert_eq!(
        result(&read(document.clone())).as_ref().unwrap_err(),
        &ParseError::Malformed("rule.id")
    );
    let mut document = config();
    document["rules"] = Value::Array(
        (0..100)
            .map(|n| {
                let mut rule = config()["rules"][0].clone();
                rule["id"] = json!(format!("{n:08x}-1111-4111-8111-111111111111"));
                rule
            })
            .collect(),
    );
    assert!(result(&read(document.clone())).is_ok());
    let rule = document["rules"][0].clone();
    document["rules"].as_array_mut().unwrap().push(rule);
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::LimitExceeded("rules")
    );
    let mut document = config();
    document["rules"][0]["targeting"]["properties"] = Value::Array(
        (0..100)
            .map(|n| json!({"key": format!("tier-{n}"), "type": "person"}))
            .collect(),
    );
    let flag = read(document.clone());
    let predicates = &result(&flag).as_ref().unwrap().rules[0].targeting;
    assert_eq!(predicates.len(), 100);
    for (n, predicate) in predicates.iter().enumerate() {
        assert_eq!(predicate.key, format!("tier-{n}"));
    }
    document["rules"][0]["targeting"]["properties"]
        .as_array_mut()
        .unwrap()
        .push(json!({"key": "tier", "type": "person"}));
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::LimitExceeded("properties")
    );
    let mut document = config();
    document["rules"][0]["metadata"] = json!({"display": "x".repeat(*MAX_CONFIG_BYTES)});
    let flag = read(document.clone());
    assert_eq!(
        result(&flag).as_ref().unwrap_err(),
        &ParseError::LimitExceeded("filters")
    );
    assert_eq!(serde_json::to_value(flag).unwrap()["filters"], document);

    let mut document = config();
    document["rules"][0]["metadata"] = json!({"display": ""});
    let padding = *MAX_CONFIG_BYTES - document.to_string().len();
    document["rules"][0]["metadata"]["display"] = json!("x".repeat(padding));
    let raw = serde_json::to_string_pretty(&document).unwrap();
    let encoded = format!(r#"{{"id":1,"team_id":1,"key":"example","filters":{raw}}}"#);
    let flag: FeatureFlag = serde_json::from_str(&encoded).unwrap();
    assert!(result(&flag).is_ok());
    document["rules"][0]["metadata"]["display"] = json!("x".repeat(padding + 1));
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::LimitExceeded("filters")
    );

    // Arrays count toward the object depth, and numbers inside them keep the safe range.
    let mut deepest = json!("leaf");
    for _ in 1..MAX_OBJECT_DEPTH {
        deepest = json!([deepest]);
    }
    for (value, accepted) in [
        (json!({"list": deepest.clone()}), true),
        (json!({"list": [deepest]}), false),
        (json!({"limits": [9_007_199_254_740_991_u64]}), true),
        (json!({"limits": [9_007_199_254_740_992_u64]}), false),
        (json!({"limits": [-9_007_199_254_740_992_i64]}), false),
    ] {
        let mut document = config();
        document["return_type"] = json!("object");
        document["default_value"] = Value::Null;
        document["rules"][0]["value"] = value;
        let flag = read(document);
        if accepted {
            assert!(result(&flag).is_ok());
        } else {
            assert_eq!(
                result(&flag).as_ref().unwrap_err(),
                &ParseError::Malformed("value")
            );
        }
    }
}

fn person_property_cases() -> Vec<(&'static str, Value)> {
    vec![
        ("exact", json!(["preview"])),
        ("is_not", json!(false)),
        ("is_set", Value::Null),
        ("is_not_set", Value::Null),
        ("regex", json!("^preview$")),
        ("not_regex", json!("[")),
        ("icontains", json!("view")),
        ("not_icontains", json!("view")),
        ("starts_with", json!("pre")),
        ("not_starts_with", json!("pre")),
        ("ends_with", json!("view")),
        ("not_ends_with", json!("view")),
        ("icontains_multi", json!(["a", "b"])),
        ("not_icontains_multi", json!([])),
        ("gt", json!(2)),
        ("gte", json!("2")),
        ("lt", json!(3.5)),
        ("lte", json!("3.5")),
        ("is_date_exact", json!("2024-01-01")),
        ("is_date_after", json!("-7d")),
        ("is_date_before", json!("2024-01-01T00:00:00Z")),
        ("semver_gt", json!("1.2.3")),
        ("semver_eq", json!(" 1.2.3 ")),
        ("semver_gte", json!("1.2.3")),
        ("semver_lt", json!("1.2.3")),
        ("semver_lte", json!("1.2.3")),
        ("semver_eq", json!("1.2.3")),
        ("semver_neq", json!("1.2.3")),
        ("semver_tilde", json!("1.2")),
        ("semver_caret", json!("1.2.3")),
        ("semver_wildcard", json!("1.2.*")),
        ("semver_eq", json!("01.2.3-rc.1")),
        ("semver_eq", json!("1.2.3-alpha+build.01")),
        ("semver_eq", json!("18446744073709551615.0.0")),
    ]
}

#[test]
fn person_properties_are_closed_before_reusing_operator_types() {
    for (operator, value) in person_property_cases() {
        let mut document = config();
        document["rules"][0]["targeting"]["properties"] = json!([{
            "key": "example", "type": "person", "operator": operator, "value": value,
            "negation": true, "group_type_index": null, "label": "Display", "cohort_name": null,
            "group_key_names": {"0": "Display only"}
        }]);
        let flag = read(document);
        let parsed = result(&flag)
            .as_ref()
            .unwrap_or_else(|error| panic!("{operator}: {error:?}"));
        let property = &parsed.rules[0].targeting[0];
        assert_eq!(property.key, "example");
        assert_eq!(serde_json::to_value(property.operator).unwrap(), operator);
        assert!(property.negation);
        assert_eq!(
            property.value,
            if value.is_null() { None } else { Some(value) }
        );
    }
    for property in [
        json!({"key": "tier", "type": "person"}),
        json!({"key": "tier", "type": "person", "operator": null, "value": null, "negation": null}),
    ] {
        let mut document = config();
        document["rules"][0]["targeting"]["properties"] = json!([property]);
        let flag = read(document);
        let predicate = &result(&flag).as_ref().unwrap().rules[0].targeting[0];
        assert_eq!(predicate.operator, OperatorType::Exact);
        assert!(!predicate.negation);
    }
    for (field, value) in [
        ("key", json!(42)),
        ("key", json!("")),
        ("type", json!("person_metadata")),
        ("operator", json!("min")),
        ("operator", json!("max")),
        ("operator", json!("between")),
        ("operator", json!("in")),
        ("operator", json!("not_in")),
        ("operator", json!("flag_evaluates_to")),
        ("operator", json!("unknown")),
        ("operator", json!(true)),
        ("negation", json!("false")),
        ("group_type_index", json!(0)),
        ("label", json!(false)),
        ("cohort_name", json!([])),
        ("group_key_names", json!({"0": false})),
        ("extra", json!(true)),
    ] {
        let mut document = config();
        let mut property = json!({"key": "tier", "type": "person", "value": "preview"});
        property[field] = value;
        document["rules"][0]["targeting"]["properties"] = json!([property]);
        assert!(
            matches!(result(&read(document)), Err(ParseError::Malformed(_))),
            "{field}"
        );
    }
    for (operator, value) in [
        ("regex", json!(1)),
        ("icontains_multi", json!("x")),
        ("gt", json!(false)),
        ("is_date_exact", json!("not-a-date")),
        ("is_date_exact", json!("-10000d")),
        ("semver_gt", json!("not-a-version")),
        ("semver_gt", json!(123)),
        ("semver_eq", json!("1.2.3+meta")),
        ("semver_eq", json!("v1.2.3")),
        ("semver_eq", json!("+1.2.3")),
        ("semver_eq", json!("1. 2.3")),
        ("semver_eq", json!("1.+2.3")),
        ("semver_eq", json!("1.2.3.4")),
        ("semver_tilde", json!("1.2.3.4")),
        ("semver_wildcard", json!("1.2.3.4.*")),
        ("semver_eq", json!("1.2.3-")),
        ("semver_eq", json!("1.2.3-01")),
        ("semver_eq", json!("1.2.3-a_b")),
        ("semver_eq", json!("1_0.2.3")),
        ("semver_eq", json!("18446744073709551616.0.0")),
    ] {
        let mut document = config();
        document["rules"][0]["targeting"]["properties"] =
            json!([{"key": "example", "type": "person", "operator": operator, "value": value}]);
        assert_eq!(
            result(&read(document)).as_ref().unwrap_err(),
            &ParseError::Malformed("property.value")
        );
    }
}

#[test]
fn unsupported_members_reject_the_whole_flag_and_debug_redacts_config() {
    for property_type in ["cohort", "group", "flag"] {
        let mut document = config();
        document["rules"][0]["targeting"]["properties"] = json!([
            {"key": "tier", "type": "person", "value": "preview"},
            {"key": "id", "type": property_type, "value": "private-property-value"}
        ]);
        assert_eq!(
            result(&read(document)).as_ref().unwrap_err(),
            &ParseError::Unsupported("property.type")
        );
    }
    let mut document = config();
    document["aggregation_group_type_index"] = json!(0);
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::Unsupported("aggregation_group_type_index")
    );
    for version in [json!(2), json!(3), json!("private-version")] {
        let mut document = config();
        document["version"] = version;
        document["rules"][0]["seed"] = json!("private-seed");
        document["rules"][0]["metadata"] = json!({"private-metadata": "private-metadata-value"});
        document["rules"][0]["targeting"]["properties"] =
            json!([{"key": "private-key", "type": "person", "value": "private-property-value"}]);
        let row = FeatureFlagRow {
            id: 1,
            team_id: 2,
            key: "example".to_owned(),
            active: true,
            version: Some(42),
            filters: document.clone(),
            ..Default::default()
        };
        let debug = format!("{row:?}");
        assert!(debug.contains("key: \"example\""));
        assert!(debug.contains("active: true"));
        assert!(debug.contains("version: Some(42)"));
        assert!(!debug.contains("private-"), "{debug}");
        let flag = read(document);
        let debug = format!("{flag:?}");
        assert!(!debug.contains("private-"), "{debug}");
        if let Some(Ok(parsed)) = flag
            .filters
            .non_v1
            .as_deref()
            .and_then(|config| config.parsed_v2.as_ref())
        {
            assert!(!format!("{:?}", parsed.rules).contains("private-"));
            assert!(!format!("{:?}", parsed.rules[0].targeting).contains("private-"));
        }
    }
}

#[test]
fn preparation_reuses_parsing_and_accounts_for_raw_and_typed_data() {
    let mut document = config();
    document["rules"][0]["metadata"] = json!({"display": "x".repeat(8192)});
    document["rules"][0]["targeting"]["properties"] =
        json!([{"key": "tier", "type": "person", "value": "preview"}]);
    let flag = read(document.clone());
    let parsed = Arc::clone(flag.filters.non_v1.as_ref().unwrap());
    let mut raw_only = flag.clone();
    Arc::make_mut(raw_only.filters.non_v1.as_mut().unwrap()).parsed_v2 = None;
    let prepared = |flag| PreparedFlagDefinitions {
        flags: PreparedFlags::seal(vec![flag]),
        evaluation_metadata: Arc::new(EvaluationMetadata::default()),
        cohorts: None,
    };
    let parsed_flags = prepared(flag);
    let raw_flags = prepared(raw_only);
    assert!(parsed_flags.estimated_size_bytes() > raw_flags.estimated_size_bytes());
    assert!(raw_flags.estimated_size_bytes() > 8192);
    assert!(Arc::ptr_eq(
        &parsed,
        parsed_flags.flags[0].filters.non_v1.as_ref().unwrap()
    ));
    assert!(parsed_flags.flags[0].filters.groups.is_empty());
    assert_eq!(
        serde_json::to_value(&parsed_flags.flags[0]).unwrap()["filters"],
        document
    );
    let wrapper: HypercacheFlagsWrapper = serde_json::from_value(json!({
        "flags": [serde_json::to_value(&parsed_flags.flags[0]).unwrap(), {
            "id": 2, "team_id": 1, "key": "healthy", "active": true,
            "filters": {"groups": [{"rollout_percentage": 100}]}
        }], "evaluation_metadata": {"dependency_stages": [[1, 2]], "flags_with_missing_deps": [], "transitive_deps": {"1": [], "2": []}}
    })).unwrap();
    assert!(result(&wrapper.flags[0]).is_ok());
    assert!(wrapper.flags[1].filters.non_v1.is_none());
    assert_eq!(wrapper.flags[1].filters.groups.len(), 1);

    let values = vec![json!({"items": vec![Value::Null; 1000]}); 50];
    let mut document = config();
    document["rules"][0]["targeting"]["properties"] =
        json!([{"key": "example", "type": "person", "value": values}]);
    let flag = read(document.clone());
    assert!(result(&flag).is_ok());
    let weighted = prepared(flag).estimated_size_bytes();
    assert!(weighted > document.to_string().len() + 50_000 * std::mem::size_of::<Value>());

    // The parsed default and each rule value count, not only their raw text.
    let object = json!({"items": vec![Value::Null; 1000]});
    let mut document = config();
    document["return_type"] = json!("object");
    document["default_value"] = object.clone();
    document["rules"][0]["value"] = object;
    let flag = read(document.clone());
    assert!(result(&flag).is_ok());
    let weighted = prepared(flag).estimated_size_bytes();
    assert!(weighted > document.to_string().len() + 2000 * std::mem::size_of::<Value>());
}

fn experiment() -> Value {
    json!({
        "version": 2, "return_type": "string", "default_value": "standard",
        "rules": [{
            "id": "11111111-1111-4111-8111-111111111111", "rule_type": "experiment",
            "targeting": {"properties": []}, "paused": false,
            "rollout_percentage": 80.5, "on_rollout_miss": "return_default",
            "assignment_algorithm": "sha1_60_v1", "seed": "example-seed", "assign_by": "person",
            "variants": [
                {"key": "control", "weight": 33.33, "value": "standard"},
                {"key": "test", "weight": 33.33, "value": "compact"},
                {"key": "test-copy", "weight": 33.34, "value": "compact"}
            ],
            "holdout": {"seed": "example-holdout", "exclusion_percentage": 10.25}
        }]
    })
}

#[test]
fn experiment_rules_parse_into_a_weighted_split() {
    let document = experiment();
    let flag = read(document.clone());
    let parsed = result(&flag).as_ref().unwrap();
    let Outcome::Experiment {
        paused,
        rollout_percentage,
        on_rollout_miss,
        seed,
        variants,
        holdout,
    } = &parsed.rules[0].outcome
    else {
        panic!("unexpected outcome {:?}", parsed.rules[0].outcome);
    };
    assert!(!paused);
    assert_eq!(*rollout_percentage, 80.5);
    assert_eq!(*on_rollout_miss, RolloutMiss::ReturnDefault);
    assert_eq!(seed, "example-seed");
    let summary: Vec<_> = variants
        .iter()
        .map(|v| (v.key.as_str(), v.weight, v.value.clone()))
        .collect();
    assert_eq!(
        summary,
        [
            ("control", 33.33, json!("standard")),
            ("test", 33.33, json!("compact")),
            ("test-copy", 33.34, json!("compact"))
        ]
    );
    let holdout = holdout.as_ref().unwrap();
    assert_eq!(
        (holdout.seed.as_str(), holdout.exclusion_percentage),
        ("example-holdout", 10.25)
    );
    assert_eq!(serde_json::to_value(&flag).unwrap()["filters"], document);
    let debug = format!("{:?}", parsed.rules);
    assert!(
        !debug.contains("example-") && !debug.contains("compact"),
        "{debug}"
    );

    let mut without_holdout = experiment();
    let rule = without_holdout["rules"][0].as_object_mut().unwrap();
    rule.remove("holdout");
    rule.remove("assign_by");
    assert!(result(&read(without_holdout)).is_ok());

    // `weight` and percentages inside values and metadata are not contract percentages.
    let mut nested = experiment();
    nested["return_type"] = json!("object");
    nested["default_value"] = json!({"weight": 0.125});
    for (index, variant) in nested["rules"][0]["variants"]
        .as_array_mut()
        .unwrap()
        .iter_mut()
        .enumerate()
    {
        variant["value"] = json!({"weight": 0.001, "rank": index});
    }
    nested["rules"][0]["metadata"] = json!({"exclusion_percentage": 0.001});
    assert!(result(&read(nested)).is_ok());
}

#[test]
fn experiment_rule_contract_violations_reject_the_whole_flag() {
    let cases: Vec<(&str, Value, ParseError)> = vec![
        (
            "/rules/0/experiment_id",
            json!(42),
            ParseError::Malformed("rule"),
        ),
        (
            "/rules/0/paused",
            json!("false"),
            ParseError::Malformed("paused"),
        ),
        (
            "/rules/0/holdout/id",
            json!(7),
            ParseError::Malformed("holdout"),
        ),
        (
            "/rules/0/holdout/id",
            Value::Null,
            ParseError::Malformed("holdout"),
        ),
        (
            "/rules/0/holdout/seed",
            json!(""),
            ParseError::Malformed("seed"),
        ),
        (
            "/rules/0/holdout/exclusion_percentage",
            json!(100.5),
            ParseError::Malformed("exclusion_percentage"),
        ),
        (
            "/rules/0/holdout/exclusion_percentage",
            json!(5.555),
            ParseError::Malformed("exclusion_percentage"),
        ),
        (
            "/rules/0/variants/1/key",
            json!("control"),
            ParseError::Malformed("variant.key"),
        ),
        (
            "/rules/0/variants/1/key",
            json!("test.v2"),
            ParseError::Malformed("variant.key"),
        ),
        (
            "/rules/0/variants/1/key",
            json!(""),
            ParseError::Malformed("variant.key"),
        ),
        (
            "/rules/0/variants/1/weight",
            json!(33.32),
            ParseError::Malformed("variants"),
        ),
        (
            "/rules/0/variants/1/weight",
            json!(33.34),
            ParseError::Malformed("variants"),
        ),
        (
            "/rules/0/variants/1/weight",
            json!(33.333),
            ParseError::Malformed("weight"),
        ),
        (
            "/rules/0/variants/1/weight",
            json!(-1),
            ParseError::Malformed("weight"),
        ),
        (
            "/rules/0/variants/1/value",
            json!(true),
            ParseError::Malformed("value"),
        ),
        (
            "/rules/0/variants/1/value",
            Value::Null,
            ParseError::Malformed("value"),
        ),
        (
            "/rules/0/variants/1/value",
            json!(""),
            ParseError::Malformed("value"),
        ),
        (
            "/rules/0/variants/1/label",
            json!("x"),
            ParseError::Malformed("variant"),
        ),
        (
            "/rules/0/holdout/name",
            json!("x"),
            ParseError::Malformed("holdout"),
        ),
        (
            "/rules/0/value",
            json!("compact"),
            ParseError::Malformed("rule"),
        ),
        (
            "/rules/0/variants",
            json!([{"key": "control", "weight": 100, "value": "standard"}]),
            ParseError::Malformed("variants"),
        ),
    ];
    for (pointer, value, expected) in cases {
        let mut document = experiment();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        document
            .pointer_mut(parent)
            .unwrap()
            .as_object_mut()
            .unwrap()
            .insert(key.to_owned(), value.clone());
        let flag = read(document.clone());
        assert_eq!(
            result(&flag).as_ref().unwrap_err(),
            &expected,
            "{pointer} = {value}"
        );
        assert_eq!(serde_json::to_value(&flag).unwrap()["filters"], document);
    }
    for (pointer, expected) in [
        ("/rules/0/paused", ParseError::Malformed("paused")),
        ("/rules/0/variants", ParseError::Malformed("variants")),
        ("/rules/0/holdout/seed", ParseError::Malformed("seed")),
    ] {
        let mut document = experiment();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        document
            .pointer_mut(parent)
            .unwrap()
            .as_object_mut()
            .unwrap()
            .remove(key);
        assert_eq!(
            result(&read(document)).as_ref().unwrap_err(),
            &expected,
            "{pointer}"
        );
    }
    let mut document = experiment();
    document["rules"][0]["variants"] = json!((0..=MAX_VARIANTS)
        .map(|i| json!({"key": format!("arm_{i}"), "weight": 5, "value": "standard"}))
        .collect::<Vec<_>>());
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::LimitExceeded("variants")
    );
    // Hundredths are summed exactly: these weights total 100, but their binary64 sum is
    // 100.00000000000001.
    let mut document = experiment();
    document["rules"][0]["variants"] = json!([
        {"key": "a", "weight": 0.01, "value": "standard"},
        {"key": "b", "weight": 65.4, "value": "standard"},
        {"key": "c", "weight": 34.59, "value": "standard"}
    ]);
    assert!(result(&read(document)).is_ok());
    let mut document = experiment();
    document["rules"][0]["variants"] = json!([
        {"key": "a", "weight": 33.33, "value": "standard"},
        {"key": "b", "weight": 33.33, "value": "standard"},
        {"key": "c", "weight": 33.33, "value": "standard"}
    ]);
    assert_eq!(
        result(&read(document)).as_ref().unwrap_err(),
        &ParseError::Malformed("variants")
    );
}