Brooklyn Nicholson
e602225d86
The self-test grew a branch that spawns a Python child so pytest could prove progress advances during one. It doesn't need to: /progress is answered from its own runspace, so the existing hold already blocks the main thread, and the spawn only exercised Invoke-HermesStep, which nothing here changes. The Windows test now asserts the invariant instead of the self-test's stage string, and the posix half -- previously untested, and the half that broke -- gets real coverage: serve-ui.py's wire shape, and posix.sh driven end to end with a stub `hermes` that reports which stage was on screen while it ran.
94 lines
3.1 KiB
Python
94 lines
3.1 KiB
Python
"""The Windows hand-off keeps serving progress while its main thread blocks.
|
|
|
|
windows.ps1 answers /progress from a dedicated runspace precisely so the
|
|
window keeps moving through the long silent stretches (`hermes update`, pip,
|
|
the desktop rebuild) that made an 18-minute update look hung. This drives the
|
|
real script and polls the real listener; the posix half of the same contract
|
|
is covered in test_desktop_update_shim_progress.py.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import time
|
|
from pathlib import Path
|
|
from urllib.request import urlopen
|
|
|
|
import pytest
|
|
|
|
pytestmark = pytest.mark.windows_only
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parent.parent
|
|
WINDOWS_UPDATE_PS1 = REPO_ROOT / "scripts" / "desktop-update" / "windows.ps1"
|
|
|
|
|
|
def _read_progress(url: str) -> dict[str, object]:
|
|
with urlopen(f"{url}progress", timeout=5) as response:
|
|
return json.loads(response.read().decode("utf-8"))
|
|
|
|
|
|
def test_progress_advances_while_the_orchestrator_blocks(tmp_path: Path) -> None:
|
|
powershell = shutil.which("powershell.exe")
|
|
assert powershell, "Windows updater tests require Windows PowerShell."
|
|
|
|
output_path = tmp_path / "self-test-output.log"
|
|
env = os.environ.copy()
|
|
env["TEMP"] = str(tmp_path)
|
|
env["TMP"] = str(tmp_path)
|
|
env["HERMES_SELFTEST_HOLD_SECONDS"] = "4"
|
|
|
|
with output_path.open("wb") as output:
|
|
process = subprocess.Popen(
|
|
[
|
|
powershell,
|
|
"-NoProfile",
|
|
"-ExecutionPolicy",
|
|
"Bypass",
|
|
"-File",
|
|
str(WINDOWS_UPDATE_PS1),
|
|
"-SelfTestUi",
|
|
"-NoUi",
|
|
],
|
|
stdout=output,
|
|
stderr=subprocess.STDOUT,
|
|
env=env,
|
|
)
|
|
|
|
try:
|
|
deadline = time.monotonic() + 20
|
|
shim_url = None
|
|
while time.monotonic() < deadline:
|
|
text = output_path.read_text(encoding="utf-8", errors="replace")
|
|
match = re.search(r"SELF-TEST: shim at (http://127\.0\.0\.1:\d+/)", text)
|
|
if match:
|
|
shim_url = match.group(1)
|
|
break
|
|
if process.poll() is not None:
|
|
break
|
|
time.sleep(0.1)
|
|
|
|
assert shim_url, output_path.read_text(encoding="utf-8", errors="replace")
|
|
first = _read_progress(shim_url)
|
|
time.sleep(1.5)
|
|
second = _read_progress(shim_url)
|
|
|
|
# The stage is whatever the orchestrator last published -- it must
|
|
# reach the page verbatim and must not churn on its own.
|
|
assert first["status"] == "running"
|
|
assert first["message"]
|
|
assert second["message"] == first["message"]
|
|
# The main thread is asleep for the whole window above. If elapsed
|
|
# only moved when the orchestrator published, it would be frozen here
|
|
# -- which is what a stalled update looks like to the user.
|
|
assert int(second["elapsed_seconds"]) > int(first["elapsed_seconds"])
|
|
|
|
assert process.wait(timeout=20) == 0
|
|
finally:
|
|
if process.poll() is None:
|
|
process.kill()
|
|
process.wait(timeout=5)
|