mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
RecordedChecks (the checks a runner keeps for its result file), the step loop with its timings and known failures, the commit under test and the step keyword helper have nothing to do with Windows. Move them to komorebi_vm/runner.py, with the known-failure tables passed in, so that a runner of another port uses them instead of importing a sibling port or copying them. The Windows runner keeps its tables and the names it and its tests use. The unit tests of the core and of the Windows runner pass unchanged (163), and ruff reports what it did before.
451 lines
17 KiB
Python
451 lines
17 KiB
Python
"""Runs neutral scenarios against a fresh Windows guest.
|
|
|
|
usage: python -m platforms.qemu_windows.run GOLDEN BIN_DIR OUT SCENARIO...
|
|
|
|
GOLDEN is the golden image directory, BIN_DIR holds komorebi.exe,
|
|
komorebic.exe and komorebi-testwin.exe, OUT gets the run's artifacts.
|
|
Every scenario gets its own guest. Those that take clients start from the
|
|
windows that `tiling` opens.
|
|
|
|
With `KOMOREBI_E2E_RECORDER=DIR` (the folder of komorebi-recorder.exe) the
|
|
daemon runs at trace level and komorebi-recorder records the scenario in the
|
|
guest, with window tracking; the session comes back as OUT/recording.zip. Every
|
|
run also writes OUT/result.json, naming the scenario, the port, the kfw commit
|
|
and each check, so that a session can be matched with its run.
|
|
|
|
With `KOMOREBI_E2E_SCALE=1.5` every wait of a scenario is 1.5 times as long, for a
|
|
busy host (the daemon is slow to answer, and kfw is slow to drop a monitor).
|
|
|
|
With `KOMOREBI_E2E_STATE=DIR` every guest is restored from a state saved there
|
|
(made on the first run, and again when the golden image, QEMU or guest.py
|
|
changed) instead of booting: about 3 s instead of 50 to 90.
|
|
|
|
With `KOMOREBI_E2E_CAPTURE=DIR` the raw `komorebic state` is saved to DIR
|
|
after `tiling` (state-kfw-tiled.json) and after one window is stacked onto
|
|
another (state-kfw-stack.json) and after the focused one is floated
|
|
(state-kfw-float.json), to be used as fixtures.
|
|
"""
|
|
|
|
import importlib
|
|
import json
|
|
import os
|
|
import sys
|
|
import time
|
|
import traceback
|
|
import zipfile
|
|
from pathlib import Path
|
|
|
|
from komorebi_vm.core.suite import platform_only, shared
|
|
from komorebi_vm.runner import RecordedChecks, run_steps
|
|
from komorebi_vm.runner import commit as _commit
|
|
from komorebi_vm.runner import contains as _contains
|
|
from komorebi_vm.runner import with_kwargs as _with
|
|
|
|
from .agent import AgentError, AgentLost
|
|
from .guest import Guest
|
|
from .state import ensure
|
|
from .windows_platform import WindowsPlatform
|
|
|
|
# `move_container_to_monitor` takes the focused container off its monitor
|
|
# before it looks the target monitor up, so a monitor that is not there loses
|
|
# the window; the window stays on screen, unmanaged
|
|
UNKNOWN_MONITOR_BUG = (
|
|
"kfw drops the focused window from management when the target monitor "
|
|
"does not exist"
|
|
)
|
|
|
|
|
|
# `PlacementTarget` deserializes with `String::deserialize`, so the number 2
|
|
# is rejected ("data did not match any variant of untagged enum
|
|
# InitialWindowPlacementRules") although the type's docs allow an integer;
|
|
# the string "2" works
|
|
PLACEMENT_INTEGER_CASE = "by the number of the place, counted from 1"
|
|
PLACEMENT_INTEGER_BUG = (
|
|
"kfw rejects a number as initial_window_placement_rules and exits at "
|
|
"start, a string is accepted"
|
|
)
|
|
|
|
|
|
# steps whose failing checks are known differences of kfw, and why: a failing
|
|
# check of such a step is recorded as a known failure, and a step that has no
|
|
# failing check says the marker can go
|
|
KNOWN_STEPS = {
|
|
"maximizing.user": (
|
|
"kfw sets maximized_window only from toggle-maximize; a user's "
|
|
"maximize (SC_MAXIMIZE) is not taken as the maximized window"
|
|
),
|
|
"hotplug.user_move": (
|
|
"kfw relocates a window to another monitor only when a drag ends "
|
|
"(MoveResizeEnd); a move by any other means is ignored"
|
|
),
|
|
}
|
|
|
|
|
|
# the commit of komorebi's `next` that fixed what a step is known to fail, and
|
|
# what it still fails on a build that has it (None: nothing): the marker is the
|
|
# first reason before it and the second after it
|
|
KNOWN_STEPS_FIXED_BY = {
|
|
"maximizing.user": ("3fa3d429", None),
|
|
}
|
|
|
|
|
|
class GuestDied(RuntimeError):
|
|
"""QEMU exited while a scenario was running: not what kfw did."""
|
|
|
|
|
|
def _suite(checks: RecordedChecks, *steps):
|
|
"""`run_steps` with the known failures of this port."""
|
|
return run_steps(
|
|
checks, *steps, known=KNOWN_STEPS, fixed_by=KNOWN_STEPS_FIXED_BY,
|
|
contains=_contains,
|
|
)
|
|
|
|
|
|
# the commit that fixed each bug a marker is for (komorebi's `next`)
|
|
UNKNOWN_MONITOR_FIX = "837ca257"
|
|
PLACEMENT_INTEGER_FIX = "3b424dd7"
|
|
|
|
|
|
BINARIES = ["komorebi.exe", "komorebic.exe", "komorebi-testwin.exe"]
|
|
# uploaded when the binaries have them: only the `bar` scenario needs the bar
|
|
OPTIONAL_BINARIES = ["komorebi-bar.exe"]
|
|
WITH_CLIENTS = {
|
|
"focus", "moving", "stacks", "workspaces", "resize", "monocle", "closing",
|
|
"commands", "hotplug", "unknown_monitor", "lifecycle",
|
|
"focus_follows_mouse", "layouts", "floating", "minimizing", "padding",
|
|
"maximizing", "workspace_moves", "resize_commands", "promoting",
|
|
"flipping", "pausing", "tiling_off", "lifecycle_hidden",
|
|
"scrolling", "locking", "handover", "fullscreen", "display_change",
|
|
}
|
|
|
|
# what a scenario file has besides `run`, which its suite runs after it
|
|
MORE = {
|
|
"hotplug": ("user_move",),
|
|
"resize": ("edge_cases",),
|
|
"maximizing": ("user",),
|
|
"lifecycle_hidden": ("crash",),
|
|
"monocle": ("focus_behaviour",),
|
|
"monitors": ("at_cursor",),
|
|
"scrolling": ("columns", "two_monitors"),
|
|
}
|
|
|
|
# what only Windows can check, `extras/<name>.py`, after the tiling windows
|
|
EXTRAS = {
|
|
"windows_padding": "padding", "windows_cloaking": "cloaking",
|
|
"windows_config_file": "config_file", "windows_tracking": "tracking",
|
|
"windows_second_display": "second_display",
|
|
"windows_display_change": "display_change",
|
|
"bar": "bar",
|
|
}
|
|
|
|
# a small configuration for the sweep's `replace-configuration`
|
|
SWEEP_CONFIG = '{"monitors":[{"workspaces":[{"name":"again","layout":"BSP"}]}]}'
|
|
SWEEP_CONFIG_PATH = "C:\\e2e\\sweep.json"
|
|
|
|
|
|
def _capture(platform: WindowsPlatform, directory: Path) -> None:
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
(directory / "state-kfw-tiled.json").write_text(
|
|
platform.komorebic("state")
|
|
)
|
|
# the last window opened has the focus: stack it onto its neighbor
|
|
platform.komorebic("stack", "left")
|
|
platform.wait_for(lambda: len(platform.state().containers()) == 2)
|
|
time.sleep(1)
|
|
(directory / "state-kfw-stack.json").write_text(platform.komorebic("state"))
|
|
# then float the focused window, which leaves the stack
|
|
platform.komorebic("toggle-float")
|
|
time.sleep(1)
|
|
(directory / "state-kfw-float.json").write_text(platform.komorebic("state"))
|
|
|
|
|
|
RECORD_SECONDS = 100
|
|
|
|
|
|
def _start_recorder(
|
|
platform: WindowsPlatform, recorder_dir: Path, guest: Guest, out: Path
|
|
) -> None:
|
|
"""Starts komorebi-recorder in the guest for a fixed time."""
|
|
guest.upload(recorder_dir, ["komorebi-recorder.exe"])
|
|
doctor = platform.agent_exec("C:\\e2e\\bin\\komorebi-recorder.exe", "doctor")
|
|
(out / "recorder-doctor.txt").write_text(
|
|
f"status {doctor['status']}\n{doctor['stdout']}{doctor['stderr']}"
|
|
)
|
|
args = ["record", "--duration", str(RECORD_SECONDS), "--window-track",
|
|
"--out", "C:\\e2e\\rec"]
|
|
if os.environ.get("RECORD_NO_VIDEO"):
|
|
args.append("--no-video")
|
|
platform.agent_spawn("C:\\e2e\\bin\\komorebi-recorder.exe", *args)
|
|
|
|
|
|
def _collect_recording(platform: WindowsPlatform, out: Path) -> None:
|
|
"""Waits for the recorder to finish, then brings the session home."""
|
|
def gone() -> bool:
|
|
listing = platform.agent_exec("tasklist")["stdout"]
|
|
return "komorebi-recorder.exe" not in listing
|
|
|
|
platform.wait_for(gone, timeout=RECORD_SECONDS + 60)
|
|
platform.agent_exec(
|
|
"powershell", "-NoProfile", "-Command",
|
|
"Compress-Archive -Force C:\\e2e\\rec C:\\e2e\\rec.zip",
|
|
)
|
|
archive = out / "recording.zip"
|
|
archive.write_bytes(platform.agent_get_file("C:\\e2e\\rec.zip"))
|
|
# Windows PowerShell 5 writes entry names with backslashes
|
|
with zipfile.ZipFile(archive) as z:
|
|
for entry in z.infolist():
|
|
target = out / "session" / entry.filename.replace("\\", "/")
|
|
if entry.is_dir() or entry.filename.endswith("\\"):
|
|
target.mkdir(parents=True, exist_ok=True)
|
|
continue
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
target.write_bytes(z.read(entry))
|
|
|
|
|
|
def _fetch_logs(guest: Guest, out: Path) -> None:
|
|
"""After a failure: bring home the agent's log and the daemon's."""
|
|
try:
|
|
guest.agent.connect(timeout=20)
|
|
guest.agent.exec(
|
|
"powershell", "-NoProfile", "-Command",
|
|
"Copy-Item $env:TEMP\\komorebi_plaintext.log.* C:\\e2e\\"
|
|
"komorebi.log -ErrorAction SilentlyContinue",
|
|
)
|
|
for name, remote in (("agent.log", "C:\\e2e\\agent.log"),
|
|
("komorebi.log", "C:\\e2e\\komorebi.log")):
|
|
try:
|
|
(out / name).write_bytes(guest.agent.get_file(remote))
|
|
except AgentError as e:
|
|
print(f" no {name}: {e}")
|
|
except (AgentError, OSError, ValueError) as e:
|
|
print(f" no logs: {e}")
|
|
|
|
|
|
def _diagnose_start(
|
|
platform: WindowsPlatform, guest: Guest, out: Path
|
|
) -> None:
|
|
"""After a daemon that did not answer: the processes, the daemon's log,
|
|
the agent's log and a screenshot, into `out`."""
|
|
try:
|
|
processes = guest.agent.exec(
|
|
"cmd", "/c", "tasklist /v /fo csv"
|
|
)["stdout"]
|
|
(out / "tasklist.csv").write_text(processes)
|
|
platform.screenshot("start-failed")
|
|
except Exception as e:
|
|
print(f" no diagnosis of the start: {e}")
|
|
_fetch_logs(guest, out)
|
|
|
|
|
|
def run_one(
|
|
golden: Path, bin_dir: Path, out: Path, name: str,
|
|
state: Path | None = None,
|
|
) -> RecordedChecks:
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
module = "commands" if name == "unknown_monitor" else name
|
|
scenario = None
|
|
if name not in EXTRAS:
|
|
scenario = importlib.import_module(
|
|
f"komorebi_vm.core.scenarios.{module}"
|
|
)
|
|
tiling = importlib.import_module("komorebi_vm.core.scenarios.tiling")
|
|
capture = os.environ.get("KOMOREBI_E2E_CAPTURE")
|
|
|
|
checks = RecordedChecks()
|
|
print(f"== {name}")
|
|
began = time.monotonic()
|
|
timings: dict[str, float] = {}
|
|
|
|
def lap(phase: str) -> None:
|
|
now = time.monotonic()
|
|
timings[phase] = round(now - began - sum(timings.values()), 1)
|
|
|
|
with Guest(golden, out / "guest", state=state) as guest:
|
|
lap("guest")
|
|
guest.upload(bin_dir, BINARIES)
|
|
guest.upload(bin_dir, [b for b in OPTIONAL_BINARIES if (bin_dir / b).exists()])
|
|
lap("upload")
|
|
platform = WindowsPlatform(
|
|
guest.qmp, guest.agent, out,
|
|
scale=float(os.environ.get("KOMOREBI_E2E_SCALE", "1")),
|
|
)
|
|
recorder = os.environ.get("KOMOREBI_E2E_RECORDER")
|
|
try:
|
|
platform.start_komorebi(
|
|
log_level="trace" if recorder
|
|
else os.environ.get("KOMOREBI_E2E_LOG_LEVEL")
|
|
)
|
|
except Exception:
|
|
# what the guest was doing when the daemon did not answer
|
|
_diagnose_start(platform, guest, out)
|
|
raise
|
|
lap("daemon")
|
|
if recorder:
|
|
_start_recorder(platform, Path(recorder), guest, out)
|
|
try:
|
|
if name in EXTRAS:
|
|
extra = importlib.import_module(
|
|
f"platforms.qemu_windows.extras.{EXTRAS[name]}"
|
|
)
|
|
clients = _suite(
|
|
checks, shared(tiling.run, platform, checks)
|
|
)[0]
|
|
_suite(checks, platform_only(
|
|
"windows", extra.run, platform, checks, clients
|
|
))
|
|
return checks
|
|
if name in WITH_CLIENTS:
|
|
clients = tiling.run(platform, checks)
|
|
if capture and name == "stacks":
|
|
_capture(platform, Path(capture))
|
|
return checks
|
|
kwargs = {}
|
|
if name == "resize" and os.environ.get("RESIZE_DX"):
|
|
kwargs["dx"] = int(os.environ["RESIZE_DX"])
|
|
if name == "commands":
|
|
config = out / "sweep.json"
|
|
config.write_text(SWEEP_CONFIG)
|
|
guest.agent.put_file(config, SWEEP_CONFIG_PATH)
|
|
if os.environ.get("SWEEP_TWO_DISPLAYS"):
|
|
platform.add_display()
|
|
time.sleep(5)
|
|
_suite(
|
|
checks,
|
|
shared(scenario.layouts, platform, checks, clients),
|
|
shared(
|
|
scenario.sweep, platform, checks, clients,
|
|
SWEEP_CONFIG_PATH,
|
|
),
|
|
shared(scenario.prints, platform, checks),
|
|
)
|
|
return checks
|
|
if name == "unknown_monitor":
|
|
commands = importlib.import_module(
|
|
"komorebi_vm.core.scenarios.commands"
|
|
)
|
|
_suite(checks, shared(
|
|
_with(
|
|
commands.unknown_monitor,
|
|
known_failure=None
|
|
if _contains(UNKNOWN_MONITOR_FIX)
|
|
else UNKNOWN_MONITOR_BUG,
|
|
),
|
|
platform, checks, clients,
|
|
))
|
|
return checks
|
|
if name == "closing":
|
|
# the window that was opened last
|
|
kwargs["closing"] = clients[-1]
|
|
if name == "focus_follows_mouse":
|
|
# two tiles that are in view and do not overlap
|
|
_suite(checks, shared(
|
|
scenario.run, platform, checks, *clients[:2]
|
|
))
|
|
return checks
|
|
_suite(
|
|
checks,
|
|
shared(
|
|
_with(scenario.run, **kwargs), platform, checks,
|
|
clients,
|
|
),
|
|
*(
|
|
shared(getattr(scenario, more), platform, checks, clients)
|
|
for more in MORE.get(name, ())
|
|
),
|
|
)
|
|
elif name == "placement":
|
|
_suite(checks, shared(
|
|
_with(scenario.run, known_failures=None
|
|
if _contains(PLACEMENT_INTEGER_FIX) else {
|
|
PLACEMENT_INTEGER_CASE: PLACEMENT_INTEGER_BUG
|
|
}),
|
|
platform, checks,
|
|
))
|
|
else:
|
|
_suite(
|
|
checks,
|
|
shared(scenario.run, platform, checks),
|
|
*(
|
|
shared(getattr(scenario, more), platform, checks)
|
|
for more in MORE.get(name, ())
|
|
),
|
|
)
|
|
except AgentLost as e:
|
|
print(f" AGENT LOST: {e}")
|
|
checks.bad(str(e))
|
|
_fetch_logs(guest, out)
|
|
except Exception as e:
|
|
died = guest.died()
|
|
if died:
|
|
# the guest is gone, so there is nothing to fetch from it
|
|
raise GuestDied(died) from e
|
|
_fetch_logs(guest, out)
|
|
raise
|
|
finally:
|
|
lap("scenario")
|
|
print(f" seconds: {timings}")
|
|
try:
|
|
platform.screenshot(f"final-{name}")
|
|
except Exception:
|
|
pass
|
|
if recorder:
|
|
_collect_recording(platform, out)
|
|
# matches a recorder session directory with the run that made it
|
|
(out / "result.json").write_text(json.dumps({
|
|
"scenario": name,
|
|
"port": "kfw",
|
|
"commit": _commit(),
|
|
"passed": checks.passed,
|
|
"failed": checks.failed,
|
|
"skipped": len(checks.skipped),
|
|
"known_failures": len(checks.known),
|
|
"start_retries": platform.start_notes,
|
|
"seconds": timings,
|
|
"steps": checks.steps,
|
|
"checks": checks.results,
|
|
}, indent=2))
|
|
return checks
|
|
|
|
|
|
def main(argv: list[str]) -> int:
|
|
golden, bin_dir, out, *names = argv
|
|
failed = 0
|
|
# the commit the binaries were built from, which build-ref.sh writes
|
|
commit_file = Path(bin_dir) / "commit"
|
|
if commit_file.exists() and not os.environ.get("KOMOREBI_E2E_COMMIT"):
|
|
os.environ["KOMOREBI_E2E_COMMIT"] = commit_file.read_text().strip()
|
|
state = None
|
|
if os.environ.get("KOMOREBI_E2E_STATE"):
|
|
state = ensure(Path(golden), Path(os.environ["KOMOREBI_E2E_STATE"]))
|
|
for name in names:
|
|
try:
|
|
try:
|
|
checks = run_one(
|
|
Path(golden), Path(bin_dir), Path(out) / name, name, state
|
|
)
|
|
except GuestDied as e:
|
|
# QEMU itself aborted (it has, while a display was plugged in):
|
|
# not a result about kfw, so the scenario runs once more
|
|
print(f"{name}: THE GUEST DIED ({e}); running it again")
|
|
checks = run_one(
|
|
Path(golden), Path(bin_dir), Path(out) / name, name, state
|
|
)
|
|
except Exception:
|
|
# a scenario that cannot run is a failure of its own, and the
|
|
# others still run
|
|
traceback.print_exc()
|
|
print(f"{name}: did not run, counted as 1 failed")
|
|
failed += 1
|
|
continue
|
|
print(f"{name}: passed {checks.passed} failed {checks.failed}")
|
|
if checks.skipped:
|
|
print(f"{name}: skipped {len(checks.skipped)}")
|
|
if checks.known:
|
|
print(f"{name}: known failures {len(checks.known)}")
|
|
failed += checks.failed
|
|
return 1 if failed else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main(sys.argv[1:]))
|