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.

70.5 KB
Raw Blame
use crate::flags::flag_group_type_mapping::GroupTypeIndex;
use crate::flags::flag_models::*;
use crate::properties::property_models::PropertyFilter;
use serde_json::Value;
use std::collections::{HashMap, HashSet};

impl FeatureFlag {
    /// Returns the group type index for the flag, or None if it's not set.
    ///
    /// See [`FlagFilters::aggregation_group_type_index`] for more details about group type mappings.
    pub fn get_group_type_index(&self) -> Option<i32> {
        self.filters.aggregation_group_type_index
    }

    pub fn get_conditions(&self) -> &Vec<FlagPropertyGroup> {
        &self.filters.groups
    }

    pub fn get_variants(&self) -> &[MultivariateFlagVariant] {
        self.filters
            .multivariate
            .as_ref()
            .map_or(&[], |m| m.variants.as_slice())
    }

    pub fn get_payload(&self, match_val: &str) -> Option<serde_json::Value> {
        self.filters.payloads.as_ref().and_then(|payloads| {
            payloads
                .as_object()
                .and_then(|obj| obj.get(match_val).cloned())
        })
    }

    /// Returns true if the flag requires DB preparation in order to evaluate the flag.
    ///
    /// This is true if the flag has a group type index set
    /// OR if the flag has a cohort filter
    /// OR if the flag has a person property filter that is not present in the overrides
    /// OR if the flag has a group property filter that `group_filter_needs_db` selects
    ///    (the caller owns the request's group context — see
    ///    `FeatureFlagMatcher::group_filter_needs_db_prep`)
    ///
    /// A supported v2 flag needs it only when a predicate key is absent from the overrides.
    pub fn requires_db_preparation(
        &self,
        overrides: &HashMap<String, Value>,
        group_filter_needs_db: &dyn Fn(&PropertyFilter, Option<GroupTypeIndex>) -> bool,
    ) -> bool {
        if let Some(config) = self.filters.supported_v2() {
            return config
                .rules
                .iter()
                .flat_map(|rule| &rule.targeting)
                .any(|predicate| !overrides.contains_key(&predicate.key));
        }
        self.filters
            .requires_db_properties(overrides, &self.key, group_filter_needs_db)
            || self.filters.requires_cohort_filters()
    }

    /// Returns true if this flag has experience continuity enabled and is eligible for it.
    ///
    /// Experience continuity is only supported for v1 person-based flags using distinct_id bucketing.
    /// Group-based flags and device_id bucketing flags are not eligible.
    pub fn has_experience_continuity(&self) -> bool {
        self.filters.is_v1()
            && self.ensure_experience_continuity.unwrap_or(false)
            && self.get_group_type_index().is_none()
            && self.get_bucketing_identifier() == BucketingIdentifier::DistinctId
    }

    /// Returns true if the flag has multivariate variants that depend on hashing.
    ///
    /// `get_matching_variant` walks the variants in order accumulating percentages and returns
    /// the first whose running total passes the hash, so a variant is reachable only while the
    /// total before it is still under 100 and its own share is non-zero. Hashing decides nothing
    /// when at most one variant is reachable.
    ///
    /// Note this is about position, not just presence of a 100: `[100, 40]` is not hash
    /// dependent because the first variant already takes everyone, while `[40, 100]` is,
    /// because hashes below 0.40 still select the first.
    pub fn has_hash_dependent_variants(&self) -> bool {
        match &self.filters.multivariate {
            None => false,
            Some(multivariate) => {
                let mut cumulative = 0.0;
                let mut reachable = 0;
                for variant in &multivariate.variants {
                    if cumulative >= 100.0 {
                        break;
                    }
                    if variant.rollout_percentage > 0.0 {
                        reachable += 1;
                        if reachable > 1 {
                            return true;
                        }
                    }
                    cumulative += variant.rollout_percentage;
                }
                false
            }
        }
    }

    /// Returns true if any condition group has less than 100% rollout.
    ///
    /// When all groups are at 100%, the hash doesn't affect the result since
    /// everyone in each group gets the flag enabled.
    pub fn has_partial_rollout(&self) -> bool {
        self.filters
            .groups
            .iter()
            .any(|group| group.rollout_percentage_unwrapped() < 100.0)
    }

    /// Returns the variant this condition pins, if it names one of the flag's variants.
    /// An override that names no real variant is ignored, so the variant comes from the hash.
    pub fn pinned_variant<'c>(&self, condition: &'c FlagPropertyGroup) -> Option<&'c str> {
        let variant = condition.variant.as_deref()?;
        self.filters
            .multivariate
            .as_ref()
            .is_some_and(|m| m.variants.iter().any(|v| v.key == variant))
            .then_some(variant)
    }

    /// Returns true if the bucketing hash decides the outcome of this condition.
    ///
    /// This does not use `has_hash_dependent_variants`. That method treats a single reachable
    /// variant as hash-independent, but hashes past that variant's share still map to no
    /// variant, and reading it here would let such a flag bucket its variant on `distinct_id`.
    pub fn condition_needs_bucketing_hash(&self, condition: &FlagPropertyGroup) -> bool {
        if condition.rollout_percentage_unwrapped() < 100.0 {
            return true;
        }
        let first_live_variant = self.filters.multivariate.as_ref().and_then(|m| {
            m.variants
                .iter()
                .find(|variant| variant.rollout_percentage > 0.0)
        });
        first_live_variant.is_some_and(|variant| variant.rollout_percentage < 100.0)
            && self.pinned_variant(condition).is_none()
    }

    /// Returns true if this flag requires a hash key override lookup for experience continuity.
    ///
    /// Experience continuity lookups are only meaningful when the hash affects the result:
    /// - Partial rollouts need consistent bucketing across distinct_id changes
    /// - Multivariate flags need consistent variant assignment
    ///
    /// For flags at 100% rollout with no hash-dependent variants, everyone gets the same
    /// result regardless of their hash, so the lookup is unnecessary.
    pub fn needs_hash_key_override(&self) -> bool {
        // Must have experience continuity enabled and be eligible for it
        if !self.has_experience_continuity() {
            return false;
        }

        // If flag has hash-dependent variants, need hash for consistent variant assignment
        if self.has_hash_dependent_variants() {
            return true;
        }

        // If any condition group has < 100% rollout, need hash for consistent bucketing
        if self.has_partial_rollout() {
            return true;
        }

        // Flag is 100% rollout with no hash-dependent variants - skip the lookup
        false
    }
}

