134 lines
4.9 KiB
Python
134 lines
4.9 KiB
Python
"""Windows hand-off child must hard-exit once the update is durably done (#93581).
|
|
|
|
The re-exec'd venv child (spawned by
|
|
``_reexec_dependency_sync_off_windows_shim`` with ``HERMES_UPDATE_REEXEC=1``)
|
|
completes all update work — the receipt records ``success`` / ``completed at
|
|
command boundary`` — but then hangs in interpreter shutdown on a leftover
|
|
non-daemon thread, freezing the PowerShell window for minutes. The fix: on
|
|
the hand-off path only, after the receipt is finalized, the lock released,
|
|
and stdio restored, flush and ``os._exit(code)`` instead of unwinding.
|
|
|
|
These tests pin: the hard exit fires (with the right code) only when the
|
|
re-exec marker env is set, it happens after lock release + stdio restore,
|
|
early ``SystemExit`` codes propagate to it, and real exceptions keep the
|
|
normal raise path (traceback intact, no hard exit).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
import hermes_cli.main as main_mod
|
|
from hermes_cli.main import cmd_update
|
|
|
|
|
|
class _FakeLock:
|
|
def __init__(self, events):
|
|
self._events = events
|
|
|
|
def acquire(self):
|
|
self._events.append("acquire")
|
|
return True
|
|
|
|
def release(self):
|
|
self._events.append("release")
|
|
|
|
|
|
# Events from the most recent _run_cmd_update call, also filled in when
|
|
# cmd_update propagates an exception (the return value is unreachable then).
|
|
_LAST = {}
|
|
|
|
|
|
def _run_cmd_update(monkeypatch, impl, *, reexec: bool):
|
|
"""Run cmd_update with everything external mocked; return the events."""
|
|
events = {"order": [], "exit_codes": [], "receipts": []}
|
|
|
|
def fake_impl(args, gateway_mode=False):
|
|
events["order"].append("impl")
|
|
impl(args, gateway_mode=gateway_mode)
|
|
|
|
def fake_finalize_io(state):
|
|
events["order"].append("restore-stdio")
|
|
|
|
def fake_receipt(code, reason):
|
|
events["receipts"].append((code, reason))
|
|
|
|
def fake_exit(code):
|
|
events["order"].append("hard-exit")
|
|
events["exit_codes"].append(code)
|
|
|
|
monkeypatch.setattr("hermes_cli.config.is_managed", lambda: False)
|
|
monkeypatch.setattr("hermes_cli.config.detect_install_method", lambda root: "git")
|
|
monkeypatch.setattr("hermes_cli.update_lock.UpdateLock", lambda: _FakeLock(events["order"]))
|
|
monkeypatch.setattr(main_mod, "_cmd_update_impl", fake_impl)
|
|
monkeypatch.setattr(main_mod, "_install_hangup_protection", lambda gateway_mode=False: None)
|
|
monkeypatch.setattr(main_mod, "_finalize_update_output", fake_finalize_io)
|
|
monkeypatch.setattr("hermes_cli.update_receipt.finalize_pending_update_receipt", fake_receipt)
|
|
monkeypatch.setattr("os._exit", fake_exit)
|
|
if reexec:
|
|
monkeypatch.setenv("HERMES_UPDATE_REEXEC", "1")
|
|
else:
|
|
monkeypatch.delenv("HERMES_UPDATE_REEXEC", raising=False)
|
|
|
|
args = SimpleNamespace(plan=False, check=False, gateway=False, branch=None)
|
|
try:
|
|
cmd_update(args)
|
|
finally:
|
|
_LAST.clear()
|
|
_LAST.update(events)
|
|
return events
|
|
|
|
|
|
def _noop_impl(args, gateway_mode=False):
|
|
return None
|
|
|
|
|
|
def test_handoff_child_hard_exits_zero_after_success(monkeypatch):
|
|
events = _run_cmd_update(monkeypatch, _noop_impl, reexec=True)
|
|
assert events["exit_codes"] == [0]
|
|
assert events["receipts"] == [(0, "completed at command boundary")]
|
|
# The hard exit is the last thing, after lock release and stdio restore.
|
|
assert events["order"] == ["acquire", "impl", "release", "restore-stdio", "hard-exit"]
|
|
|
|
|
|
def test_non_handoff_run_never_hard_exits(monkeypatch):
|
|
events = _run_cmd_update(monkeypatch, _noop_impl, reexec=False)
|
|
assert events["exit_codes"] == []
|
|
assert "hard-exit" not in events["order"]
|
|
assert events["receipts"] == [(0, "completed at command boundary")]
|
|
|
|
|
|
def test_handoff_child_propagates_early_systemexit_code(monkeypatch):
|
|
def early_refusal(args, gateway_mode=False):
|
|
raise SystemExit(3)
|
|
|
|
with pytest.raises(SystemExit) as excinfo:
|
|
_run_cmd_update(monkeypatch, early_refusal, reexec=True)
|
|
assert excinfo.value.code == 3
|
|
# The finally-block hard exit ran (before the re-raise propagated)
|
|
# and carried the early exit's code, not a blanket 0.
|
|
assert _LAST["exit_codes"] == [3]
|
|
|
|
|
|
def test_handoff_child_systemexit_none_means_zero(monkeypatch):
|
|
def bare_exit(args, gateway_mode=False):
|
|
raise SystemExit(None)
|
|
|
|
with pytest.raises(SystemExit):
|
|
_run_cmd_update(monkeypatch, bare_exit, reexec=True)
|
|
assert _LAST["exit_codes"] == [0]
|
|
|
|
|
|
def test_unhandled_exception_keeps_raise_path_no_hard_exit(monkeypatch):
|
|
def boom(args, gateway_mode=False):
|
|
raise RuntimeError("update tail exploded")
|
|
|
|
# With os._exit patched to record, the re-raised RuntimeError reaches
|
|
# pytest with the finally block already run — and no hard exit fires.
|
|
with pytest.raises(RuntimeError, match="update tail exploded"):
|
|
_run_cmd_update(monkeypatch, boom, reexec=True)
|
|
assert "hard-exit" not in _LAST["order"]
|
|
assert _LAST["receipts"] == [(1, "RuntimeError: update tail exploded")]
|