sarj-python-lint 1.43.0__tar.gz → 1.43.1__tar.gz

{sarj_python_lint-1.43.0 → sarj_python_lint-1.43.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.43.0
+Version: 1.43.1
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.43.0 → sarj_python_lint-1.43.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.43.0"
+version = "1.43.1"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-1.43.0 → sarj_python_lint-1.43.1}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -56,6 +56,15 @@ _RESOURCE_OWNERS = MappingProxyType(
 )
 
 
+def builtin_namespace_untouched(context: PythonFileContext) -> bool:
+    return not any(
+        (isinstance(node, ast.Import) and any(alias.name == "builtins" for alias in node.names))
+        or (isinstance(node, ast.ImportFrom) and node.module == "builtins")
+        or (isinstance(node, ast.Name) and node.id == "__builtins__")
+        for node in context.nodes(ast.Import, ast.ImportFrom, ast.Name)
+    )
+
+
 @final
 class ResourceProvenance:
     def __init__(self, context: PythonFileContext, *, require_static_namespace: bool = False) -> None:
@@ -86,12 +95,7 @@ class ResourceProvenance:
 
     @cached_property
     def builtin_namespace_untouched(self) -> bool:
-        return not any(
-            (isinstance(node, ast.Import) and any(alias.name == "builtins" for alias in node.names))
-            or (isinstance(node, ast.ImportFrom) and node.module == "builtins")
-            or (isinstance(node, ast.Name) and node.id == "__builtins__")
-            for node in self.context.nodes(ast.Import, ast.ImportFrom, ast.Name)
-        )
+        return builtin_namespace_untouched(self.context)
 
     def scope(self, node: ast.AST) -> ast.AST | None:
         parent = self.context.parents.get(node)