/// Returns the set of non-filtered flags that require DB preparation.
/// Filtered-out flags (inactive, deleted, runtime/tag mismatches) are skipped
/// since they won't be evaluated.
pub fn flags_require_db_preparation<'a>(
    flags: &[&'a FeatureFlag],
    overrides: &HashMap<String, Value>,
    filtered_out_flag_ids: &HashSet<i32>,
    group_filter_needs_db: &dyn Fn(&PropertyFilter, Option<GroupTypeIndex>) -> bool,
) -> Vec<&'a FeatureFlag> {
    flags
        .iter()
        .filter(|flag| {
            !filtered_out_flag_ids.contains(&flag.id)
                && flag.requires_db_preparation(overrides, group_filter_needs_db)
        })
        .copied()
        .collect()
}

#[cfg(test)]
mod tests {
    use crate::{
        api::errors::FlagError,
        flags::test_helpers::get_flags_from_redis,
        mock,
        properties::property_models::{OperatorType, PropertyFilter, PropertyType},
        utils::mock::MockInto,
    };
    use serde_json::{json, Value};
    use std::time::Instant;
    use tokio::task;

    use super::*;
    use crate::utils::test_utils::{
        insert_flags_for_team_in_redis, setup_redis_client, TestContext,
    };

    #[test]
    fn test_utf16_property_names_and_values() {
        let json_str = r#"{
            "id": 1,
            "team_id": 2,
            "name": "𝖚𝖙𝖋16_𝖙𝖊𝖘𝖙_𝖋𝖑𝖆𝖌",
            "key": "𝖚𝖙𝖋16_𝖙𝖊𝖘𝖙_𝖋𝖑𝖆𝖌",
            "filters": {
                "groups": [
                    {
                        "properties": [
                            {
                                "key": "𝖕𝖗𝖔𝖕𝖊𝖗𝖙𝖞",
                                "value": "𝓿𝓪𝓵𝓾𝓮",
                                "type": "person"
                            }
                        ]
                    }
                ]
            }
        }"#;

        let flag: FeatureFlag = serde_json::from_str(json_str).expect("Failed to deserialize");

