Fix fork-safety test stdout flush, ruff formatting, and mypy typing in test suite

Author: ZelAnton

tests/test_cli_client.py

@@ -252,7 +252,9 @@ def test_cli_client_default_env_fn_rejects_a_non_callable_value() -> None:
 @pytest.mark.parametrize("verb", _SYNC_VERBS)
 def test_cli_client_default_env_fn_raise_aborts_sync_verb_before_spawn(verb: str) -> None:
     runner = RecordingRunner.replying(Reply.ok("should-not-run"))
-    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)
+    # A resolver that raises (its float-typed body never actually returns) — the
+    # deliberate wrong shape is what exercises the fail-closed abort.
+    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)  # type: ignore[dict-item, return-value]
     # The resolver's own exception reaches the caller unchanged (not swallowed,
     # not remapped) — its cause is preserved.
     with pytest.raises(ZeroDivisionError):
@@ -263,7 +265,9 @@ def test_cli_client_default_env_fn_raise_aborts_sync_verb_before_spawn(verb: str
 @pytest.mark.parametrize("verb", _ASYNC_VERBS)
 def test_cli_client_default_env_fn_raise_aborts_async_verb_before_spawn(verb: str) -> None:
     runner = RecordingRunner.replying(Reply.ok("should-not-run"))
-    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)
+    # Deliberately-raising resolver (float-typed body, never returns); see the
+    # sync twin above.
+    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)  # type: ignore[dict-item, return-value]
 
     async def scenario() -> None:
         with pytest.raises(ZeroDivisionError):
@@ -277,7 +281,8 @@ def test_cli_client_default_env_fn_raise_aborts_command_build() -> None:
     # `command()` applies the client's defaults (resolving every default_env_fn),
     # so it is on the failing path too — same fail-closed behaviour as the verbs.
     runner = RecordingRunner.replying(Reply.ok("should-not-run"))
-    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)
+    # Deliberately-raising resolver (float-typed body, never returns).
+    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)  # type: ignore[dict-item, return-value]
     with pytest.raises(ZeroDivisionError):
         client.command(["--version"])
     assert len(runner.calls()) == 0
@@ -287,7 +292,7 @@ def test_cli_client_default_env_fn_non_str_result_aborts_before_spawn() -> None:
     # A non-`str` result is just as fail-closed as a raise: the failed `str`
     # conversion surfaces as a `TypeError`, before the runner is reached.
     runner = RecordingRunner.replying(Reply.ok("should-not-run"))
-    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1}, runner=runner)  # type: ignore[dict-item]  # deliberately non-str to exercise the fail-closed conversion
+    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1}, runner=runner)  # type: ignore[dict-item, return-value]  # deliberately non-str to exercise the fail-closed conversion
     with pytest.raises(TypeError):
         client.run(["--version"])
     assert len(runner.calls()) == 0
@@ -333,7 +338,9 @@ def test_cli_client_default_env_fn_failure_is_skipped_when_key_already_set() ->
     # whose value it does not supply. The explicit value wins and the runner is
     # invoked normally.
     runner = RecordingRunner.replying(Reply.ok(""))
-    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)
+    # Deliberately-raising resolver (float-typed body, never returns); here its
+    # key is already set, so it must never even run.
+    client = CliClient(NO_SUCH_PROGRAM, default_env_fn={"PK_TOKEN": lambda: 1 / 0}, runner=runner)  # type: ignore[dict-item, return-value]
     cmd = Command(NO_SUCH_PROGRAM, ["--version"]).env("PK_TOKEN", "explicit")
     client.run(cmd)
     assert runner.only_call().env_is("PK_TOKEN", "explicit")

tests/test_command.py

@@ -1679,9 +1679,7 @@ def test_process_result_pickle_refusal_is_config_independent() -> None:
     # the contract ("ProcessResult is not picklable") is simple and total, not a
     # per-instance guess that would surprise callers.
     plain = Command(PY, ["-c", "print('plain')"]).output()
-    customized = (
-        Command(PY, ["-c", "import sys; sys.exit(3)"]).success_codes([0, 3]).output()
-    )
+    customized = Command(PY, ["-c", "import sys; sys.exit(3)"]).success_codes([0, 3]).output()
     for result in (plain, customized):
         with pytest.raises(TypeError, match="ProcessResult cannot be pickled"):
             pickle.dumps(result)

tests/test_fork_safety.py

@@ -126,7 +126,13 @@ async def _use_async():
 
 
 asyncio.run(_use_async())
-print("OK")
+
+# `os._exit()` (used throughout this driver to avoid post-fork interpreter
+# cleanup) skips the atexit stdout flush, and under `capture_output=True`
+# this stdout is a pipe — block-buffered, not line-buffered — so the success
+# marker must be flushed explicitly or it is silently dropped while the exit
+# code still reads 0. Flush before exiting so the parent test observes "OK".
+print("OK", flush=True)
 os._exit(0)
 """
 
@@ -163,4 +169,11 @@ def test_use_fork_use_refuses_without_hanging_or_orphaning(tmp_path: pathlib.Pat
         f"fork-safety driver failed (code {result.returncode}); "
         f"stdout={result.stdout!r} stderr={result.stderr!r}"
     )
-    assert result.stdout.strip().splitlines()[-1] == "OK"
+    # Use a slice (`[-1:]`) rather than an index (`[-1]`) so an unexpectedly
+    # empty stdout fails as a clear, informative assertion — not a bare
+    # IndexError that hides what the driver actually did.
+    tail = result.stdout.strip().splitlines()[-1:]
+    assert tail == ["OK"], (
+        f"fork-safety driver did not confirm success with a trailing 'OK'; "
+        f"stdout={result.stdout!r} stderr={result.stderr!r}"
+    )