posthoganalytics 6.6.0__py3-none-any.whl → 6.7.0__py3-none-any.whl

posthoganalytics/test/test_feature_flags.py

@@ -1361,6 +1361,8 @@ class TestLocalEvaluation(unittest.TestCase):
     def test_feature_flags_with_flag_dependencies(
         self, patch_get, patch_flags, mock_log
     ):
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
         client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
         client.feature_flags = [
             {
@@ -1374,9 +1376,10 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "beta-feature",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
+                                    "dependency_chain": ["beta-feature"],
                                 },
                                 {
                                     "key": "email",
@@ -1392,39 +1395,955 @@ class TestLocalEvaluation(unittest.TestCase):
             }
         ]
 
-        # Test that flag evaluation doesn't fail when encountering a flag dependency
-        # The flag should evaluate based on other conditions (email contains @example.com)
-        # Since flag dependencies aren't implemented, it should skip the flag condition
-        # and evaluate based on the email condition only
+        # Test that flag evaluation handles flag dependencies properly
+        # The flag has a dependency on "beta-feature" which doesn't exist locally
+        # Since the dependency doesn't exist, local evaluation should fail and fall back to remote
+        # Remote returns empty result, so final result is None
         feature_flag_match = client.get_feature_flag(
             "flag-with-dependencies",
             "test-user",
             person_properties={"email": "test@example.com"},
         )
-        self.assertEqual(feature_flag_match, True)
-        self.assertEqual(patch_flags.call_count, 0)
+        self.assertIsNone(feature_flag_match)
+        self.assertEqual(patch_flags.call_count, 1)
         self.assertEqual(patch_get.call_count, 0)
 
-        # Verify warning was logged for flag dependency
-        mock_log.warning.assert_called_with(
-            "Flag dependency filters are not supported in local evaluation. "
-            "Skipping condition for flag '%s' with dependency on flag '%s'",
-            "flag-with-dependencies",
-            "beta-feature",
-        )
-
-        # Test with email that doesn't match
+        # Test with email that doesn't match (should also fall back to remote due to missing dependency)
         feature_flag_match = client.get_feature_flag(
             "flag-with-dependencies",
             "test-user-2",
             person_properties={"email": "test@other.com"},
         )
-        self.assertEqual(feature_flag_match, False)
-        self.assertEqual(patch_flags.call_count, 0)
+        self.assertIsNone(feature_flag_match)
+        self.assertEqual(patch_flags.call_count, 2)  # Called twice now
         self.assertEqual(patch_get.call_count, 0)
 