{sarj_python_lint-1.43.0 → sarj_python_lint-1.43.1}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -21,7 +21,7 @@ from sarj_python_lint.rule_base import (
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._pytest import collected_tests
-from sarj_python_lint.rules._resource_provenance import ResourceProvenance
+from sarj_python_lint.rules._resource_provenance import ResourceProvenance, builtin_namespace_untouched
 
 
 if TYPE_CHECKING:
@@ -97,13 +97,44 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             "Requires a fresh local unittest.mock.AsyncMock constructor with unshadowed imports; aliases, reassignment, reset, and ambiguous configuration are excluded.",
             "Visible provider replacement, escape or unresolved lexical ownership retains WARNING; only the closed canonical AsyncMock provider proof blocks.",
             "Only the mock itself and unchanged immediate children of unspecced, unwrapped mocks are inferred; spec children, return values, and deeper chains are excluded.",
-            "Positive call evidence includes direct assertion methods and literal integer or boolean call-state checks; unresolved call expectations are excluded.",
-            "Await evidence excludes provably vacuous checks, including zero or nonnegative counts and empty expected await sequences; unresolved expectations are accepted without inferring their values.",
+            "Positive call evidence includes direct assertion methods and literal numeric or boolean call-state checks; unresolved call expectations are excluded.",
+            "Await evidence excludes provably vacuous checks, including non-None count/list state, zero or nonnegative numeric bounds, and empty expected await sequences; unresolved expectations are accepted without inferring their values.",
+            "Length comparisons over await_args_list use count semantics only for an unshadowed builtin len without visible builtin namespace access; custom length functions remain unresolved.",
             "Conjunctions need one accepted await branch; disjunctions need accepted evidence for the same mock in every branch. Argument equality and assertion strength are not compared.",
             "Compound negation and custom expression semantics remain unresolved; no variable values or fixture graphs are inferred.",
             "Custom assertion helpers and intentional scheduling contracts may require a reasoned local suppression.",
         ),
         examples=(
+            RuleExample(
+                example_id="vacuous-await-length",
+                scenario="await-length-evidence",
+                title="An empty await history still has nonnegative length",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once()\n    assert len(send.await_args_list) >= 0\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="positive-await-length",
+                scenario="await-length-evidence",
+                title="A positive await-history length distinguishes a dropped coroutine",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once()\n    assert len(send.await_args_list) == 1\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=0,
+                public=True,
+            ),
             RuleExample(
                 example_id="spaced-positive-called-state",
                 scenario="called-attribute-spacing",
@@ -212,6 +243,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
         if tree is None:
             return []
         imports = context.module_imports
+        builtin_len = builtin_namespace_untouched(context)
         writes = {
             _reference(node)
             for node in context.nodes(ast.AST)
@@ -221,14 +253,20 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             finding
             for test in collected_tests(tree.body)
             if not _is_pytest_fixture(test, imports)
-            for finding in _test_diagnostics(test, context, imports, writes, self.code)
+            for finding in _test_diagnostics(test, context, imports, writes, self.code, builtin_len=builtin_len)
         ]
 
 
 def _test_diagnostics(
-    test: _TestFunction, context: PythonFileContext, imports: ImportIndex, writes: set[_Reference], code: str
+    test: _TestFunction,
+    context: PythonFileContext,
+    imports: ImportIndex,
+    writes: set[_Reference],
+    code: str,
+    *,
+    builtin_len: bool,
 ) -> list[Diagnostic]:
-    calls = tuple(_uncovered_calls(_test_imports(imports, test), test, writes))
+    calls = tuple(_uncovered_calls(_test_imports(imports, test), test, writes, builtin_len=builtin_len))
     if not calls:
         return []
     severity = Severity.ERROR if _mock_provider_proven(test, context) else Severity.WARNING
@@ -281,11 +319,11 @@ def _test_imports(module: ImportIndex, test: _TestFunction) -> ImportIndex:
 
 
 def _uncovered_calls(
-    imports: ImportIndex, test: _TestFunction, writes: set[_Reference]
+    imports: ImportIndex, test: _TestFunction, writes: set[_Reference], *, builtin_len: bool
 ) -> Iterator[ast.Call | ast.Attribute]:
     nodes = tuple(walk_ast(test))
     bindings = _mock_bindings(imports, test.body, writes)
-    covered = _await_oracles(test.body)
+    covered = _await_oracles(test.body, builtin_len=builtin_len and imports.builtin_is_unshadowed("len"))
     reported: set[_Reference] = set()
     for statement in test.body:
         for reference, oracle in _call_oracles(statement):
@@ -375,7 +413,7 @@ def _is_async_reference(reference: _Reference, constructor: ast.Call) -> bool:
     )
 
 
-def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
+def _await_oracles(statements: list[ast.stmt], *, builtin_len: bool) -> set[_Reference]:
     covered: set[_Reference] = set()
     for statement in statements:
         match statement:
@@ -385,7 +423,7 @@ def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
                 if method != "assert_has_awaits" or _calls_evidence(call) is not _Evidence.INSUFFICIENT:
                     covered.add(_reference(receiver))
             case ast.Assert(test=condition):
-                covered.update(_asserted_states(condition, _AWAIT_STATE))
+                covered.update(_asserted_states(condition, _AWAIT_STATE, builtin_len=builtin_len))
             case _:
                 pass
     return covered
@@ -409,17 +447,21 @@ def _sequence_evidence(node: ast.expr) -> _Evidence:
     return _Evidence.UNRESOLVED
 
 
-def _asserted_states(condition: ast.expr, states: frozenset[str]) -> set[_Reference]:
+def _asserted_states(condition: ast.expr, states: frozenset[str], *, builtin_len: bool = False) -> set[_Reference]:
     match condition:
         case ast.UnaryOp(op=ast.Not(), operand=ast.UnaryOp(op=ast.Not(), operand=operand)):
-            return _asserted_states(operand, states)
+            return _asserted_states(operand, states, builtin_len=builtin_len)
         case ast.UnaryOp(op=ast.Not(), operand=ast.Compare(left=left, ops=[operator], comparators=[right])):
             inverse = _negated_operator(operator)
-            return _comparison_states(left, inverse, right, states) if inverse is not None else set()
+            return (
+                _comparison_states(left, inverse, right, states, builtin_len=builtin_len)
+                if inverse is not None
+                else set()
+            )
         case ast.UnaryOp(op=ast.Not(), operand=ast.Attribute(attr=attribute)) if attribute in states:
             return set()
         case ast.BoolOp(op=operator, values=values):
-            branches = [_asserted_states(value, states) for value in values]
+            branches = [_asserted_states(value, states, builtin_len=builtin_len) for value in values]
             return (
                 branches[0].union(*branches[1:])
                 if isinstance(operator, ast.And)
@@ -430,7 +472,7 @@ def _asserted_states(condition: ast.expr, states: frozenset[str]) -> set[_Refere
         case ast.Compare(left=left, ops=operators, comparators=rights):
             result: set[_Reference] = set()
             for first, operator, second in zip((left, *rights[:-1]), operators, rights, strict=True):
-                result.update(_comparison_states(first, operator, second, states))
+                result.update(_comparison_states(first, operator, second, states, builtin_len=builtin_len))
             return result
         case _:
             # Preserve acceptance of unresolved await-state assertions, such as
@@ -453,18 +495,37 @@ def _negated_operator(operator: ast.cmpop) -> ast.cmpop | None:
     return factory() if factory is not None else None
 
 
-def _comparison_states(left: ast.expr, operator: ast.cmpop, right: ast.expr, states: frozenset[str]) -> set[_Reference]:
+def _comparison_states(
+    left: ast.expr, operator: ast.cmpop, right: ast.expr, states: frozenset[str], *, builtin_len: bool = False
+) -> set[_Reference]:
     result: set[_Reference] = set()
     for node, comparison, expected in ((left, operator, right), (right, _reversed_operator(operator), left)):
-        if isinstance(node, ast.Attribute) and node.attr in states:
-            evidence = _state_evidence(node.attr, comparison, expected)
+        state = _state_operand(node, states, builtin_len=builtin_len)
+        if state is not None:
+            evidence = _state_evidence(
+                "await_count" if isinstance(node, ast.Call) else state.attr, comparison, expected
+            )
             if evidence is _Evidence.POSITIVE or (states == _AWAIT_STATE and evidence is _Evidence.UNRESOLVED):
-                result.add(_reference(node.value))
+                result.add(_reference(state.value))
         else:
             result.update(_unresolved_await_states(node, states))
     return result
 
 
+def _state_operand(node: ast.expr, states: frozenset[str], *, builtin_len: bool) -> ast.Attribute | None:
+    if isinstance(node, ast.Attribute) and node.attr in states:
+        return node
+    if builtin_len and states == _AWAIT_STATE:
+        match node:
+            case ast.Call(
+                func=ast.Name(id="len"), args=[ast.Attribute(attr="await_args_list") as argument], keywords=[]
+            ):
+                return argument
+            case _:
+                pass
+    return None
+
+
 def _reversed_operator(operator: ast.cmpop) -> ast.cmpop:
     match operator:
         case ast.Lt():
@@ -489,12 +550,14 @@ def _unresolved_await_states(node: ast.expr, states: frozenset[str]) -> set[_Ref
 
 def _state_evidence(attribute: str, operator: ast.cmpop, expected: ast.expr) -> _Evidence:
     positive: bool
-    if (
-        attribute in {"call_count", "await_count"}
+    if attribute in {"call_count", "await_count"} and (value := _literal_number(expected)) is not None:
+        positive = _proves_positive_count(operator, value)
+    elif (
+        attribute in {"call_count", "await_count", "await_args_list"}
         and isinstance(expected, ast.Constant)
-        and isinstance(expected.value, int)
+        and expected.value is None
     ):
-        positive = _proves_positive_count(operator, expected.value)
+        return _Evidence.INSUFFICIENT
     elif attribute == "called" and isinstance(expected, ast.Constant) and isinstance(expected.value, bool):
         positive = (isinstance(operator, (ast.Eq, ast.Is)) and expected.value) or (
             isinstance(operator, (ast.NotEq, ast.IsNot)) and not expected.value
@@ -513,7 +576,20 @@ def _state_evidence(attribute: str, operator: ast.cmpop, expected: ast.expr) ->
     return _Evidence.POSITIVE if positive else _Evidence.INSUFFICIENT
 
 
-def _proves_positive_count(operator: ast.cmpop, value: int) -> bool:
+def _literal_number(node: ast.expr) -> int | float | None:
+    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+        return node.value
+    if isinstance(node, ast.UnaryOp) and isinstance(node.operand, ast.Constant):
+        value = node.operand.value
+        if isinstance(value, (int, float)):
+            if isinstance(node.op, ast.USub):
+                return -value
+            if isinstance(node.op, ast.UAdd):
+                return +value
+    return None
+
+
+def _proves_positive_count(operator: ast.cmpop, value: float) -> bool:
     match operator:
         case ast.Eq() | ast.GtE():
             return value > 0

{sarj_python_lint-1.43.0 → sarj_python_lint-1.43.1}/src/sarj_python_lint/rules/production_derived_test_cases.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from collections import Counter
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, NamedTuple, final, override
 
@@ -21,7 +22,7 @@ from sarj_python_lint.rules._paths import is_test_path
 
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Container, Mapping
     from pathlib import Path
 
     from sarj_python_lint._file_context import PythonFileContext
@@ -60,6 +61,11 @@ class _CollectedTest(NamedTuple):
     class_bindings: set[str]
 
 
+class _ImportedCollection(NamedTuple):
+    module: str
+    symbol: str
+
+
 def _scope_binding_counts(statements: list[ast.stmt]) -> dict[str, int]:
     counts: dict[str, int] = {}
     stack: list[ast.AST] = [*reversed(statements)]
@@ -115,8 +121,8 @@ def _imported_bindings(
     binding_counts: dict[str, int],
     path: Path,
     facts: FirstPartyFacts,
-) -> dict[str, str]:
-    bindings: dict[str, str] = {}
+) -> dict[str, _ImportedCollection]:
+    bindings: dict[str, _ImportedCollection] = {}
     for node in tree.body:
         if (
             isinstance(node, ast.ImportFrom)
@@ -125,7 +131,7 @@ def _imported_bindings(
             and _is_first_party_production_module(node.module, path, facts)
         ):
             bindings.update(
-                (local, node.module)
+                (local, _ImportedCollection(node.module, alias.name))
                 for alias in node.names
                 if alias.name != "*"
                 and binding_counts.get(local := alias.asname or alias.name, 0) == 1
@@ -170,7 +176,7 @@ def _pytest_bindings(tree: ast.Module, binding_counts: dict[str, int]) -> _Pytes
 
 def _direct_imported_collection(
     node: ast.expr,
-    imported: Mapping[str, str],
+    imported: Mapping[str, _ImportedCollection],
     blocked: set[str],
     builtin_wrappers: frozenset[str],
 ) -> ast.Name | None:
@@ -199,7 +205,7 @@ def _is_registry(name: str) -> bool:
 
 def _is_imported_collection_wrapper(
     node: ast.Call,
-    imported: Mapping[str, str],
+    imported: Mapping[str, _ImportedCollection],
     builtin_wrappers: frozenset[str],
 ) -> bool:
     return (
@@ -254,30 +260,134 @@ def _collected_tests(tree: ast.Module) -> list[_CollectedTest]:
 
 def _independently_asserted_collections(
     tree: ast.Module,
-    imported: Mapping[str, str],
+    imported: Mapping[str, _ImportedCollection],
     tests: list[_CollectedTest],
 ) -> set[str]:
-    expected = _independent_expected_bindings(tree, _scope_binding_counts(tree.body))
+    expected = _independent_expected_bindings(tree.body, _scope_binding_counts(tree.body))
+    asserted = _asserted_collections(tree.body, imported, expected, blocked=set(), proven_reads={})
+    for test in tests:
+        if imported.keys() <= asserted:
+            break
+        function = test.function
+        if not any(
+            isinstance(statement, ast.Assert)
+            and isinstance(statement.test, ast.Compare)
+            and any(
+                isinstance(operand, ast.Name) and operand.id in imported
+                for operand in (statement.test.left, *statement.test.comparators)
+            )
+            for statement in function.body
+        ):
+            continue
+        bindings = _scope_binding_counts(function.body)
+        parameters = [*function.args.posonlyargs, *function.args.args, *function.args.kwonlyargs]
+        if function.args.vararg is not None:
+            parameters.append(function.args.vararg)
+        if function.args.kwarg is not None:
+            parameters.append(function.args.kwarg)
+        for parameter in parameters:
+            bindings[parameter.arg] = bindings.get(parameter.arg, 0) + 1
+        local_expected = _local_expected_bindings(function, bindings)
+        proven_reads = _captured_unchanged_defaults(test, imported, bindings)
+        proven_reads.update(_direct_production_reimports(function, imported, bindings))
+        captured_expected = _captured_unchanged_defaults(test, expected, bindings)
+        asserted.update(
+            _asserted_collections(
+                function.body,
+                imported,
+                (expected - bindings.keys()) | local_expected | captured_expected.keys(),
+                blocked=set(bindings),
+                proven_reads=proven_reads,
+            )
+        )
+    return asserted
+
+
+def _captured_unchanged_defaults(
+    test: _CollectedTest, names: Container[str], bindings: dict[str, int]
+) -> dict[str, tuple[int, int]]:
+    function = test.function
+    defaults = list(zip(function.args.kwonlyargs, function.args.kw_defaults, strict=True))
+    if function.args.defaults:
+        positional = [*function.args.posonlyargs, *function.args.args]
+        defaults.extend(zip(positional[-len(function.args.defaults) :], function.args.defaults, strict=True))
+    return {
+        argument.arg: (function.lineno, function.col_offset)
+        for argument, default in defaults
+        if isinstance(default, ast.Name)
+        and default.id == argument.arg
+        and argument.arg in names
+        and argument.arg not in test.class_bindings
+        and bindings.get(argument.arg) == 1
+    }
+
+
+def _direct_production_reimports(
+    function: ast.FunctionDef | ast.AsyncFunctionDef,
+    imported: Mapping[str, _ImportedCollection],
+    bindings: dict[str, int],
+) -> dict[str, tuple[int, int]]:
+    proven: dict[str, tuple[int, int]] = {}
+    for statement in function.body:
+        if not isinstance(statement, ast.ImportFrom) or statement.level != 0 or statement.module is None:
+            continue
+        local_counts = Counter(alias.asname or alias.name for alias in statement.names)
+        for alias in statement.names:
+            local = alias.asname or alias.name
+            if (
+                local_counts[local] == 1
+                and bindings.get(local) == 1
+                and imported.get(local) == _ImportedCollection(statement.module, alias.name)
+            ):
+                proven[local] = (statement.lineno, statement.col_offset)
+    return proven
+
+
+def _local_expected_bindings(function: ast.FunctionDef | ast.AsyncFunctionDef, bindings: dict[str, int]) -> set[str]:
+    expected = _independent_expected_bindings(function.body, bindings)
+    reads = Counter(
+        node.id for node in ast.walk(function) if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load)
+    )
+    expected.update(
+        target.id
+        for statement in function.body
+        if isinstance(statement, (ast.Assign, ast.AnnAssign)) and _is_literal_table(statement.value)
+        for target in _assignment_targets(statement)
+        if isinstance(target, ast.Name) and bindings.get(target.id) == 1 and reads[target.id] == 1
+    )
+    return expected
+
+
+def _asserted_collections(
+    statements: list[ast.stmt],
+    imported: Mapping[str, _ImportedCollection],
+    expected: set[str],
+    *,
+    blocked: set[str],
+    proven_reads: Mapping[str, tuple[int, int]],
+) -> set[str]:
     asserted: set[str] = set()
-    assertions = _direct_assertions(tree, tests)
-    for node in assertions:
-        if not isinstance(node.test, ast.Compare):
+    for node in statements:
+        if not isinstance(node, ast.Assert) or not isinstance(node.test, ast.Compare):
             continue
         compare = node.test
         if len(compare.ops) != 1 or not isinstance(compare.ops[0], ast.Eq) or len(compare.comparators) != 1:
             continue
+        visible = (imported.keys() - blocked) | {
+            name for name, position in proven_reads.items() if position < (node.lineno, node.col_offset)
+        }
         left, right = compare.left, compare.comparators[0]
-        if isinstance(left, ast.Name) and left.id in imported and _is_independent_expected(right, expected):
+        if isinstance(left, ast.Name) and left.id in visible and _is_independent_expected(right, expected):
             asserted.add(left.id)
-        if isinstance(right, ast.Name) and right.id in imported and _is_independent_expected(left, expected):
+        if isinstance(right, ast.Name) and right.id in visible and _is_independent_expected(left, expected):
             asserted.add(right.id)
     return asserted
 
 
-def _independent_expected_bindings(tree: ast.Module, binding_counts: dict[str, int]) -> set[str]:
+def _independent_expected_bindings(statements: list[ast.stmt], binding_counts: dict[str, int]) -> set[str]:
     return {
         target.id
-        for statement in tree.body
+        for statement in statements
         if isinstance(statement, (ast.Assign, ast.AnnAssign))
         for target in _assignment_targets(statement)
         if isinstance(target, ast.Name)
@@ -323,8 +433,40 @@ class ProductionDerivedTestCases(Rule):
             "Only proven first-party, non-test imports with eligible, supported, allowed, or required in their names are checked in collected pytest parametrization.",
             "Direct collections, simple unshadowed builtin wrappers, set expressions, and positional or keyword argvalues are recognized.",
             "A direct module-level or collected-test equality against a distinct literal expected table proves an independent oracle; helper-indirected relationships remain unreported.",
+            "Collected-test oracles must read the imported production binding without parameter/local shadowing. Expected tuple bindings may be module-level or local and must be assigned once; fresh local literal lists/sets are accepted only when their sole read is the assertion.",
+            "Unchanged same-name default captures of production imports or immutable expected tuples, and single direct local reimports of the exact absolute module and symbol, retain provenance. Class-scope default shadowing, later writes, and imports after the assertion do not prove a production read.",
         ),
         examples=(
+            RuleExample(
+                example_id="shadowed-membership-oracle",
+                scenario="oracle-lexical-bindings",
+                title="A fixture equality does not observe the imported production collection",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/tests/test_models.py",
+                        "import pytest\nfrom app.models import ELIGIBLE_MODELS\n\ndef test_membership(ELIGIBLE_MODELS):\n    assert ELIGIBLE_MODELS == ('a', 'b')\n\n@pytest.mark.parametrize('model', ELIGIBLE_MODELS)\ndef test_model(model):\n    assert build(model)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/tests/test_models.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="local-independent-membership-oracle",
+                scenario="oracle-lexical-bindings",
+                title="A fresh local expected table observes the actual production collection",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/tests/test_models.py",
+                        "import pytest\nfrom app.models import ELIGIBLE_MODELS\n\ndef test_membership():\n    expected = ['a', 'b']\n    assert ELIGIBLE_MODELS == expected\n\n@pytest.mark.parametrize('model', ELIGIBLE_MODELS)\ndef test_model(model):\n    assert build(model)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/tests/test_models.py"),
+                expected_count=0,
+                public=True,
+            ),
             RuleExample(
                 example_id="independent-model-cases",
                 title="Drive behavior from an independent expected table",
@@ -424,11 +566,3 @@ def _collect_pytest_modules(node: ast.Import, binding_counts: dict[str, int], mo
         for alias in node.names
         if alias.name == "pytest" and binding_counts.get(local := alias.asname or alias.name, 0) == 1
     )
-
-
-def _direct_assertions(tree: ast.Module, tests: list[_CollectedTest]) -> list[ast.Assert]:
-    assertions = [node for node in tree.body if isinstance(node, ast.Assert)]
-    assertions.extend(
-        statement for test in tests for statement in test.function.body if isinstance(statement, ast.Assert)
-    )
-    return assertions