test(run,sync/git[timeout]) Reduce flake risk in deadline tests

why: Several tests had wall-clock budgets sized for the 0.5 s SIGTERM
grace and 0.1 s selector poll defaults, leaving ~2.2 s of headroom
above the nominal timeout. On loaded CI runners (cold Python startup
of 0.5-0.7 s on ARM Actions, slow filesystems), that headroom narrows
to single digits. Separately, the early-stderr-close test relies on
``os.close(sys.stderr.fileno())`` which has POSIX-specific semantics
not portable to Windows, and the 500-ref regression test invoked
``git update-ref`` 500 times -- inflating suite duration without
sharpening the assertion.
what:
- Add a ``fast_timeout_constants`` fixture that monkeypatches
  ``_TIMEOUT_KILL_GRACE_SECONDS`` and ``_TIMEOUT_POLL_INTERVAL_SECONDS``
  to 0.05 s so the wall-clock spread above the nominal deadline stays
  predictable across runners.
- Apply the fixture to every deadline-firing test; tighten the
  upper-bound assertion in
  ``test_run_raises_command_timeout_when_deadline_exceeded`` from 2.5
  to 2.0 with a comment showing the spread arithmetic.
- Skip ``test_run_timeout_handles_early_stderr_close_without_hanging``
  on Windows; document the POSIX dependency in the skip reason.
- Replace the 500-iteration ``run(['git', 'update-ref', ...])`` loop
  with a single ``git update-ref --stdin`` call so the test setup
  costs one fork+exec instead of 500. The behavioural assertion
  (remote() returns under 5 s with 500 refs) is unchanged.

Author: tony

tests/_internal/test_run.py

@@ -12,9 +12,26 @@
 import pytest
 
 from libvcs import exc
+from libvcs._internal import run as run_module
 from libvcs._internal.run import _normalize_command_args, run
 
 
