test(rewrite): collapse the harness onto one exec helper

The five helpers each repeated dedent -> rewrite -> compile -> build
namespace -> exec -> fetch check().  Extract _exec_check() and build all
of them on it, including _run_both, which assert_semantically_equivalent
now shares with assert_evaluation_order instead of open-coding a second
double-execution.

Drop the extra_ns parameter.  It was threaded through six functions and
no test ever passed it: assert_single_evaluation seeds its own counter
and every other source defines what it needs inline.  With each run
getting a fresh namespace, the deepcopy that kept plain and rewritten
runs from leaking into each other is no longer needed either.

Add smoke tests for must_not_contain, whose only callers sit behind
strict xfails that fail before reaching it.

The harness is now fully exercised by its own tests, which is what the
PRs stacked on it need in order to be independently reviewable.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: RonnyPfannschmidt

testing/test_assertrewrite_coverage.py

@@ -37,8 +37,6 @@
 
 import ast
 from collections.abc import Callable
-from collections.abc import Mapping
-import copy
 import sys
 import textwrap
 from typing import cast
@@ -52,32 +50,42 @@
 # ---------------------------------------------------------------------------
 
 
-def _rewrite_source(src: str) -> ast.Module:
-    """Parse and rewrite assertions in source code."""
+def _exec_check(
+    src: str,
+    *,
+    rewrite: bool = True,
+    ns: dict[str, object] | None = None,
+) -> Callable[[], object]:
+    """Compile and execute ``src``, returning the ``check`` function it defines.
+
+    ``src`` is dedented first.  When ``rewrite`` is true the assertions are
+    rewritten before compiling, which is the usual case; the axes that compare
+    against unrewritten behaviour ask for both.
+
+    ``ns`` is the namespace the source executes in.  Pass one in to seed it
+    (``assert_single_evaluation`` needs a ``counter``) or to read side effects
+    back out afterwards; each call otherwise gets a fresh namespace, which is
+    what keeps a plain and a rewritten run from leaking state into each other.
+    """
+    src = textwrap.dedent(src)
     tree = ast.parse(src)
-    rewrite_asserts(tree, src.encode())
-    return tree
+    if rewrite:
+        rewrite_asserts(tree, src.encode())
+    if ns is None:
+        ns = {}
+    exec(compile(tree, "<test-rewritten>" if rewrite else "<test-plain>", "exec"), ns)
+    return cast(Callable[[], object], ns["check"])
 
 
-def get_failure_message(
-    src: str,
-    extra_ns: Mapping[str, object] | None = None,
-) -> str:
+def get_failure_message(src: str) -> str:
     """Compile rewritten source, execute it, and return the failure message.
 
     The source should contain a function named ``check`` with a failing assert.
     Returns the AssertionError message string.
 
     Raises AssertionError via pytest.fail if the code does not raise.
     """
-    src = textwrap.dedent(src)
-    mod = _rewrite_source(src)
-    code = compile(mod, "<test>", "exec")
-    ns: dict[str, object] = {}
-    if extra_ns is not None:
-        ns.update(extra_ns)
-    exec(code, ns)
-    func = cast(Callable[[], None], ns["check"])
+    func = _exec_check(src)
     try:
         func()
     except AssertionError:
@@ -94,7 +102,6 @@ def assert_introspects(
     *,
     must_contain: list[str],
     must_not_contain: list[str] | None = None,
-    extra_ns: Mapping[str, object] | None = None,
 ) -> str:
     """Verify a failing assert produces a message with expected intermediate values.
 
@@ -106,15 +113,13 @@ def assert_introspects(
         Substrings that MUST appear in the failure message.
     must_not_contain : list[str] | None
         Substrings that must NOT appear in the failure message.
-    extra_ns : Mapping[str, object] | None
-        Additional namespace entries available during execution.
 
     Returns
     -------
     str
         The full failure message (for further inspection if needed).
     """
