test: Point benchmark + coverage at shared large-env fixture

- Bump the engine-test-data submodule to pick up Flagsmith/engine-test-data#51
  (a realistic 262-feature / 26-multivariate / segment-override test case
  mirroring the #198 scenario) and consume it as the large-context
  benchmark, dropping the synthetic local fixture.
- Exercise the `metadata` branch of the `get_flag_result_from_context`
  wrapper by adding metadata to the existing parametrized test.
- Add a test for the `value == 100` recursive fallback on the new
  two-key fast-path hasher.

Restores 100% coverage and keeps the realistic benchmark portable across
every SDK consuming engine-test-data, rather than living only in this
repo's Python tests.

beep boop

Author: khvn26

tests/engine_tests/engine-test-data

@@ -6,11 +6,14 @@
 import pytest
 from _pytest.mark import ParameterSet
 
-from flag_engine.context.types import EvaluationContext, FeatureContext
+from flag_engine.context.types import EvaluationContext
 from flag_engine.engine import get_evaluation_result
 from flag_engine.result.types import EvaluationResult
 
 TEST_CASES_PATH = Path(__file__).parent / "engine-test-data/test_cases"
+LARGE_ENVIRONMENT_TEST_CASE = (
+    "test_000000cf-0000-0000-0000-000000000000__large_environment.json"
+)
 
 EnvironmentDocument = dict[str, typing.Any]
 
@@ -40,66 +43,19 @@ def _extract_benchmark_contexts(
         yield pyjson5.loads((test_cases_dir_path / file_path).read_text())["context"]
 
 
-def _build_large_benchmark_context(
-    n_features: int = 262,
-    multivariate_features: int = 26,
-) -> EvaluationContext:
-    """Mirror the scenario from flagsmith-python-client issue #198: a real-world
-    local-evaluation environment with ~260 features, a handful of which use
-    multivariate splits, evaluated for a single identity. Small enough to
-    keep the benchmark fast but large enough to surface per-feature overhead.
-    """
-    features: dict[str, FeatureContext[typing.Any]] = {}
-    for i in range(n_features):
-        name = f"feature_{i:04d}"
-        fc: FeatureContext[typing.Any] = {
-            "key": str(i + 1),
-            "name": name,
-            "enabled": bool(i % 2),
-            "value": f"value-{i}",
-            "metadata": {"id": i + 1},
-        }
-        if i < multivariate_features:
-            # Intentionally reverse-ordered so ``sorted()`` has work to do.
-            fc["variants"] = [
-                {"value": f"mv-{i}-b", "weight": 40.0, "priority": 2},
-                {"value": f"mv-{i}-a", "weight": 60.0, "priority": 1},
-            ]
-        features[name] = fc
-    return {
-        "environment": {"key": "bench-env", "name": "bench"},
-        "features": features,
-        "segments": {
-            "1": {
-                "key": "1",
-                "name": "bench-segment",
-                "rules": [
-                    {
-                        "type": "ALL",
-                        "conditions": [
-                            {
-                                "property": "venue_id",
-                                "operator": "EQUAL",
-                                "value": "no-match",
-                            }
-                        ],
-                    }
-                ],
-            }
-        },
-        "identity": {
-            "identifier": "anonymous",
-            "traits": {"venue_id": "12345"},
-        },
-    }
+def _load_test_case_context(name: str) -> EvaluationContext:
+    ctx: EvaluationContext = pyjson5.loads((TEST_CASES_PATH / name).read_text())[
+        "context"
+    ]
+    return ctx
 
 
 TEST_CASES = sorted(
     _extract_test_cases(TEST_CASES_PATH),
     key=lambda param: str(param.id),
 )
 BENCHMARK_CONTEXTS = list(_extract_benchmark_contexts(TEST_CASES_PATH))
-LARGE_BENCHMARK_CONTEXT = _build_large_benchmark_context()
+LARGE_BENCHMARK_CONTEXT = _load_test_case_context(LARGE_ENVIRONMENT_TEST_CASE)
 
 
 @pytest.mark.parametrize(

tests/engine_tests/test_engine.py

@@ -806,6 +806,7 @@ def test_segment_condition_matches_context_value_for_modulo(
                 "name": "my_feature",
                 "reason": "SPLIT; weight=30",
                 "value": "foo",
+                "metadata": {"id": 7},
             },
         ),
         (
@@ -815,6 +816,7 @@ def test_segment_condition_matches_context_value_for_modulo(
                 "name": "my_feature",
                 "reason": "SPLIT; weight=30",
                 "value": "bar",
+                "metadata": {"id": 7},
             },
         ),
         (
@@ -824,6 +826,7 @@ def test_segment_condition_matches_context_value_for_modulo(
                 "name": "my_feature",
                 "reason": "DEFAULT",
                 "value": "control",
+                "metadata": {"id": 7},
             },
         ),
     ),
@@ -851,6 +854,7 @@ def test_get_flag_result_from_context__calls_returns_expected(
         "enabled": False,
         "name": "my_feature",
         "value": "control",
+        "metadata": {"id": 7},
         "variants": [
             {"value": "foo", "weight": 30, "priority": 1},
             {"value": "bar", "weight": 30, "priority": 2},

tests/unit/segments/test_segments_evaluator.py

@@ -5,7 +5,10 @@
 
 import pytest
 
-from flag_engine.utils.hashing import get_hashed_percentage_for_object_ids
+from flag_engine.utils.hashing import (
+    get_hashed_percentage_for_object_id_pair,
+    get_hashed_percentage_for_object_ids,
+)
 
 
 @pytest.mark.parametrize(
@@ -146,3 +149,31 @@ def hexdigest_side_effect() -> str:
     # the second call, with a string (in bytes) that contains each object id twice
     expected_bytes_2 = ",".join(str(id_) for id_ in object_ids * 2).encode("utf-8")
     assert call_list[1][0][0] == expected_bytes_2
+
+
+@mock.patch("flag_engine.utils.hashing.hashlib")
+def test_get_hashed_percentage_for_object_id_pair__value_is_100__falls_back(
+    mock_hashlib: mock.Mock,
+) -> None:
+    """When the two-key fast path would return exactly 100, it must fall back
+    to the generic helper with iterations=2 (same anti-boundary guarantee as
+    ``get_hashed_percentage_for_object_ids``)."""
+
+    # 270e converts to 9998, forcing value == 100. 270f → 9999 → value == 0.
+    hashed_values = ["270f", "270e"]
+
+    def hexdigest_side_effect() -> str:
+        return hashed_values.pop()
+
+    mock_hash = mock.MagicMock()
+    mock_hashlib.md5.return_value = mock_hash
+    mock_hash.hexdigest.side_effect = hexdigest_side_effect
+
+    value = get_hashed_percentage_for_object_id_pair("12", "93")
+
+    assert value == 0
+    # First call: fast-path two-key hash (single pair); second: recursive fallback.
+    call_list = mock_hashlib.md5.call_args_list
+    assert len(call_list) == 2
+    assert call_list[0][0][0] == b"12,93"
+    assert call_list[1][0][0] == b"12,93,12,93"