+@pytest.fixture
+def fast_timeout_constants(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Tighten the deadline-loop spread so test wall-clock budgets stay reliable.
+
+    The two ``_TIMEOUT_*`` constants in :mod:`libvcs._internal.run` are tuned
+    for production use (0.5 s SIGTERM grace, 0.1 s selector poll). For tests
+    that intentionally fire the deadline, those defaults add up to ~0.7 s of
+    unavoidable wall-clock spread on top of the test's nominal timeout, which
+    makes upper-bound assertions fragile on loaded CI runners. This fixture
+    monkeypatches both to 0.05 s so the spread stays predictable; production
+    behaviour is unchanged.
+    """
+    monkeypatch.setattr(run_module, "_TIMEOUT_KILL_GRACE_SECONDS", 0.05)
+    monkeypatch.setattr(run_module, "_TIMEOUT_POLL_INTERVAL_SECONDS", 0.05)
+
+
 def test_normalize_command_args_keeps_scalar_string() -> None:
     """Scalar strings should remain a single subprocess argument."""
     assert _normalize_command_args("status") == ["status"]
@@ -46,7 +63,9 @@ def test_run_without_timeout_matches_legacy_behavior() -> None:
     assert "world" in output
 
 
-def test_run_raises_command_timeout_when_deadline_exceeded() -> None:
+def test_run_raises_command_timeout_when_deadline_exceeded(
+    fast_timeout_constants: None,
+) -> None:
     """A command sleeping past ``timeout`` raises ``CommandTimeoutError`` fast."""
     started = time.monotonic()
 
@@ -59,12 +78,17 @@ def test_run_raises_command_timeout_when_deadline_exceeded() -> None:
     elapsed = time.monotonic() - started
 
     # Upper bound keeps the test honest: the deadline must actually fire, not
-    # fall through to the legacy unbounded wait.
-    assert elapsed < 2.5, f"timeout took too long: {elapsed:.2f}s"
+    # fall through to the legacy unbounded wait. With the fast-constants
+    # fixture, the worst-case spread is 0.3 (deadline) + 0.05 (SIGTERM grace)
+    # + 0.05 (poll) + Python startup (~0.5 s on cold CI) -> ~1 s; the budget
+    # below leaves comfortable headroom for slow runners.
+    assert elapsed < 2.0, f"timeout took too long: {elapsed:.2f}s"
     assert isinstance(excinfo.value, exc.CommandError)
 
 
-def test_run_timeout_captures_partial_stderr_output() -> None:
+def test_run_timeout_captures_partial_stderr_output(
+    fast_timeout_constants: None,
+) -> None:
     """Output produced before the timeout is preserved on ``CommandTimeoutError``."""
     script = (
         "import sys, time;"
@@ -86,7 +110,10 @@ def test_run_timeout_captures_partial_stderr_output() -> None:
     assert "first" in excinfo.value.output
 
 
-def test_run_timeout_reaps_child_process(monkeypatch: pytest.MonkeyPatch) -> None:
+def test_run_timeout_reaps_child_process(
+    monkeypatch: pytest.MonkeyPatch,
+    fast_timeout_constants: None,
+) -> None:
     """Timed-out processes are terminated; no zombies remain in the group."""
     script = "import time; time.sleep(10)"
 
@@ -151,7 +178,9 @@ def test_command_timeout_error_without_timeout_falls_back() -> None:
     assert "partial" in rendered
 
 
-def test_run_timeout_message_includes_duration() -> None:
+def test_run_timeout_message_includes_duration(
+    fast_timeout_constants: None,
+) -> None:
     """``run(..., timeout=X)`` raises an exception whose ``str()`` shows X."""
     with pytest.raises(exc.CommandTimeoutError) as excinfo:
         run([sys.executable, "-c", "import time; time.sleep(10)"], timeout=0.3)
@@ -186,7 +215,9 @@ def test_run_timeout_preserves_stdout_after_exit() -> None:
     assert "lines" in output
 
 
-def test_run_timeout_captures_partial_stdout_on_timeout() -> None:
+def test_run_timeout_captures_partial_stdout_on_timeout(
+    fast_timeout_constants: None,
+) -> None:
     """Stdout flushed before the deadline appears in ``CommandTimeoutError.output``."""
     script = (
         "import sys, time; "
@@ -203,6 +234,7 @@ def test_run_timeout_captures_partial_stdout_on_timeout() -> None:
 
 def test_run_timeout_logs_deadline_exceeded(
     caplog: pytest.LogCaptureFixture,
+    fast_timeout_constants: None,
 ) -> None:
     """Deadline-fired path emits a WARNING with the canonical ``vcs_cmd`` extra."""
     with (
@@ -224,6 +256,10 @@ def test_run_timeout_logs_deadline_exceeded(
     assert "time.sleep" in cmd_extra
 
 
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="os.close(sys.stderr.fileno()) has POSIX-specific semantics",
+)
 def test_run_timeout_handles_early_stderr_close_without_hanging() -> None:
     """A child that closes stderr long before exiting must not stall the loop.
 

tests/sync/test_git.py

@@ -6,6 +6,7 @@
 import pathlib
 import random
 import shutil
+import subprocess
 import textwrap
 import time
 import typing as t
@@ -1683,23 +1684,25 @@ def test_remote_is_fast_for_repos_with_many_refs(
     This test seeds synthetic refs/remotes/origin/branch-N entries and asserts
     that ``remote('origin')`` returns promptly. A generous 5-second budget is
     enough to catch the pathological old path (many seconds on WSL2) without
-    flaking on slow CI.
+    flaking on slow CI. Refs are batched through ``git update-ref --stdin``
+    (one subprocess) instead of one invocation per ref so the test setup
+    doesn't dominate suite duration.
     """
     # Point origin at a commit we already have so fake refs don't dangle.
     head_sha = run(["git", "rev-parse", "HEAD"], cwd=git_repo.path).strip()
 
-    # Seed 500 fake remote-tracking refs. ``git update-ref`` is quick but the
-    # cumulative count is what would blow up ``git remote show -n``.
-    for i in range(500):
-        run(
-            [
-                "git",
-                "update-ref",
-                f"refs/remotes/origin/fake-branch-{i:04d}",
-                head_sha,
-            ],
-            cwd=git_repo.path,
-        )
+    # Seed 500 fake remote-tracking refs in a single ``git update-ref`` call;
+    # the cumulative count is what would blow up ``git remote show -n``.
+    stdin_input = "".join(
+        f"update refs/remotes/origin/fake-branch-{i:04d} {head_sha}\n"
+        for i in range(500)
+    )
+    subprocess.run(
+        ["git", "-C", str(git_repo.path), "update-ref", "--stdin"],
+        input=stdin_input,
+        text=True,
+        check=True,
+    )
 
     started = time.monotonic()
     remote = git_repo.remote("origin")