-    msg = get_failure_message(src, extra_ns=extra_ns)
+    msg = get_failure_message(src)
     for expected in must_contain:
         assert expected in msg, (
             f"Expected {expected!r} in failure message.\nGot:\n{msg}"
@@ -130,31 +135,22 @@ def assert_single_evaluation(
     src: str,
     *,
     expected_call_count: int = 1,
-    extra_ns: Mapping[str, object] | None = None,
 ) -> None:
     """Verify side-effecting expressions in assert are evaluated exactly once.
 
-    The source should define a ``check()`` function and use a ``counter`` list
-    (provided via extra_ns or defined in the source) that tracks how many times
-    a side-effecting expression is evaluated.
+    The source should define a ``check()`` function and use the ``counter``
+    list seeded here, which tracks how many times a side-effecting expression
+    is evaluated.
 
     Parameters
     ----------
     src : str
         Source containing a ``check()`` function whose assert has side effects.
     expected_call_count : int
         How many times the side-effecting expression should be evaluated.
-    extra_ns : Mapping[str, object] | None
-        Additional namespace. Should include ``counter`` if not defined in src.
     """
-    src = textwrap.dedent(src)
-    mod = _rewrite_source(src)
-    code = compile(mod, "<test>", "exec")
     ns: dict[str, object] = {"counter": [0]}
-    if extra_ns is not None:
-        ns.update(extra_ns)
-    exec(code, ns)
-    func = cast(Callable[[], None], ns["check"])
+    func = _exec_check(src, ns=ns)
     counter = cast(list[int], ns["counter"])
     counter[0] = 0
     try:
@@ -167,108 +163,53 @@ def assert_single_evaluation(
     )
 
 
-def assert_passes_when_true(
-    src: str,
-    *,
-    extra_ns: Mapping[str, object] | None = None,
-) -> None:
+def assert_passes_when_true(src: str) -> None:
     """Verify rewritten assertion does not raise when the condition is true.
 
     Parameters
     ----------
     src : str
         Source containing a ``check()`` function with a passing assertion.
-    extra_ns : Mapping[str, object] | None
-        Additional namespace entries available during execution.
     """
-    src = textwrap.dedent(src)
-    mod = _rewrite_source(src)
-    code = compile(mod, "<test>", "exec")
-    ns: dict[str, object] = {}
-    if extra_ns is not None:
-        ns.update(extra_ns)
-    exec(code, ns)
-    func = cast(Callable[[], None], ns["check"])
-    func()
+    _exec_check(src)()
 
 
-def assert_semantically_equivalent(
-    src: str,
-    *,
-    extra_ns: Mapping[str, object] | None = None,
-) -> None:
+_Outcome = tuple[bool, object]
+
+
+def _run_both(src: str) -> tuple[_Outcome, _Outcome]:
+    """Execute ``check()`` plain and rewritten, returning (raised, result) pairs."""
+    outcomes: list[_Outcome] = []
+    for rewrite in (False, True):
+        func = _exec_check(src, rewrite=rewrite)
+        try:
+            outcomes.append((False, func()))
+        except AssertionError:
+            outcomes.append((True, None))
+    plain, rewritten = outcomes
+    return plain, rewritten
+
+
+def assert_semantically_equivalent(src: str) -> None:
     """Verify rewritten code has same pass/fail semantics as unrewritten code.
 
     Runs the source both with and without rewriting, and asserts they agree
-    on whether an AssertionError is raised.
+    on whether an AssertionError is raised.  Only the raise is compared --
+    :func:`assert_evaluation_order` compares the returned observations too.
 
     Parameters
     ----------
     src : str
         Source containing a ``check()`` function with an assertion.
-    extra_ns : Mapping[str, object] | None
-        Additional namespace entries available during execution.
     """
-    src = textwrap.dedent(src)
-
-    # Run without rewriting — use deepcopy of extra_ns to isolate mutable state
-    plain_code = compile(src, "<test-plain>", "exec")
-    plain_ns: dict[str, object] = {}
-    if extra_ns is not None:
-        plain_ns.update(copy.deepcopy(dict(extra_ns)))
-    exec(plain_code, plain_ns)
-    plain_func = cast(Callable[[], None], plain_ns["check"])
-    plain_raised = False
-    try:
-        plain_func()
-    except AssertionError:
-        plain_raised = True
-
-    # Run with rewriting — fresh deepcopy so mutations from first run don't leak
-    mod = _rewrite_source(src)
-    rewritten_code = compile(mod, "<test-rewritten>", "exec")
-    rewritten_ns: dict[str, object] = {}
-    if extra_ns is not None:
-        rewritten_ns.update(copy.deepcopy(dict(extra_ns)))
-    exec(rewritten_code, rewritten_ns)
-    rewritten_func = cast(Callable[[], None], rewritten_ns["check"])
-    rewritten_raised = False
-    try:
-        rewritten_func()
-    except AssertionError:
-        rewritten_raised = True
-
+    (plain_raised, _), (rewritten_raised, _) = _run_both(src)
     assert plain_raised == rewritten_raised, (
         f"Semantic mismatch: plain {'raised' if plain_raised else 'passed'}, "
         f"rewritten {'raised' if rewritten_raised else 'passed'}"
     )
 
 
-def _run_both(src: str, extra_ns: Mapping[str, object] | None) -> list[object]:
-    """Execute ``check()`` plain and rewritten, returning (raised, result) pairs."""
-    src = textwrap.dedent(src)
-    outcomes: list[object] = []
-    for code in (
-        compile(src, "<test-plain>", "exec"),
-        compile(_rewrite_source(src), "<test-rewritten>", "exec"),
-    ):
-        ns: dict[str, object] = {}
-        if extra_ns is not None:
-            ns.update(copy.deepcopy(dict(extra_ns)))
-        exec(code, ns)
-        func = cast(Callable[[], object], ns["check"])
-        try:
-            outcomes.append((False, func()))
-        except AssertionError:
-            outcomes.append((True, None))
-    return outcomes
-
-
-def assert_evaluation_order(
-    src: str,
-    *,
-    extra_ns: Mapping[str, object] | None = None,
-) -> None:
+def assert_evaluation_order(src: str) -> None:
     """Verify rewriting preserves the values Python's evaluation order produces.
 
     ``check()`` should return whatever the order is observable through -- the
@@ -291,10 +232,8 @@ def assert_evaluation_order(
     ----------
     src : str
         Source containing a ``check()`` function that returns its observations.
-    extra_ns : Mapping[str, object] | None
-        Additional namespace entries available during execution.
     """
-    plain, rewritten = _run_both(src, extra_ns)
+    plain, rewritten = _run_both(src)
     assert plain == rewritten, (
         f"Evaluation order mismatch:\n  plain     (raised, result) = {plain}\n"
         f"  rewritten (raised, result) = {rewritten}"
@@ -343,6 +282,29 @@ def check():
                 must_contain=["this is not in the message"],
             )
 
+    def test_assert_introspects_must_not_contain(self) -> None:
+        assert_introspects(
+            """
+def check():
+    x = 3
+    assert x == 5
+""",
+            must_contain=["assert 3 == 5"],
+            must_not_contain=["this is not in the message"],
+        )
+
+    def test_assert_introspects_fails_on_unexpected(self) -> None:
+        with pytest.raises(AssertionError, match=r"Did NOT expect.*in failure"):
+            assert_introspects(
+                """
+def check():
+    x = 3
+    assert x == 5
+""",
+                must_contain=["assert 3 == 5"],
+                must_not_contain=["assert 3"],
+            )
+
     def test_assert_single_evaluation(self) -> None:
         assert_single_evaluation("""
 def check():