use case-sensitive comparisons

Author: dmarticus

posthog/client.py

@@ -714,9 +714,6 @@ def get_feature_flag(
         if self.disabled:
             return None
 
-        # Normalize key to lowercase
-        key = str(key).lower()
-
         person_properties, group_properties = self._add_local_person_and_group_properties(
             distinct_id, groups, person_properties, group_properties
         )
@@ -727,8 +724,7 @@ def get_feature_flag(
 
         if self.feature_flags:
             for flag in self.feature_flags:
-                # Compare lowercase keys
-                if str(flag["key"]).lower() == key:
+                if flag["key"] == key:
                     try:
                         response = self._compute_flag_locally(
                             flag,
@@ -826,7 +822,7 @@ def get_feature_flag_payload(
                     distinct_id, groups, person_properties, group_properties, disable_geoip
                 )
                 response = responses_and_payloads["featureFlags"].get(key, None)
-                payload = responses_and_payloads["featureFlagPayloads"].get(str(key).lower(), None)
+                payload = responses_and_payloads["featureFlagPayloads"].get(str(key), None)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature flags and payloads: {e}")
 
@@ -859,19 +855,10 @@ def _compute_payload_locally(self, key, match_value):
         if self.feature_flags_by_key is None:
             return payload
 
-        # Normalize key to lowercase when looking up flag definition
-        key = str(key).lower()
-        flag_definition = None
-        for flag_key, flag in self.feature_flags_by_key.items():
-            if str(flag_key).lower() == key:
-                flag_definition = flag
-                break
-
-        if flag_definition:
-            flag_filters = flag_definition.get("filters") or {}
-            flag_payloads = flag_filters.get("payloads") or {}
-            payload = flag_payloads.get(str(match_value).lower(), None)
-        return payload
+        flag_definition = self.feature_flags_by_key.get(key) or {}
+        flag_filters = flag_definition.get("filters") or {}
+        flag_payloads = flag_filters.get("payloads") or {}
+        payload = flag_payloads.get(str(match_value), None)
 
     def get_all_flags(
         self,

posthog/test/test_feature_flags.py

@@ -4642,7 +4642,7 @@ def test_multivariate_flag_consistency(self, patch_get):
                 self.assertFalse(feature_flag_match)
 
     @mock.patch("posthog.client.decide")
-    def test_feature_flag_case_insensitive(self, mock_decide):
+    def test_feature_flag_case_sensitive(self, mock_decide):
         client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
         client.feature_flags = [
             {
@@ -4655,16 +4655,16 @@ def test_feature_flag_case_insensitive(self, mock_decide):
             }
         ]
 
-        # Test that flag evaluation works regardless of case
+        # Test that flag evaluation is case-sensitive
         self.assertTrue(client.feature_enabled("Beta-Feature", "user1"))
-        self.assertTrue(client.feature_enabled("beta-feature", "user1"))
-        self.assertTrue(client.feature_enabled("BETA-FEATURE", "user1"))
+        self.assertFalse(client.feature_enabled("beta-feature", "user1"))
+        self.assertFalse(client.feature_enabled("BETA-FEATURE", "user1"))
 
     @mock.patch("posthog.client.decide")
-    def test_feature_flag_payload_case_insensitive(self, mock_decide):
+    def test_feature_flag_payload_case_sensitive(self, mock_decide):
         mock_decide.return_value = {
-            "featureFlags": {"beta-feature": True},
-            "featureFlagPayloads": {"beta-feature": {"some": "value"}},
+            "featureFlags": {"Beta-Feature": True},
+            "featureFlagPayloads": {"Beta-Feature": {"some": "value"}},
         }
 
         client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
@@ -4682,16 +4682,16 @@ def test_feature_flag_payload_case_insensitive(self, mock_decide):
             }
         ]
 
-        # Test that payload retrieval works regardless of case
+        # Test that payload retrieval is case-sensitive
         self.assertEqual(client.get_feature_flag_payload("Beta-Feature", "user1"), {"some": "value"})
-        self.assertEqual(client.get_feature_flag_payload("beta-feature", "user1"), {"some": "value"})
-        self.assertEqual(client.get_feature_flag_payload("BETA-FEATURE", "user1"), {"some": "value"})
+        self.assertIsNone(client.get_feature_flag_payload("beta-feature", "user1"))
+        self.assertIsNone(client.get_feature_flag_payload("BETA-FEATURE", "user1"))
 
     @mock.patch("posthog.client.decide")
-    def test_feature_flag_mixed_case_consistency(self, mock_decide):
+    def test_feature_flag_case_sensitive_consistency(self, mock_decide):
         mock_decide.return_value = {
-            "featureFlags": {"beta-feature": True},
-            "featureFlagPayloads": {"beta-feature": {"some": "value"}},
+            "featureFlags": {"Beta-Feature": True},
+            "featureFlagPayloads": {"Beta-Feature": {"some": "value"}},
         }
 
         client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
@@ -4709,10 +4709,13 @@ def test_feature_flag_mixed_case_consistency(self, mock_decide):
             }
         ]
 
-        # Test that flag evaluation and payload retrieval are consistent
-        # regardless of the case used
-        test_cases = ["Beta-Feature", "beta-feature", "BETA-FEATURE", "bEtA-FeAtUrE"]
+        # Test that flag evaluation and payload retrieval are consistently case-sensitive
+        # Only exact match should work
+        self.assertTrue(client.feature_enabled("Beta-Feature", "user1"))
+        self.assertEqual(client.get_feature_flag_payload("Beta-Feature", "user1"), {"some": "value"})
+
+        # Different cases should not match
+        test_cases = ["beta-feature", "BETA-FEATURE", "bEtA-FeAtUrE"]
         for case in test_cases:
-            # Both the flag evaluation and payload retrieval should work
-            self.assertTrue(client.feature_enabled(case, "user1"))
-            self.assertEqual(client.get_feature_flag_payload(case, "user1"), {"some": "value"})
+            self.assertFalse(client.feature_enabled(case, "user1"))
+            self.assertIsNone(client.get_feature_flag_payload(case, "user1"))