Teknium
6d1284a073
test_progress_advances_while_the_orchestrator_blocks raced its subject on both edges within one hour of PR CI (#90358): - Run 1: sampled right after the shim URL printed, before the orchestrator published its stage — caught the page boot default ('Hermes will open once done.' != 'Testing quiet update'). - Run 2 (rerun): with HOLD=4s on a slow runner, the second sample slid past the hold and caught the cleared terminal state ('' != 'Testing quiet update'). Fix: wait (<=10s) for the published stage to actually land before starting the 1.5s stability window, and raise the hold to 10s so both samples land inside it. Same assertions, same contract — just anchored to the event the test is about instead of wall-clock luck.
111 lines
4.0 KiB
Python
111 lines
4.0 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)
|
|
# Generous hold: the assertions below must both land INSIDE it. 4s was
|
|
# too tight for a slow runner — the second sample slid past the hold,
|
|
# caught the cleared terminal state, and failed '' == 'Testing quiet
|
|
# update' (PR #90358 rerun, Aug 2026).
|
|
env["HERMES_SELFTEST_HOLD_SECONDS"] = "10"
|
|
|
|
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")
|
|
|
|
# The URL prints BEFORE the orchestrator publishes its held stage —
|
|
# sampling immediately races the publish and can catch the page's
|
|
# boot default instead ('Hermes will open once done.' ==
|
|
# 'Testing quiet update', PR #90358 first run). Wait for the held
|
|
# stage to actually land, THEN start the stability window.
|
|
held_stage = "Testing quiet update"
|
|
publish_deadline = time.monotonic() + 10
|
|
first = _read_progress(shim_url)
|
|
while first.get("message") != held_stage and time.monotonic() < publish_deadline:
|
|
time.sleep(0.1)
|
|
first = _read_progress(shim_url)
|
|
assert first["message"] == held_stage, first
|
|
|
|
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)
|