        assert_eq!(flag.key, "𝖚𝖙𝖋16_𝖙𝖊𝖘𝖙_𝖋𝖑𝖆𝖌");
        let property = &flag.filters.groups[0].properties.as_ref().unwrap()[0];
        assert_eq!(property.key, "𝖕𝖗𝖔𝖕𝖊𝖗𝖙𝖞");
        assert_eq!(property.value, Some(json!("𝓿𝓪𝓵𝓾𝓮")));
    }

    #[test]
    fn test_deserialize_complex_flag() {
        let json_str = r#"{
            "id": 1,
            "team_id": 2,
            "name": "Complex Flag",
            "key": "complex_flag",
            "filters": {
                "groups": [
                    {
                        "properties": [
                            {
                                "key": "email",
                                "value": "[email protected]",
                                "operator": "exact",
                                "type": "person"
                            }
                        ],
                        "rollout_percentage": 50
                    }
                ],
                "multivariate": {
                    "variants": [
                        {
                            "key": "control",
                            "name": "Control Group",
                            "rollout_percentage": 33.33
                        },
                        {
                            "key": "test",
                            "name": "Test Group",
                            "rollout_percentage": 66.67
                        }
                    ]
                },
                "aggregation_group_type_index": 0,
                "payloads": {"test": {"type": "json", "value": {"key": "value"}}}
            },
            "deleted": false,
            "active": true,
            "ensure_experience_continuity": false,
            "evaluation_runtime": "all"
        }"#;

        let flag: FeatureFlag = serde_json::from_str(json_str).expect("Failed to deserialize");

        assert_eq!(flag.id, 1);
        assert_eq!(flag.team_id, 2);
        assert_eq!(flag.name, Some("Complex Flag".to_string()));
        assert_eq!(flag.key, "complex_flag");
        assert_eq!(flag.filters.groups.len(), 1);
        assert_eq!(flag.filters.groups[0].properties.as_ref().unwrap().len(), 1);
        assert_eq!(flag.filters.groups[0].rollout_percentage, Some(50.0));
        assert_eq!(
            flag.filters.multivariate.as_ref().unwrap().variants.len(),
            2
        );
        assert_eq!(flag.filters.aggregation_group_type_index, Some(0));
        assert!(flag.filters.payloads.is_some());
        assert!(!flag.deleted);
        assert!(flag.active);
        assert_eq!(flag.evaluation_runtime, Some("all".to_string()));
        assert!(!flag.ensure_experience_continuity.unwrap_or(false));
    }

    // TODO: Add more tests to validate deserialization of flags.
    // TODO: Also make sure old flag data is handled, or everything is migrated to new style in production

    #[test]
    fn test_operator_type_deserialization() {
        let operators = vec![
            ("exact", OperatorType::Exact),
            ("is_not", OperatorType::IsNot),
            ("icontains", OperatorType::Icontains),
            ("not_icontains", OperatorType::NotIcontains),
            ("icontains_multi", OperatorType::IcontainsMulti),
            ("not_icontains_multi", OperatorType::NotIcontainsMulti),
            ("regex", OperatorType::Regex),
            ("not_regex", OperatorType::NotRegex),
            ("gt", OperatorType::Gt),
            ("lt", OperatorType::Lt),
            ("gte", OperatorType::Gte),
            ("lte", OperatorType::Lte),
            ("is_set", OperatorType::IsSet),
            ("is_not_set", OperatorType::IsNotSet),
            ("is_date_exact", OperatorType::IsDateExact),
            ("is_date_after", OperatorType::IsDateAfter),
            ("is_date_before", OperatorType::IsDateBefore),
        ];

        for (op_str, op_type) in operators {
            let json = format!(
                r#"{{
            "key": "test_key",
            "value": "test_value",
            "operator": "{op_str}",
            "type": "person"
        }}"#
            );
            let deserialized: PropertyFilter = serde_json::from_str(&json).unwrap();
            assert_eq!(deserialized.operator, Some(op_type));
        }
    }

    #[tokio::test]
    async fn test_multivariate_flag_parsing() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let multivariate_flag = json!({
            "id": 1,
            "team_id": team.id,
            "name": "Multivariate Flag",
            "key": "multivariate_flag",
            "filters": {
                "groups": [
                    {
                        "properties": [],
                        "rollout_percentage": 100
                    }
                ],
                "multivariate": {
                    "variants": [
                        {
                            "key": "control",
                            "name": "Control Group",
                            "rollout_percentage": 33.33
                        },
                        {
                            "key": "test_a",
                            "name": "Test Group A",
                            "rollout_percentage": 33.33
                        },
                        {
                            "key": "test_b",
                            "name": "Test Group B",
                            "rollout_percentage": 33.34
                        }
                    ]
                }
            },
            "active": true,
            "deleted": false,
            "evaluation_runtime": "all"
        });

        // Insert into Redis
        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!([multivariate_flag]).to_string()),
        )
        .await
        .expect("Failed to insert flag in Redis");

        // Insert into Postgres
        context
            .insert_flag(
                team.id,
                Some(FeatureFlagRow {
                    id: 1,
                    team_id: team.id,
                    name: Some("Multivariate Flag".to_string()),
                    key: "multivariate_flag".to_string(),
                    filters: multivariate_flag["filters"].clone(),
                    deleted: false,
                    active: true,
                    ensure_experience_continuity: Some(false),
                    version: Some(1),
                    evaluation_runtime: Some("all".to_string()),
                    evaluation_tags: None,
                    bucketing_identifier: None,
                    has_experiment: false,
                }),
            )
            .await
            .expect("Failed to insert flag in Postgres");

        // Fetch and verify from Redis
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");

        assert_eq!(redis_flags.flags.len(), 1);
        let redis_flag = &redis_flags.flags[0];
        assert_eq!(redis_flag.key, "multivariate_flag");
        assert_eq!(redis_flag.get_variants().len(), 3);

        // Fetch and verify from Postgres
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        assert_eq!(pg_flags.len(), 1);
        let pg_flag = &pg_flags[0];
        assert_eq!(pg_flag.key, "multivariate_flag");
        assert_eq!(pg_flag.get_variants().len(), 3);
    }

    #[tokio::test]
    async fn test_multivariate_flag_with_payloads() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let multivariate_flag_with_payloads = json!({
            "id": 1,
            "team_id": team.id,
            "name": "Multivariate Flag with Payloads",
            "key": "multivariate_flag_with_payloads",
            "filters": {
                "groups": [
                    {
                        "properties": [],
                        "rollout_percentage": 100
                    }
                ],
                "multivariate": {
                    "variants": [
                        {
                            "key": "control",
                            "name": "Control Group",
                            "rollout_percentage": 33.33
                        },
                        {
                            "key": "test_a",
                            "name": "Test Group A",
                            "rollout_percentage": 33.33
                        },
                        {
                            "key": "test_b",
                            "name": "Test Group B",
                            "rollout_percentage": 33.34
                        }
                    ]
                },
                "payloads": {
                    "control": {"type": "json", "value": {"feature": "old"}},
                    "test_a": {"type": "json", "value": {"feature": "new_a"}},
                    "test_b": {"type": "json", "value": {"feature": "new_b"}}
                }
            },
            "active": true,
            "deleted": false
        });

        // Insert into Redis
        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!([multivariate_flag_with_payloads]).to_string()),
        )
        .await
        .expect("Failed to insert flag in Redis");

        // Insert into Postgres
        context
            .insert_flag(
                team.id,
                Some(FeatureFlagRow {
                    id: 1,
                    team_id: team.id,
                    name: Some("Multivariate Flag with Payloads".to_string()),
                    key: "multivariate_flag_with_payloads".to_string(),
                    filters: multivariate_flag_with_payloads["filters"].clone(),
                    deleted: false,
                    active: true,
                    ensure_experience_continuity: Some(false),
                    version: Some(1),
                    evaluation_runtime: Some("all".to_string()),
                    evaluation_tags: None,
                    bucketing_identifier: None,
                    has_experiment: false,
                }),
            )
            .await
            .expect("Failed to insert flag in Postgres");

        // Fetch and verify from Redis
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");

        assert_eq!(redis_flags.flags.len(), 1);
        let redis_flag = &redis_flags.flags[0];
        assert_eq!(redis_flag.key, "multivariate_flag_with_payloads");

        // Fetch and verify from Postgres
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        assert_eq!(pg_flags.len(), 1);
        let pg_flag = &pg_flags[0];
        assert_eq!(pg_flag.key, "multivariate_flag_with_payloads");

        // Verify flag contents for both Redis and Postgres
        for (source, flag) in [("Redis", redis_flag), ("Postgres", pg_flag)].iter() {
            // Check multivariate options
            assert!(flag.filters.multivariate.is_some());
            let multivariate = flag.filters.multivariate.as_ref().unwrap();
            assert_eq!(multivariate.variants.len(), 3);

            // Check variant details
            let variant_keys = ["control", "test_a", "test_b"];
            let expected_names = ["Control Group", "Test Group A", "Test Group B"];
            for (i, (key, expected_name)) in
                variant_keys.iter().zip(expected_names.iter()).enumerate()
            {
                let variant = &multivariate.variants[i];
                assert_eq!(variant.key, *key);
                assert_eq!(
                    variant.name,
                    Some(expected_name.to_string()),
                    "Incorrect variant name for {key} in {source}"
                );
            }

            // Check payloads
            assert!(flag.filters.payloads.is_some());
            let payloads = flag.filters.payloads.as_ref().unwrap();

            for key in variant_keys.iter() {
                let payload = payloads[key].as_object().unwrap();
                assert_eq!(payload["type"], "json");

                let value = payload["value"].as_object().unwrap();
                let expected_feature = match *key {
                    "control" => "old",
                    "test_a" => "new_a",
                    "test_b" => "new_b",
                    _ => panic!("Unexpected variant key"),
                };
                assert_eq!(
                    value["feature"], expected_feature,
                    "Incorrect payload value for {key} in {source}"
                );
            }
        }
    }

    #[tokio::test]
    async fn test_flags_with_different_property_types() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let flag_with_different_properties = json!({
            "id": 1,
            "team_id": team.id,
            "name": "Flag with Different Properties",
            "key": "flag_with_different_properties",
            "filters": {
                "groups": [
                    {
                        "properties": [
                            {
                                "key": "email",
                                "value": "[email protected]",
                                "type": "person",
                                "operator": "exact"
                            },
                            {
                                "key": "country",
                                "value": "US",
                                "type": "group",
                                "operator": "exact"
                            },
                            {
                                "key": "cohort",
                                "value": "123",
                                "type": "cohort",
                                "operator": "exact"
                            }
                        ],
                        "rollout_percentage": 100
                    }
                ]
            },
            "active": true,
            "deleted": false,
            "evaluation_runtime": "all"
        });

        // Insert into Redis
        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!([flag_with_different_properties]).to_string()),
        )
        .await
        .expect("Failed to insert flag in Redis");

        // Insert into Postgres
        context
            .insert_flag(
                team.id,
                Some(FeatureFlagRow {
                    id: 1,
                    team_id: team.id,
                    name: Some("Flag with Different Properties".to_string()),
                    key: "flag_with_different_properties".to_string(),
                    filters: flag_with_different_properties["filters"].clone(),
                    deleted: false,
                    active: true,
                    ensure_experience_continuity: Some(false),
                    version: Some(1),
                    evaluation_runtime: Some("all".to_string()),
                    evaluation_tags: None,
                    bucketing_identifier: None,
                    has_experiment: false,
                }),
            )
            .await
            .expect("Failed to insert flag in Postgres");

        // Fetch and verify from Redis
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");

        assert_eq!(redis_flags.flags.len(), 1);
        let redis_flag = &redis_flags.flags[0];
        assert_eq!(redis_flag.key, "flag_with_different_properties");
        let redis_properties = &redis_flag.filters.groups[0].properties.as_ref().unwrap();
        assert_eq!(redis_properties.len(), 3);
        assert_eq!(redis_properties[0].prop_type, PropertyType::Person);
        assert_eq!(redis_properties[1].prop_type, PropertyType::Group);
        assert_eq!(redis_properties[2].prop_type, PropertyType::Cohort);

        // Fetch and verify from Postgres
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        assert_eq!(pg_flags.len(), 1);
        let pg_flag = &pg_flags[0];
        assert_eq!(pg_flag.key, "flag_with_different_properties");
        let pg_properties = &pg_flag.filters.groups[0].properties.as_ref().unwrap();
        assert_eq!(pg_properties.len(), 3);
        assert_eq!(pg_properties[0].prop_type, PropertyType::Person);
        assert_eq!(pg_properties[1].prop_type, PropertyType::Group);
        assert_eq!(pg_properties[2].prop_type, PropertyType::Cohort);
    }

    #[tokio::test]
    async fn test_deleted_and_inactive_flags() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let deleted_flag = json!({
            "id": 1,
            "team_id": team.id,
            "name": "Deleted Flag",
            "key": "deleted_flag",
            "filters": {"groups": []},
            "active": true,
            "deleted": true
        });

        // Insert into Redis
        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!([deleted_flag]).to_string()),
        )
        .await
        .expect("Failed to insert flags in Redis");

        // Insert into Postgres
        context
            .insert_flag(
                team.id,
                Some(FeatureFlagRow {
                    id: 0,
                    team_id: team.id,
                    name: Some("Deleted Flag".to_string()),
                    key: "deleted_flag".to_string(),
                    filters: deleted_flag["filters"].clone(),
                    deleted: true,
                    active: true,
                    ensure_experience_continuity: Some(false),
                    version: Some(1),
                    evaluation_runtime: Some("all".to_string()),
                    evaluation_tags: None,
                    bucketing_identifier: None,
                    has_experiment: false,
                }),
            )
            .await
            .expect("Failed to insert deleted flag in Postgres");

        // Fetch and verify from Redis
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");

        assert_eq!(redis_flags.flags.len(), 1);
        assert!(redis_flags.flags.iter().any(|f| f.deleted));

        // Fetch and verify from Postgres
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        assert_eq!(pg_flags.len(), 0);
        assert!(!pg_flags.iter().any(|f| f.deleted)); // no deleted flags
    }

    #[tokio::test]
    async fn test_error_handling() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;

        // Test malformed JSON in Redis (using Django-compatible hypercache key format)
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        // Use Django-compatible key format: posthog:1:cache/teams/{team_id}/feature_flags/flags.json
        let django_key = format!("posthog:1:cache/teams/{}/feature_flags/flags.json", team.id);
        redis_client
            .set(django_key, "not a json".to_string())
            .await
            .expect("Failed to set malformed JSON in Redis");

        let result = get_flags_from_redis(redis_client, team.id).await;
        assert!(matches!(
            result,
            Err(FlagError::InternalError {
                code: "flag_data_parsing_error",
                ..
            })
        ));

        // Test database query error (using a non-existent table)
        let result = sqlx::query("SELECT * FROM non_existent_table")
            .fetch_all(&mut *context.non_persons_reader.get_connection().await.unwrap())
            .await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_concurrent_access() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let flag = json!({
            "id": 1,
            "team_id": team.id,
            "name": "Concurrent Flag",
            "key": "concurrent_flag",
            "filters": {"groups": []},
            "active": true,
            "deleted": false
        });

        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!([flag]).to_string()),
        )
        .await
        .expect("Failed to insert flag in Redis");

        context
            .insert_flag(
                team.id,
                Some(FeatureFlagRow {
                    id: 0,
                    team_id: team.id,
                    name: Some("Concurrent Flag".to_string()),
                    key: "concurrent_flag".to_string(),
                    filters: flag["filters"].clone(),
                    deleted: false,
                    active: true,
                    ensure_experience_continuity: Some(false),
                    version: Some(1),
                    evaluation_runtime: Some("all".to_string()),
                    evaluation_tags: None,
                    bucketing_identifier: None,
                    has_experiment: false,
                }),
            )
            .await
            .expect("Failed to insert flag in Postgres");

        let mut handles = vec![];
        for _ in 0..10 {
            let redis_client = redis_client.clone();
            let reader = context.non_persons_reader.clone();
            let project_id = team.id;

            let handle = task::spawn(async move {
                let redis_flags = get_flags_from_redis(redis_client, project_id)
                    .await
                    .unwrap();
                let pg_flags = FeatureFlagList::from_pg(reader, project_id).await.unwrap();
                (redis_flags, pg_flags)
            });

            handles.push(handle);
        }

        for handle in handles {
            let (redis_flags, pg_flags) = handle.await.unwrap();
            assert_eq!(redis_flags.flags.len(), 1);
            assert_eq!(pg_flags.len(), 1);
            assert_eq!(redis_flags.flags[0].key, "concurrent_flag");
            assert_eq!(pg_flags[0].key, "concurrent_flag");
        }
    }

    #[tokio::test]
    #[ignore]
    async fn test_performance() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let num_flags = 1000;
        let mut flags = Vec::with_capacity(num_flags);

        for i in 0..num_flags {
            let flag = json!({
                "id": i,
                "team_id": team.id,
                "name": format!("Flag {}", i),
                "key": format!("flag_{}", i),
                "filters": {"groups": []},
                "active": true,
                "deleted": false
            });
            flags.push(flag);
        }

        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(json!(flags).to_string()),
        )
        .await
        .expect("Failed to insert flags in Redis");

        for flag in flags {
            context
                .insert_flag(
                    team.id,
                    Some(FeatureFlagRow {
                        id: 0,
                        team_id: team.id,
                        name: Some(flag["name"].as_str().unwrap().to_string()),
                        key: flag["key"].as_str().unwrap().to_string(),
                        filters: flag["filters"].clone(),
                        deleted: false,
                        active: true,
                        ensure_experience_continuity: Some(false),
                        version: Some(1),
                        evaluation_runtime: Some("all".to_string()),
                        evaluation_tags: None,
                        bucketing_identifier: None,
                        has_experiment: false,
                    }),
                )
                .await
                .expect("Failed to insert flag in Postgres");
        }

        let start = Instant::now();
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");
        let redis_duration = start.elapsed();

        let start = Instant::now();
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader, team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        let pg_duration = start.elapsed();

        tracing::info!("Redis fetch time: {:?}", redis_duration);
        tracing::info!("Postgres fetch time: {:?}", pg_duration);

        assert_eq!(redis_flags.flags.len(), num_flags);
        assert_eq!(pg_flags.len(), num_flags);

        assert!(redis_duration < std::time::Duration::from_millis(100));
        assert!(pg_duration < std::time::Duration::from_millis(1000));
    }

    #[tokio::test]
    async fn test_edge_cases() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let edge_case_flags = json!([
            {
                "id": 1,
                "team_id": team.id,
                "name": "Empty Properties Flag",
                "key": "empty_properties",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
                "active": true,
                "deleted": false
            },
            {
                "id": 2,
                "team_id": team.id,
                "name": "Very Long Key Flag",
                "key": "a".repeat(400), // max key length is 400
                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
                "active": true,
                "deleted": false
            },
            {
                "id": 3,
                "team_id": team.id,
                "name": "Unicode Flag",
                "key": "unicode_flag_🚀",
                "filters": {"groups": [{"properties": [{"key": "country", "value": "🇯🇵", "type": "person"}], "rollout_percentage": 100}]},
                "active": true,
                "deleted": false
            }
        ]);

        // Insert edge case flags
        insert_flags_for_team_in_redis(
            redis_client.clone(),
            team.id,
            Some(edge_case_flags.to_string()),
        )
        .await
        .expect("Failed to insert edge case flags in Redis");

        for flag in edge_case_flags.as_array().unwrap() {
            context
                .insert_flag(
                    team.id,
                    Some(FeatureFlagRow {
                        id: 0,
                        team_id: team.id,
                        name: flag["name"].as_str().map(|s| s.to_string()),
                        key: flag["key"].as_str().unwrap().to_string(),
                        filters: flag["filters"].clone(),
                        deleted: false,
                        active: true,
                        ensure_experience_continuity: Some(false),
                        version: Some(1),
                        evaluation_runtime: Some("all".to_string()),
                        evaluation_tags: None,
                        bucketing_identifier: None,
                        has_experiment: false,
                    }),
                )
                .await
                .expect("Failed to insert edge case flag in Postgres");
        }

        // Fetch and verify edge case flags
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");
        assert_eq!(redis_flags.flags.len(), 3);
        assert_eq!(pg_flags.len(), 3);

        // Verify empty properties flag
        assert!(redis_flags.flags.iter().any(|f| f.key == "empty_properties"
            && f.filters.groups[0].properties.as_ref().unwrap().is_empty()));
        assert!(pg_flags.iter().any(|f| f.key == "empty_properties"
            && f.filters.groups[0].properties.as_ref().unwrap().is_empty()));

        // Verify very long key flag
        assert!(redis_flags.flags.iter().any(|f| f.key.len() == 400));
        assert!(pg_flags.iter().any(|f| f.key.len() == 400));

        // Verify unicode flag
        assert!(redis_flags.flags.iter().any(|f| f.key == "unicode_flag_🚀"));
        assert!(pg_flags.iter().any(|f| f.key == "unicode_flag_🚀"));
    }

    #[tokio::test]
    async fn test_consistent_behavior_from_both_clients() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let flags = json!([
            {
                "id": 1,
                "team_id": team.id,
                "name": "Flag 1",
                "key": "flag_1",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 50}]},
                "active": true,
                "deleted": false
            },
            {
                "id": 2,
                "team_id": team.id,
                "name": "Flag 2",
                "key": "flag_2",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 75}]},
                "active": true,
                "deleted": false
            }
        ]);

        // Insert flags in both Redis and Postgres
        insert_flags_for_team_in_redis(redis_client.clone(), team.id, Some(flags.to_string()))
            .await
            .expect("Failed to insert flags in Redis");

        for flag in flags.as_array().unwrap() {
            context
                .insert_flag(
                    team.id,
                    Some(FeatureFlagRow {
                        id: 0,
                        team_id: team.id,
                        name: flag["name"].as_str().map(|s| s.to_string()),
                        key: flag["key"].as_str().unwrap().to_string(),
                        filters: flag["filters"].clone(),
                        deleted: false,
                        active: true,
                        ensure_experience_continuity: Some(false),
                        version: Some(1),
                        evaluation_runtime: Some("all".to_string()),
                        evaluation_tags: None,
                        bucketing_identifier: None,
                        has_experiment: false,
                    }),
                )
                .await
                .expect("Failed to insert flag in Postgres");
        }

        // Fetch flags from both sources
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");
        let mut pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");

        // `redis_flags.flags` is `Arc<[FeatureFlag]>` (immutable), so sort into a
        // local Vec for the comparison below.
        let mut redis_flag_list: Vec<_> = redis_flags.flags.iter().cloned().collect();
        redis_flag_list.sort_by(|a, b| a.key.cmp(&b.key));
        pg_flags.sort_by(|a, b| a.key.cmp(&b.key));

        // Compare results
        assert_eq!(
            redis_flag_list.len(),
            pg_flags.len(),
            "Number of flags mismatch"
        );

        for (redis_flag, pg_flag) in redis_flag_list.iter().zip(pg_flags.iter()) {
            assert_eq!(redis_flag.key, pg_flag.key, "Flag key mismatch");
            assert_eq!(
                redis_flag.name, pg_flag.name,
                "Flag name mismatch for key: {}",
                redis_flag.key
            );
            assert_eq!(
                redis_flag.active, pg_flag.active,
                "Flag active status mismatch for key: {}",
                redis_flag.key
            );
            assert_eq!(
                redis_flag.deleted, pg_flag.deleted,
                "Flag deleted status mismatch for key: {}",
                redis_flag.key
            );
            assert_eq!(
                redis_flag.filters.groups[0].rollout_percentage,
                pg_flag.filters.groups[0].rollout_percentage,
                "Flag rollout percentage mismatch for key: {}",
                redis_flag.key
            );
        }
    }

    #[tokio::test]
    async fn test_rollout_percentage_edge_cases() {
        let redis_client = setup_redis_client(None).await;
        let context = TestContext::new(None).await;
        let team = context
            .insert_new_team(None)
            .await
            .expect("Failed to insert team in pg");

        let flags = json!([
            {
                "id": 1,
                "team_id": team.id,
                "name": "0% Rollout",
                "key": "zero_percent",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 0}]},
                "active": true,
                "deleted": false,
                "evaluation_runtime": "all"
            },
            {
                "id": 2,
                "team_id": team.id,
                "name": "100% Rollout",
                "key": "hundred_percent",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
                "active": true,
                "deleted": false,
                "evaluation_runtime": "all"
            },
            {
                "id": 3,
                "team_id": team.id,
                "name": "Fractional Rollout",
                "key": "fractional_percent",
                "filters": {"groups": [{"properties": [], "rollout_percentage": 33.33}]},
                "active": true,
                "deleted": false,
                "evaluation_runtime": "all"
            }
        ]);

        // Insert flags in both Redis and Postgres
        insert_flags_for_team_in_redis(redis_client.clone(), team.id, Some(flags.to_string()))
            .await
            .expect("Failed to insert flags in Redis");

        for flag in flags.as_array().unwrap() {
            context
                .insert_flag(
                    team.id,
                    Some(FeatureFlagRow {
                        id: 0,
                        team_id: team.id,
                        name: flag["name"].as_str().map(|s| s.to_string()),
                        key: flag["key"].as_str().unwrap().to_string(),
                        filters: flag["filters"].clone(),
                        deleted: false,
                        active: true,
                        ensure_experience_continuity: Some(false),
                        version: Some(1),
                        evaluation_runtime: Some("all".to_string()),
                        evaluation_tags: None,
                        bucketing_identifier: None,
                        has_experiment: false,
                    }),
                )
                .await
                .expect("Failed to insert flag in Postgres");
        }

        // Fetch flags from both sources
        let redis_flags = get_flags_from_redis(redis_client, team.id)
            .await
            .expect("Failed to fetch flags from Redis");
        let pg_flags = FeatureFlagList::from_pg(context.non_persons_reader.clone(), team.id)
            .await
            .expect("Failed to fetch flags from Postgres");

        // Verify rollout percentages
        for flags in &[
            redis_flags,
            FeatureFlagList {
                flags: pg_flags.into(),
                ..Default::default()
            },
        ] {
            assert!(flags
                .flags
                .iter()
                .any(|f| f.key == "zero_percent"
                    && f.filters.groups[0].rollout_percentage == Some(0.0)));
            assert!(flags.flags.iter().any(|f| f.key == "hundred_percent"
                && f.filters.groups[0].rollout_percentage == Some(100.0)));
            assert!(flags.flags.iter().any(|f| f.key == "fractional_percent"
                && (f.filters.groups[0].rollout_percentage.unwrap() - 33.33).abs() < f64::EPSILON));
        }
    }

    #[test]
    fn test_empty_filters_deserialization() {
        let empty_filters_json = r#"{
            "id": 1,
            "team_id": 2,
            "name": "Empty Filters Flag",
            "key": "empty_filters",
            "filters": {},
            "deleted": false,
            "active": true,
            "evaluation_runtime": "all"
        }"#;

        let flag: FeatureFlag =
            serde_json::from_str(empty_filters_json).expect("Should deserialize empty filters");

        assert_eq!(flag.filters.groups.len(), 0);
        assert!(flag.filters.multivariate.is_none());
        assert!(flag.filters.aggregation_group_type_index.is_none());
        assert!(flag.filters.payloads.is_none());
        assert!(flag.filters.holdout.is_none());
    }

    #[test]
    fn test_require_db_preparation_if_group_type_index() {
        let mut flag = mock!(FeatureFlag, filters: vec![
            mock!(crate::properties::property_models::PropertyFilter, key: "some_property".mock_into(), prop_type: PropertyType::Person, operator: Some(OperatorType::Exact))
        ].mock_into());

        let overrides = HashMap::from([(
            "some_property".to_string(),
            Value::String("value".to_string()),
        )]);

        assert!(flag.get_group_type_index().is_none());
        assert!(!flag.requires_db_preparation(&overrides, &|_, _| true));

        flag.filters.aggregation_group_type_index = Some(0);

        assert!(flag.get_group_type_index().is_some());
        assert!(flag.requires_db_preparation(&overrides, &|_, _| true));
    }

    #[test]
    fn test_requires_db_preparation_if_cohort_filter_set() {
        let flag = mock!(FeatureFlag, filters: vec![
            mock!(crate::properties::property_models::PropertyFilter, key: "some_property".mock_into(), prop_type: PropertyType::Cohort, operator: Some(OperatorType::Exact))
        ].mock_into());

        // Even though override matches the cohort filter, we still need to prepare the DB
        let overrides = HashMap::from([(
            "some_property".to_string(),
            Value::String("value".to_string()),
        )]);

        assert!(flag.requires_db_preparation(&overrides, &|_, _| true));
    }

    #[test]
    fn test_requires_db_preparation_if_not_enough_overrides() {
        let flag = mock!(FeatureFlag, filters: mock!(FlagFilters, groups: vec![
            mock!(FlagPropertyGroup, properties: Some(vec![
                mock!(crate::properties::property_models::PropertyFilter, key: "some_property".mock_into(), prop_type: PropertyType::Person, operator: Some(OperatorType::Exact)),
                mock!(crate::properties::property_models::PropertyFilter, key: "another_property".mock_into(), prop_type: PropertyType::Person, operator: Some(OperatorType::Exact)),
            ]), rollout_percentage: Some(1.0))
        ]));

        {
            let overrides = HashMap::from([
                // Not enough overrides to evaluate locally
                (
                    "some_property".to_string(),
                    Value::String("value".to_string()),
                ),
            ]);
            assert!(flag.requires_db_preparation(&overrides, &|_, _| true));
        }

        {
            let overrides = HashMap::from([
                (
                    "some_property".to_string(),
                    Value::String("value".to_string()),
                ),
                (
                    "another_property".to_string(),
                    Value::String("value".to_string()),
                ),
            ]);
            assert!(!flag.requires_db_preparation(&overrides, &|_, _| true));
        }
    }

    #[test]
    fn test_v2_requires_db_preparation_only_when_a_predicate_key_is_missing() {
        let flag: FeatureFlag = serde_json::from_value(json!({
            "id": 1, "team_id": 1, "key": "v2", "active": true,
            "filters": {"version": 2, "return_type": "boolean", "default_value": false, "rules": [
                {"id": "a1a1a1a1-a1a1-4a1a-8a1a-a1a1a1a1a1a1", "rule_type": "targeted_release",
                 "value": true, "targeting": {"properties": [
                    {"key": "a", "type": "person", "operator": "exact", "value": "1", "negation": false},
                    {"key": "b", "type": "person", "operator": "exact", "value": "2", "negation": false}
                 ]}}
            ]}
        }))
        .unwrap();

        assert!(
            flag.requires_db_preparation(&HashMap::from([("a".into(), json!("1"))]), &|_, _| true)
        );
        assert!(!flag.requires_db_preparation(
            &HashMap::from([("a".into(), json!("1")), ("b".into(), json!("2"))]),
            &|_, _| true
        ));
    }

    #[test]
    fn test_does_not_require_db_preparation_if_holdout_set() {
        use crate::flags::flag_models::Holdout;
        let mut flag = mock!(FeatureFlag);
        flag.filters.holdout = Some(mock!(Holdout));

        assert!(!flag.requires_db_preparation(&HashMap::new(), &|_, _| true));
    }

    // ======== Tests for experience continuity optimization helper methods ========

    #[test]
    fn test_has_hash_dependent_variants_none() {
        let flag = mock!(FeatureFlag);
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_empty() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![],
            ..Default::default()
        });
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_single_100_percent() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![MultivariateFlagVariant {
                key: "control".to_string(),
                name: Some("Control".to_string()),
                rollout_percentage: 100.0,
                ..Default::default()
            }],
            ..Default::default()
        });
        // Single variant at 100% is effectively not multivariate
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_two_variants() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_multiple_with_one_at_100_percent() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 100.0, // This variant wins for everyone
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 0.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        // When any variant is at 100%, hashing doesn't matter - that variant always wins
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_partial_before_100_percent() {
        // Hashes below 0.40 select "control", so assignment depends on the hash and
        // continuity lookups must not be skipped.
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 40.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 100.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_zero_before_100_percent() {
        // A zero-share variant is never selected, so the 100 still takes everyone.
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 0.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 100.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_first_variant_over_100_percent() {
        // The first variant already covers the whole range, so later ones are unreachable.
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 150.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 10.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_all_zero() {
        // No variant is ever selected, so the hash decides nothing.
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 0.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 0.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(!flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_has_hash_dependent_variants_100_percent_in_the_middle() {
        // The third variant is unreachable, but the first two still split on the hash.
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "a".to_string(),
                    name: Some("A".to_string()),
                    rollout_percentage: 30.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "b".to_string(),
                    name: Some("B".to_string()),
                    rollout_percentage: 100.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "c".to_string(),
                    name: Some("C".to_string()),
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(flag.has_hash_dependent_variants());
    }

    #[test]
    fn test_needs_hash_key_override_partial_before_100_percent() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: Some("Control".to_string()),
                    rollout_percentage: 40.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: Some("Test".to_string()),
                    rollout_percentage: 100.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        assert!(flag.needs_hash_key_override());
    }

    #[test]
    fn test_has_partial_rollout_100_percent() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(100.0),
            variant: None,
            ..Default::default()
        }];
        assert!(!flag.has_partial_rollout());
    }

    #[test]
    fn test_has_partial_rollout_50_percent() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0),
            variant: None,
            ..Default::default()
        }];
        assert!(flag.has_partial_rollout());
    }

    #[test]
    fn test_has_partial_rollout_none_defaults_to_100() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: None, // Defaults to 100%
            variant: None,
            ..Default::default()
        }];
        assert!(!flag.has_partial_rollout());
    }

    #[test]
    fn test_has_partial_rollout_mixed_groups() {
        let mut flag = mock!(FeatureFlag);
        flag.filters.groups = vec![
            FlagPropertyGroup {
                properties: None,
                rollout_percentage: Some(100.0),
                variant: None,
                ..Default::default()
            },
            FlagPropertyGroup {
                properties: None,
                rollout_percentage: Some(50.0),
                variant: None,
                ..Default::default()
            },
        ];
        assert!(flag.has_partial_rollout());
    }

    #[rstest::rstest]
    #[case::no_variants(None, None, 100.0, false)]
    #[case::empty_variants(Some(vec![]), None, 100.0, false)]
    #[case::single_variant_at_100(Some(vec![100.0]), None, 100.0, false)]
    #[case::zero_before_100(Some(vec![0.0, 100.0]), None, 100.0, false)]
    #[case::all_zero(Some(vec![0.0, 0.0]), None, 100.0, false)]
    #[case::single_variant_short_of_range(Some(vec![50.0]), None, 100.0, true)]
    #[case::unpinned_variants(Some(vec![50.0, 50.0]), None, 100.0, true)]
    #[case::pinned_variant(Some(vec![50.0, 50.0]), Some("variant-0"), 100.0, false)]
    #[case::pin_names_no_variant(Some(vec![50.0, 50.0]), Some("nonexistent"), 100.0, true)]
    #[case::pinned_variant_partial_rollout(Some(vec![50.0, 50.0]), Some("variant-0"), 50.0, true)]
    fn test_condition_needs_bucketing_hash(
        #[case] variant_percentages: Option<Vec<f64>>,
        #[case] variant: Option<&str>,
        #[case] rollout_percentage: f64,
        #[case] expected: bool,
    ) {
        let mut flag = mock!(FeatureFlag);
        flag.filters.multivariate =
            variant_percentages.map(|percentages| MultivariateFlagOptions {
                variants: percentages
                    .into_iter()
                    .enumerate()
                    .map(|(i, rollout_percentage)| MultivariateFlagVariant {
                        key: format!("variant-{i}"),
                        name: None,
                        rollout_percentage,
                        ..Default::default()
                    })
                    .collect(),
                ..Default::default()
            });
        let condition = FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(rollout_percentage),
            variant: variant.map(str::to_string),
            ..Default::default()
        };
        assert_eq!(flag.condition_needs_bucketing_hash(&condition), expected);
    }

    #[test]
    fn test_needs_hash_key_override_no_continuity() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(false);
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_continuity_none() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = None;
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0),
            variant: None,
            ..Default::default()
        }];
        // None defaults to false, so no continuity means no lookup needed
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_100_percent_no_variants() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(100.0),
            variant: None,
            ..Default::default()
        }];
        // 100% rollout with no variants -> doesn't need lookup
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_partial_rollout() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0),
            variant: None,
            ..Default::default()
        }];
        // Partial rollout needs consistent bucketing
        assert!(flag.needs_hash_key_override());
        assert!(flag.has_experience_continuity());

        for version in [serde_json::json!(2), serde_json::json!(3)] {
            flag.filters = crate::flags::config_format::decode_filters(serde_json::json!({
                "version": version, "groups": [{"rollout_percentage": 50}]
            }))
            .unwrap();
            assert!(!flag.has_experience_continuity());
            assert!(!flag.needs_hash_key_override());
        }
    }

    #[test]
    fn test_needs_hash_key_override_with_variants() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(100.0),
            variant: None,
            ..Default::default()
        }];
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: None,
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: None,
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        // Has variants -> needs consistent variant assignment
        assert!(flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_group_based_flag() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.aggregation_group_type_index = Some(0); // Group-based flag
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0),
            variant: None,
            ..Default::default()
        }];
        // Group-based flags don't use hash key overrides
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_device_id_bucketing() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.bucketing_identifier = Some("device_id".to_string());
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0),
            variant: None,
            ..Default::default()
        }];
        // Device ID bucketing doesn't use hash key overrides
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_empty_groups() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.groups = vec![];
        // Empty groups means no partial rollout, doesn't need lookup
        assert!(!flag.needs_hash_key_override());
    }

    #[test]
    fn test_needs_hash_key_override_both_partial_and_variants() {
        let mut flag = mock!(FeatureFlag);
        flag.ensure_experience_continuity = Some(true);
        flag.filters.groups = vec![FlagPropertyGroup {
            properties: None,
            rollout_percentage: Some(50.0), // Partial rollout
            variant: None,
            ..Default::default()
        }];
        flag.filters.multivariate = Some(MultivariateFlagOptions {
            variants: vec![
                MultivariateFlagVariant {
                    key: "control".to_string(),
                    name: None,
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
                MultivariateFlagVariant {
                    key: "test".to_string(),
                    name: None,
                    rollout_percentage: 50.0,
                    ..Default::default()
                },
            ],
            ..Default::default()
        });
        // Both conditions satisfied -> needs lookup
        assert!(flag.needs_hash_key_override());
    }

    #[test]
    fn test_flags_require_db_preparation_skips_filtered_out() {
        let person_property = mock!(crate::properties::property_models::PropertyFilter, key: "email".mock_into(), prop_type: PropertyType::Person, operator: Some(OperatorType::Exact));
        let mut flag_a = mock!(FeatureFlag, filters: vec![person_property.clone()].mock_into());
        flag_a.id = 1;
        flag_a.key = "flag_a".to_string();
        let mut flag_b = mock!(FeatureFlag, filters: vec![person_property].mock_into());
        flag_b.id = 2;
        flag_b.key = "flag_b".to_string();

        let flags: Vec<&FeatureFlag> = vec![&flag_a, &flag_b];
        let overrides = HashMap::new();

        // Without filtering, both flags require DB preparation
        let result =
            flags_require_db_preparation(&flags, &overrides, &HashSet::new(), &|_, _| true);
        assert_eq!(result.len(), 2);

        // With flag_a filtered out, only flag_b requires preparation
        let filtered = HashSet::from([1]);
        let result = flags_require_db_preparation(&flags, &overrides, &filtered, &|_, _| true);
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].key, "flag_b");

        // With both filtered, none require preparation
        let filtered = HashSet::from([1, 2]);
        let result = flags_require_db_preparation(&flags, &overrides, &filtered, &|_, _| true);
        assert!(result.is_empty());
    }
}