test(lazy): Lift _make_lazy_context into pytest fixtures

Replaces the module-level helper with three fixtures:

  * ``lazy_context_factory`` — keyword-only callable producing an
    evaluation context, for tests that need a non-default shape.
  * ``lazy_context`` — a default context (identity matches the
    segment override).
  * ``lazy_flags`` — a ``Flags`` built from the default context.

Tests now request whichever fixture suits their case instead of
calling the helper directly. While here, mark each test body with
Given / When / Then comments to match the rest of the file.

beep boop

Author: khvn26

tests/test_models.py

@@ -172,162 +172,207 @@ def test_get_flag_without_pipeline_processor() -> None:
     assert flag.enabled is True
 
 
-def _make_lazy_context(
-    *,
-    extra_features: int = 2,
-    identity_trait_value: str = "premium",
-    segment_match_value: str = "premium",
-) -> SDKEvaluationContext:
-    """Build a minimal evaluation context for lazy-Flags tests.
+LazyContextFactory = typing.Callable[..., SDKEvaluationContext]
+
+
+@pytest.fixture
+def lazy_context_factory() -> LazyContextFactory:
+    """Factory for minimal evaluation contexts used by the lazy-Flags tests.
 
-    Structure: a "target" feature with a single segment override that
-    matches when ``tier == segment_match_value`` (priority 0), plus a
-    handful of no-override "noise" features whose values should come
-    straight off the base feature context. ``identity_trait_value`` sets
-    the identity's ``tier`` trait so tests can exercise match / no-match.
+    The returned context has a ``target`` feature with a single segment
+    override (matches when ``tier == segment_match_value``, priority 0)
+    plus ``extra_features`` no-override "noise" features whose values
+    should come straight off the base feature context.
     """
-    features: typing.Dict[str, typing.Any] = {
-        "target": {
-            "key": "target",
-            "name": "target",
-            "enabled": False,
-            "value": "base-value",
-            "metadata": {"id": 1},
-        },
-    }
-    for i in range(extra_features):
-        features[f"noise_{i}"] = {
-            "key": f"noise_{i}",
-            "name": f"noise_{i}",
-            "enabled": True,
-            "value": f"noise-value-{i}",
-            "metadata": {"id": 100 + i},
+
+    def make(
+        *,
+        extra_features: int = 2,
+        identity_trait_value: str = "premium",
+        segment_match_value: str = "premium",
+    ) -> SDKEvaluationContext:
+        features: typing.Dict[str, typing.Any] = {
+            "target": {
+                "key": "target",
+                "name": "target",
+                "enabled": False,
+                "value": "base-value",
+                "metadata": {"id": 1},
+            },
         }
-    return {
-        "environment": {"key": "env-key", "name": "env"},
-        "features": features,
-        "segments": {
-            "premium_segment": {
-                "key": "premium_segment",
-                "name": "premium_segment",
-                "rules": [
-                    {
-                        "type": "ALL",
-                        "conditions": [
-                            {
-                                "property": "tier",
-                                "operator": "EQUAL",
-                                "value": segment_match_value,
-                            },
-                        ],
-                    }
-                ],
-                "overrides": [
-                    {
-                        "key": "target",
-                        "name": "target",
-                        "enabled": True,
-                        "value": "premium-value",
-                        "priority": 0.0,
-                        "metadata": {"id": 1},
-                    },
-                ],
+        for i in range(extra_features):
+            features[f"noise_{i}"] = {
+                "key": f"noise_{i}",
+                "name": f"noise_{i}",
+                "enabled": True,
+                "value": f"noise-value-{i}",
+                "metadata": {"id": 100 + i},
+            }
+        return {
+            "environment": {"key": "env-key", "name": "env"},
+            "features": features,
+            "segments": {
+                "premium_segment": {
+                    "key": "premium_segment",
+                    "name": "premium_segment",
+                    "rules": [
+                        {
+                            "type": "ALL",
+                            "conditions": [
+                                {
+                                    "property": "tier",
+                                    "operator": "EQUAL",
+                                    "value": segment_match_value,
+                                },
+                            ],
+                        }
+                    ],
+                    "overrides": [
+                        {
+                            "key": "target",
+                            "name": "target",
+                            "enabled": True,
+                            "value": "premium-value",
+                            "priority": 0.0,
+                            "metadata": {"id": 1},
+                        },
+                    ],
+                },
             },
-        },
-        "identity": {
-            "identifier": "user-1",
-            "key": "env-key_user-1",
-            "traits": {"tier": identity_trait_value},
-        },
-    }
+            "identity": {
+                "identifier": "user-1",
+                "key": "env-key_user-1",
+                "traits": {"tier": identity_trait_value},
+            },
+        }
 
+    return make
 
-def test_lazy_flags__get_flag__applies_matching_segment_override() -> None:
-    ctx = _make_lazy_context()
-    flags = Flags.from_evaluation_context(
-        context=ctx,
-        overrides_index=build_segment_overrides_index(ctx),
+
+@pytest.fixture
+def lazy_context(
+    lazy_context_factory: LazyContextFactory,
+) -> SDKEvaluationContext:
+    """Default evaluation context: identity matches the segment override."""
+    return lazy_context_factory()
+
+
+@pytest.fixture
+def lazy_flags(lazy_context: SDKEvaluationContext) -> Flags:
+    """Lazy ``Flags`` built from the default context, no analytics, no handler."""
+    return Flags.from_evaluation_context(
+        context=lazy_context,
+        overrides_index=build_segment_overrides_index(lazy_context),
         analytics_processor=None,
         default_flag_handler=None,
     )
 
-    target = flags.get_flag("target")
+
+def test_lazy_flags__get_flag__applies_matching_segment_override(
+    lazy_flags: Flags,
+) -> None:
+    # Given: identity matches the segment rule (default context).
+    # When: we read the targeted feature.
+    target = lazy_flags.get_flag("target")
+    # Then: the override wins over the base feature value.
     assert target.enabled is True
     assert target.value == "premium-value"
 
 
-def test_lazy_flags__get_flag__skips_non_matching_segment_override() -> None:
-    # Segment rule requires tier == "premium"; identity has tier "free",
-    # so the override must not win and base-value should come through.
-    ctx = _make_lazy_context(identity_trait_value="free")
-
+def test_lazy_flags__get_flag__skips_non_matching_segment_override(
+    lazy_context_factory: LazyContextFactory,
+) -> None:
+    # Given: segment rule requires tier == "premium" but identity has tier "free".
+    ctx = lazy_context_factory(identity_trait_value="free")
     flags = Flags.from_evaluation_context(
         context=ctx,
         overrides_index=build_segment_overrides_index(ctx),
         analytics_processor=None,
         default_flag_handler=None,
     )
+
+    # When: we read the targeted feature.
     target = flags.get_flag("target")
+
+    # Then: the override doesn't win and base-value comes through.
     assert target.enabled is False
     assert target.value == "base-value"
 
 
-def test_lazy_flags__get_flag__caches_per_feature() -> None:
-    ctx = _make_lazy_context(extra_features=5)
+def test_lazy_flags__get_flag__caches_per_feature(
+    lazy_context_factory: LazyContextFactory,
+) -> None:
+    # Given: a context with several no-override features.
+    ctx = lazy_context_factory(extra_features=5)
     flags = Flags.from_evaluation_context(
         context=ctx,
         overrides_index=build_segment_overrides_index(ctx),
         analytics_processor=None,
         default_flag_handler=None,
     )
 
+    # When: we read a single feature once.
     flags.get_flag("noise_0")
-    # Only the accessed feature is populated.
+
+    # Then: only that feature is populated in the cache.
     assert set(flags.flags.keys()) == {"noise_0"}
 
-    # A repeated read hits the cache rather than rebuilding the Flag.
+    # And: repeated reads return the same Flag instance, not a rebuild.
     first = flags.get_flag("noise_0")
     second = flags.get_flag("noise_0")
     assert first is second
 
 
-def test_lazy_flags__all_flags__materialises_every_feature() -> None:
-    ctx = _make_lazy_context(extra_features=3)
+def test_lazy_flags__all_flags__materialises_every_feature(
+    lazy_context_factory: LazyContextFactory,
+) -> None:
+    # Given: a context with three no-override features plus the target.
+    ctx = lazy_context_factory(extra_features=3)
     flags = Flags.from_evaluation_context(
         context=ctx,
         overrides_index=build_segment_overrides_index(ctx),
         analytics_processor=None,
         default_flag_handler=None,
     )
 
+    # When: the caller asks for the full set.
     materialised = flags.all_flags()
+
+    # Then: every feature in the context is present.
     names = {flag.feature_name for flag in materialised}
     assert names == {"target", "noise_0", "noise_1", "noise_2"}
-    # Second call is a no-op: everything is already resolved.
-    assert flags.all_flags() == materialised
 
+    # And: a second call is a no-op — everything is already resolved.
+    assert flags.all_flags() == materialised
 
-def test_lazy_flags__missing_feature__falls_through_to_default_handler() -> None:
-    ctx = _make_lazy_context()
 
+def test_lazy_flags__missing_feature__falls_through_to_default_handler(
+    lazy_context: SDKEvaluationContext,
+) -> None:
+    # Given: a Flags wired to a default-flag handler.
     def default(name: str) -> DefaultFlag:
         return DefaultFlag(enabled=False, value=f"default-for-{name}")
 
     flags = Flags.from_evaluation_context(
-        context=ctx,
-        overrides_index=build_segment_overrides_index(ctx),
+        context=lazy_context,
+        overrides_index=build_segment_overrides_index(lazy_context),
         analytics_processor=None,
         default_flag_handler=default,
     )
+
+    # When: we ask for a feature that isn't in the context.
     result = flags.get_flag("does_not_exist")
+
+    # Then: the handler produces the default flag for that name.
     assert result.value == "default-for-does_not_exist"
 
 
-def test_build_segment_overrides_index__indexes_only_overriding_segments() -> None:
-    ctx = _make_lazy_context()
-    # Add a second segment without overrides — must not appear in the index.
-    assert ctx["segments"] is not None
-    ctx["segments"]["no_override_segment"] = {
+def test_build_segment_overrides_index__indexes_only_overriding_segments(
+    lazy_context: SDKEvaluationContext,
+) -> None:
+    # Given: a second segment with no overrides on top of the default context.
+    assert lazy_context["segments"] is not None
+    lazy_context["segments"]["no_override_segment"] = {
         "key": "no_override_segment",
         "name": "no_override_segment",
         "rules": [
@@ -340,6 +385,9 @@ def test_build_segment_overrides_index__indexes_only_overriding_segments() -> No
         ],
     }
 
-    index = build_segment_overrides_index(ctx)
+    # When: we build the reverse index.
+    index = build_segment_overrides_index(lazy_context)
+
+    # Then: only segments that actually carry an override appear.
     assert set(index) == {"target"}
     assert index["target"][0]["name"] == "premium_segment"