-        # Verify warning was logged again for the second evaluation
-        self.assertEqual(mock_log.warning.call_count, 2)
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_simple_chain(self, patch_get, patch_flags):
+        """Test basic flag dependency: flag-b depends on flag-a"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "operator": "icontains",
+                                    "value": "@example.com",
+                                    "type": "person",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Test when dependency is satisfied
+        result = client.get_feature_flag(
+            "flag-b",
+            "test-user",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, True)
+
+        # Test when dependency is not satisfied
+        result = client.get_feature_flag(
+            "flag-b",
+            "test-user-2",
+            person_properties={"email": "test@other.com"},
+        )
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_circular_dependency(self, patch_get, patch_flags):
+        """Test circular dependency handling: flag-a depends on flag-b, flag-b depends on flag-a"""
+        # Mock remote flags call to return empty for these flags (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-b",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": [],  # Empty chain indicates circular dependency
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": [],  # Empty chain indicates circular dependency
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Both flags should fall back to remote evaluation due to circular dependency
+        # Since we're not mocking the remote call, both should return None
+        result_a = client.get_feature_flag("flag-a", "test-user")
+        self.assertIsNone(result_a)
+
+        result_b = client.get_feature_flag("flag-b", "test-user")
+        self.assertIsNone(result_b)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_missing_flag(self, patch_get, patch_flags):
+        """Test handling of missing flag dependency"""
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "non-existent-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["non-existent-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            }
+        ]
+
+        # Should fall back to remote evaluation because dependency doesn't exist
+        # Since we're not mocking the remote call, should return None
+        result = client.get_feature_flag("flag-a", "test-user")
+        self.assertIsNone(result)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_complex_chain(self, patch_get, patch_flags):
+        """Test complex dependency chain: flag-d -> flag-c -> [flag-a, flag-b]"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 3,
+                "name": "Flag C",
+                "key": "flag-c",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a"],
+                                },
+                                {
+                                    "key": "flag-b",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-b"],
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 4,
+                "name": "Flag D",
+                "key": "flag-d",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-c",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a", "flag-b", "flag-c"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # All dependencies satisfied - should return True
+        result = client.get_feature_flag("flag-d", "test-user")
+        self.assertEqual(result, True)
+
+        # Make flag-a inactive - should break the chain
+        client.feature_flags[0]["active"] = False
+        result = client.get_feature_flag("flag-d", "test-user")
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_mixed_conditions(self, patch_get, patch_flags):
+        """Test flag dependency mixed with other property conditions"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Base Flag",
+                "key": "base-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Mixed Flag",
+                "key": "mixed-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "base-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["base-flag"],
+                                },
+                                {
+                                    "key": "email",
+                                    "operator": "icontains",
+                                    "value": "@example.com",
+                                    "type": "person",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Both flag dependency and email condition satisfied
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, True)
+
+        # Flag dependency satisfied but email condition not satisfied
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user-2",
+            person_properties={"email": "test@other.com"},
+        )
+        self.assertEqual(result, False)
+
+        # Email condition satisfied but flag dependency not satisfied
+        client.feature_flags[0]["active"] = False
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user-3",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_malformed_chain(self, patch_get, patch_flags):
+        """Test handling of malformed dependency chains"""
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Base Flag",
+                "key": "base-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Missing Chain Flag",
+                "key": "missing-chain-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "base-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": True,
+                                    "type": "flag",
+                                    # No dependency_chain property - should evaluate as inconclusive
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Should fall back to remote evaluation when dependency_chain is missing
+        # Since we're not mocking the remote call, should return None
+        result = client.get_feature_flag("missing-chain-flag", "test-user")
+        self.assertIsNone(result)
+
+    def test_flag_dependencies_without_context_raises_inconclusive(self):
+        """Test that missing flags_by_key raises InconclusiveMatchError"""
+        from posthoganalytics.feature_flags import (
+            evaluate_flag_dependency,
+            InconclusiveMatchError,
+        )
+
+        property_with_flag_dep = {
+            "key": "some-flag",
+            "operator": "flag_evaluates_to",
+            "value": True,
+            "type": "flag",
+            "dependency_chain": ["some-flag"],
+        }
+
+        # Should raise InconclusiveMatchError when flags_by_key is None
+        with self.assertRaises(InconclusiveMatchError) as cm:
+            evaluate_flag_dependency(
+                property_with_flag_dep,
+                flags_by_key=None,  # This should trigger the error
+                evaluation_cache={},
+                distinct_id="test-user",
+                properties={},
+                cohort_properties={},
+            )
+
+        self.assertIn("Cannot evaluate flag dependency", str(cm.exception))
+        self.assertIn("some-flag", str(cm.exception))
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_multi_level_multivariate_dependency_chain(self, patch_get, patch_flags):
+        """Test multi-level multivariate dependency chain: dependent-flag -> intermediate-flag -> leaf-flag"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            # Leaf flag: multivariate with "control" and "test" variants using person property overrides
+            {
+                "id": 1,
+                "name": "Leaf Flag",
+                "key": "leaf-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": "control@example.com",
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "control",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": "test@example.com",
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "test",
+                        },
+                        {
+                            "rollout_percentage": 50,
+                            "variant": "control",
+                        },  # Default fallback
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {
+                                "key": "control",
+                                "name": "Control",
+                                "rollout_percentage": 50,
+                            },
+                            {"key": "test", "name": "Test", "rollout_percentage": 50},
+                        ]
+                    },
+                },
+            },
+            # Intermediate flag: multivariate with "blue" and "green" variants, depends on leaf-flag="control"
+            {
+                "id": 2,
+                "name": "Intermediate Flag",
+                "key": "intermediate-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "leaf-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "control",
+                                    "type": "flag",
+                                    "dependency_chain": ["leaf-flag"],
+                                },
+                                {
+                                    "key": "variant_type",
+                                    "type": "person",
+                                    "value": "blue",
+                                    "operator": "exact",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "blue",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "leaf-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "control",
+                                    "type": "flag",
+                                    "dependency_chain": ["leaf-flag"],
+                                },
+                                {
+                                    "key": "variant_type",
+                                    "type": "person",
+                                    "value": "green",
+                                    "operator": "exact",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "green",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "blue", "name": "Blue", "rollout_percentage": 50},
+                            {"key": "green", "name": "Green", "rollout_percentage": 50},
+                        ]
+                    },
+                },
+            },
+            # Dependent flag: boolean flag that depends on intermediate-flag="blue"
+            {
+                "id": 3,
+                "name": "Dependent Flag",
+                "key": "dependent-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "intermediate-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "blue",
+                                    "type": "flag",
+                                    "dependency_chain": [
+                                        "leaf-flag",
+                                        "intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Test using person properties and variant overrides to ensure predictable variants
+
+        # Test 1: Make sure the leaf flag evaluates to the variant we expect using email overrides
+        self.assertEqual(
+            "control",
+            client.get_feature_flag(
+                "leaf-flag",
+                "any-user",
+                person_properties={"email": "control@example.com"},
+            ),
+        )
+        self.assertEqual(
+            "test",
+            client.get_feature_flag(
+                "leaf-flag",
+                "any-user",
+                person_properties={"email": "test@example.com"},
+            ),
+        )
+
+        # Test 2: Make sure the intermediate flag evaluates to the expected variants when dependency is satisfied
+        self.assertEqual(
+            "blue",
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        self.assertEqual(
+            "green",
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "green",
+                },
+            ),
+        )
+
+        # Test 3: Make sure the intermediate flag evaluates to false when leaf dependency fails
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "test@example.com",  # This makes leaf-flag="test", breaking dependency
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        # Test 4: When leaf-flag="control", intermediate="blue", dependent should be true
+        self.assertEqual(
+            True,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        # Test 5: When leaf-flag="control", intermediate="green", dependent should be false
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "green",
+                },
+            ),
+        )
+
+        # Test 6: When leaf-flag="test", intermediate is False, dependent should be false
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={"email": "test@example.com", "variant_type": "blue"},
+            ),
+        )
+
+    def test_matches_dependency_value(self):
+        """Test the matches_dependency_value function logic"""
+        from posthoganalytics.feature_flags import matches_dependency_value
+
+        # String variant matches string exactly (case-sensitive)
+        self.assertTrue(matches_dependency_value("control", "control"))
+        self.assertTrue(matches_dependency_value("Control", "Control"))
+        self.assertFalse(matches_dependency_value("control", "Control"))
+        self.assertFalse(matches_dependency_value("Control", "CONTROL"))
+        self.assertFalse(matches_dependency_value("control", "test"))
+
+        # String variant matches boolean true (any variant is truthy)
+        self.assertTrue(matches_dependency_value(True, "control"))
+        self.assertTrue(matches_dependency_value(True, "test"))
+        self.assertFalse(matches_dependency_value(False, "control"))
+
+        # Boolean matches boolean exactly
+        self.assertTrue(matches_dependency_value(True, True))
+        self.assertTrue(matches_dependency_value(False, False))
+        self.assertFalse(matches_dependency_value(False, True))
+        self.assertFalse(matches_dependency_value(True, False))
+
+        # Empty string doesn't match
+        self.assertFalse(matches_dependency_value(True, ""))
+        self.assertFalse(matches_dependency_value("control", ""))
+
+        # Type mismatches
+        self.assertFalse(matches_dependency_value(123, "control"))
+        self.assertFalse(matches_dependency_value("control", True))
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_production_style_multivariate_dependency_chain(
+        self, patch_get, patch_flags
+    ):
+        """Test production-style multivariate dependency chain: multivariate-root-flag -> multivariate-intermediate-flag -> multivariate-leaf-flag"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            # Leaf flag: multivariate with fruit variants
+            {
+                "id": 451,
+                "name": "Multivariate Leaf Flag (Base)",
+                "key": "multivariate-leaf-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["pineapple@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "pineapple",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["mango@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "mango",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["papaya@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "papaya",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["kiwi@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "kiwi",
+                        },
+                        {
+                            "properties": [],
+                            "rollout_percentage": 0,  # Force default to false for unknown emails
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "pineapple", "rollout_percentage": 25},
+                            {"key": "mango", "rollout_percentage": 25},
+                            {"key": "papaya", "rollout_percentage": 25},
+                            {"key": "kiwi", "rollout_percentage": 25},
+                        ]
+                    },
+                },
+            },
+            # Intermediate flag: multivariate with color variants, depends on fruit
+            {
+                "id": 467,
+                "name": "Multivariate Intermediate Flag (Depends on fruit)",
+                "key": "multivariate-intermediate-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-leaf-flag",
+                                    "type": "flag",
+                                    "value": "pineapple",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": ["multivariate-leaf-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "blue",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-leaf-flag",
+                                    "type": "flag",
+                                    "value": "mango",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": ["multivariate-leaf-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "red",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "blue", "rollout_percentage": 100},
+                            {"key": "red", "rollout_percentage": 0},
+                            {"key": "green", "rollout_percentage": 0},
+                            {"key": "black", "rollout_percentage": 0},
+                        ]
+                    },
+                },
+            },
+            # Root flag: multivariate with show variants, depends on color
+            {
+                "id": 468,
+                "name": "Multivariate Root Flag (Depends on color)",
+                "key": "multivariate-root-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-intermediate-flag",
+                                    "type": "flag",
+                                    "value": "blue",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": [
+                                        "multivariate-leaf-flag",
+                                        "multivariate-intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "breaking-bad",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-intermediate-flag",
+                                    "type": "flag",
+                                    "value": "red",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": [
+                                        "multivariate-leaf-flag",
+                                        "multivariate-intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "the-wire",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "breaking-bad", "rollout_percentage": 100},
+                            {"key": "the-wire", "rollout_percentage": 0},
+                            {"key": "game-of-thrones", "rollout_percentage": 0},
+                            {"key": "the-expanse", "rollout_percentage": 0},
+                        ]
+                    },
+                },
+            },
+        ]
+
+        # Test successful pineapple -> blue -> breaking-bad chain
+        leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+        intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+        root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+
+        self.assertEqual(leaf_result, "pineapple")
+        self.assertEqual(intermediate_result, "blue")
+        self.assertEqual(root_result, "breaking-bad")
+
+        # Test successful mango -> red -> the-wire chain
+        mango_leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+        mango_intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+        mango_root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+
+        self.assertEqual(mango_leaf_result, "mango")
+        self.assertEqual(mango_intermediate_result, "red")
+        self.assertEqual(mango_root_result, "the-wire")
+
+        # Test broken chain - user without matching email gets default/false results
+        unknown_leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+        unknown_intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+        unknown_root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+
+        self.assertEqual(
+            unknown_leaf_result, False
+        )  # No matching email -> null variant -> false
+        self.assertEqual(unknown_intermediate_result, False)  # Dependency not satisfied
+        self.assertEqual(unknown_root_result, False)  # Chain broken
 
     @mock.patch("posthog.client.Poller")
     @mock.patch("posthog.client.get")