Two things stood between "containers enabled" and an application actually sitting on its own output, and neither was where I said it was. ipc: discovery refused whenever two instance directories existed, which every compositor restart leaves behind (a log file where a live compositor used to be). After two rebuilds the broker could not reach any compositor at all, so no container could be created and the pointer had nothing to aim at. It now asks each candidate for its version and uses the one that answers, preferring the newest only when two answer, and still refusing when none do. container_host.claim: windows are assigned by the pid the compositor already reports, not by the class stamp the per-session rule matches -- foot, GTK, Qt and the chromium wrapper all ignore that stamp, so the desk was created and left empty while the window sat in special:quarantine. The claim moves the window to its desk's workspace, makes that workspace the one the desk is showing, and reads back: the record says where the window is, never where it was sent. Called from both places a window can appear -- the read-back at start and container.reconcile -- and skipped in the steady state, because a move is a real change on screen and should not be dispatched for its own sake.
642 lines
24 KiB
Python
642 lines
24 KiB
Python
"""Integration: a real daemon, a real control socket, a container and a cursor.
|
|
|
|
Everything the broker talks to is a real socket in this test. The daemon is
|
|
``python -m hhstreamd`` in a subprocess; the compositor is an ``AF_UNIX``
|
|
listener laid out the way Hyprland lays one out, answering the commands
|
|
Hyprland answers; the pointer driver is the shipped driver with its Wayland
|
|
sink replaced by a recorder. No compositor, no VM, no GUI application, no
|
|
network.
|
|
|
|
**What this proves, and what it cannot.** It proves the broker's half: that
|
|
the plan's commands go out in the plan's order, that the record is built from
|
|
what came back rather than from what was asked for, that a container is taken
|
|
down with its session and an unattended one is taken down at start-up, and
|
|
that the cursor is leased, bookmarked and never left with a button down. It
|
|
proves nothing about whether Hyprland agrees — ``output create headless`` is
|
|
marked unverified in the plan, and this fake says ``ok`` because it was asked
|
|
politely. The slice report lists what still needs a real compositor.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import signal
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
|
from conftest import socket_path, wait_until
|
|
from fakes import WINDOW_PID, FakeCompositor, FakeDriver
|
|
from hhstreamd.protocol import ExitCode
|
|
|
|
# The lifecycle test owns the daemon harness; reusing it is what keeps the two
|
|
# files describing the *same* daemon rather than two subtly different ones.
|
|
from test_lifecycle import Daemon, compositor_dir, start
|
|
|
|
|
|
class Rig:
|
|
"""A daemon with a compositor and a driver behind it."""
|
|
|
|
def __init__(self, root: Path, *, with_compositor: bool = True, with_driver: bool = True):
|
|
self.root = root
|
|
# The daemon refuses to start without a Wayland socket to hand its
|
|
# children, so the compositor's runtime directory holds both: the
|
|
# `wayland-N` an application connects to and the `hypr/<sig>/` the
|
|
# broker queries. That is the real layout of /run/hypr-stream.
|
|
self.comp_dir, self._wayland = compositor_dir(root)
|
|
self.compositor = FakeCompositor(self.comp_dir) if with_compositor else None
|
|
runtime = root / "run"
|
|
runtime.mkdir(parents=True, exist_ok=True)
|
|
socket_path(runtime, "pointer.sock")
|
|
self.driver = FakeDriver(runtime / "pointer.sock") if with_driver else None
|
|
self.daemon = Daemon(root, "--compositor-runtime-dir", str(self.comp_dir))
|
|
if self.compositor is not None:
|
|
# As a deployment does: the instance is named, not guessed at.
|
|
self.daemon.env["HYPRLAND_INSTANCE_SIGNATURE"] = self.compositor.signature
|
|
|
|
def start(self) -> None:
|
|
self.daemon.start()
|
|
|
|
def stop(self) -> None:
|
|
self.daemon.stop()
|
|
if self.driver is not None:
|
|
self.driver.stop()
|
|
if self.compositor is not None:
|
|
self.compositor.stop()
|
|
self._wayland.close()
|
|
|
|
# -- convenience ------------------------------------------------------
|
|
|
|
def plan_commands(self) -> list[str]:
|
|
"""What the compositor was told to do, queries filtered out."""
|
|
|
|
assert self.compositor is not None
|
|
return [
|
|
c
|
|
for c in self.compositor.commands
|
|
if not c.startswith(("version", "clients", "monitors", "workspaces", "cursorpos"))
|
|
]
|
|
|
|
|
|
def make_rig(root: Path, **kwargs) -> Rig:
|
|
rig = Rig(root, **kwargs)
|
|
rig.start()
|
|
return rig
|
|
|
|
|
|
@pytest.fixture
|
|
def rig(short_tmpdir: Path):
|
|
r = make_rig(short_tmpdir)
|
|
try:
|
|
yield r
|
|
finally:
|
|
_kill_everything(r.daemon)
|
|
r.stop()
|
|
|
|
|
|
def _kill_everything(daemon: Daemon) -> None:
|
|
try:
|
|
for session in daemon.call("list", all=True).get("sessions", []):
|
|
if session.get("live"):
|
|
try:
|
|
daemon.call("kill", id=session["id"], grace_s=0)
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
# ===========================================================================
|
|
# the container, start to finish
|
|
# ===========================================================================
|
|
|
|
|
|
def test_a_started_session_gets_an_output_a_workspace_and_a_window(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
record = rig.daemon.session(session_id)
|
|
|
|
container = record["container"]
|
|
assert container["output"] == f"hh-{session_id}"
|
|
assert container["workspace"] == 1000
|
|
assert container["mode"] == {"width": 1280, "height": 720}
|
|
assert container["created_by"] == "broker"
|
|
assert container["state"] == "owned"
|
|
# The signature, so a restarted broker re-attaches to this instance.
|
|
assert record["signature"] == rig.compositor.signature
|
|
|
|
# And the compositor really has it.
|
|
assert f"hh-{session_id}" in rig.compositor.outputs()
|
|
assert rig.compositor.workspaces_on(f"hh-{session_id}") == [1000]
|
|
|
|
|
|
def test_the_spatial_fields_come_from_the_compositor_not_from_our_intention(rig: Rig):
|
|
"""The read-back is the point: a record that echoed the plan back would
|
|
look identical whether or not the window rule ever bound."""
|
|
|
|
session_id = start(rig.daemon, "sleeper")
|
|
record = rig.daemon.session(session_id)
|
|
|
|
assert record["workspace"] == 1000
|
|
# The fake gives every window it conjures a pid of its own, which is not
|
|
# the session's — so a record carrying it can only have come from
|
|
# `clients -j`.
|
|
assert record["window"]["stable_id"] == f"hh-{session_id}:{WINDOW_PID}"
|
|
assert record["window"]["initial_class"] == f"hh-{session_id}"
|
|
assert record["pid"] != WINDOW_PID
|
|
assert record["foreground"] is True
|
|
# And `status` says where all of that came from.
|
|
assert record["compositor"]["ipc"] == "ok"
|
|
assert record["compositor"]["signature"] == rig.compositor.signature
|
|
assert record["compositor"]["error"] is None
|
|
|
|
|
|
def test_the_plan_runs_in_order_with_the_quarantine_backstop_first(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
|
|
assert rig.plan_commands() == [
|
|
# Installed at start-up, before any container exists: it matches every
|
|
# class, and a catch-all declared after an anchored rule overrides it.
|
|
"keyword windowrule match:initial_class .*, workspace special:quarantine",
|
|
f"output create headless hh-{session_id}",
|
|
f"keyword workspace 1000, monitor:hh-{session_id}, default:true, persistent:true",
|
|
f"keyword windowrule match:initial_class ^hh-{session_id}$, workspace 1000, "
|
|
f"monitor hh-{session_id}",
|
|
f"keyword monitor hh-{session_id},1280x720,auto,1",
|
|
]
|
|
|
|
|
|
def test_the_application_is_launched_with_the_container_stamp(rig: Rig):
|
|
"""The class the window rule matches reaches the app in its environment.
|
|
|
|
The environment is the only lever the launcher has: a per-app
|
|
``--app-id``/``--class`` flag would have to come from the allowlist, and
|
|
the allowlist is not this slice's file. A toolkit that reads none of
|
|
these keeps its own class — which the read-back is there to catch.
|
|
"""
|
|
|
|
session_id = start(rig.daemon, "idump")
|
|
lines = wait_until(
|
|
lambda: rig.daemon.call("logs", id=session_id).get("lines"),
|
|
timeout=10.0,
|
|
what="the app to report its environment",
|
|
)
|
|
|
|
assert json.loads(lines[0]) == {
|
|
"HHSTREAM_APP_ID": f"hh-{session_id}",
|
|
"SDL_VIDEO_WAYLAND_WMCLASS": f"hh-{session_id}",
|
|
"RESOURCE_NAME": f"hh-{session_id}",
|
|
}
|
|
# And the rule the compositor was given matches exactly that class.
|
|
assert rig.compositor.rules[f"hh-{session_id}"] == (1000, f"hh-{session_id}")
|
|
|
|
|
|
def test_killing_a_session_removes_its_output_and_reports_no_survivors(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
assert f"hh-{session_id}" in rig.compositor.outputs()
|
|
|
|
reply = rig.daemon.call("kill", id=session_id, grace_s=0)
|
|
|
|
assert reply["ok"], reply
|
|
# Teardown facts ride with the record, where `survivors` already does and
|
|
# where the CLI reads them from.
|
|
record = reply["session"]
|
|
assert record["container_removed"] is True
|
|
assert record["container_survivors"] == []
|
|
assert record["container"]["state"] == "removed"
|
|
assert f"hh-{session_id}" not in rig.compositor.outputs()
|
|
assert f"output remove hh-{session_id}" in rig.plan_commands()
|
|
|
|
|
|
def test_a_window_that_outlives_the_teardown_is_reported_not_hidden(rig: Rig):
|
|
"""Two sources have to agree before a teardown is called a success."""
|
|
|
|
session_id = start(rig.daemon, "sleeper")
|
|
# A second window of ours that landed outside the container, so removing
|
|
# the output does not take it with it.
|
|
rig.compositor.add_window(f"hh-{session_id}", 1, "HEADLESS-1", pid=999)
|
|
|
|
reply = rig.daemon.call("kill", id=session_id, grace_s=0)
|
|
|
|
assert [s["pid"] for s in reply["session"]["container_survivors"]] == [999]
|
|
|
|
|
|
def test_the_workspace_slot_comes_back_when_the_session_does_not(rig: Rig):
|
|
first = start(rig.daemon, "sleeper")
|
|
assert rig.daemon.session(first)["container"]["workspace"] == 1000
|
|
rig.daemon.call("kill", id=first, grace_s=0)
|
|
|
|
second = start(rig.daemon, "sleeper")
|
|
|
|
assert rig.daemon.session(second)["container"]["workspace"] == 1000, "the slot was reused"
|
|
|
|
|
|
def test_two_sessions_get_different_outputs_and_different_workspaces(rig: Rig):
|
|
first = start(rig.daemon, "sleeper")
|
|
second = start(rig.daemon, "sleeper")
|
|
|
|
a = rig.daemon.session(first)["container"]
|
|
b = rig.daemon.session(second)["container"]
|
|
|
|
assert a["output"] != b["output"]
|
|
assert {a["workspace"], b["workspace"]} == {1000, 1001}
|
|
assert sorted(rig.compositor.outputs()) == sorted(
|
|
["HEADLESS-1", a["output"], b["output"]]
|
|
)
|
|
|
|
|
|
def test_container_list_reports_the_containers_and_the_orphans(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
rig.compositor.add_output("hh-ghost-aaaaaa")
|
|
|
|
reply = rig.daemon.call("container.list")
|
|
|
|
assert reply["ok"], reply
|
|
assert [row["id"] for row in reply["containers"]] == [session_id]
|
|
assert reply["orphans"] == ["hh-ghost-aaaaaa"]
|
|
assert reply["workspaces_in_use"] == [1000]
|
|
# Listing is not acting.
|
|
assert "hh-ghost-aaaaaa" in rig.compositor.outputs()
|
|
|
|
|
|
def test_container_reconcile_reports_the_difference_it_repaired(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
# The window goes away under the broker, as a crashed application's would.
|
|
rig.compositor._clients.clear()
|
|
|
|
reply = rig.daemon.call("container.reconcile", id=session_id)
|
|
|
|
assert reply["ok"], reply
|
|
fields = {d["field"]: d for d in reply["diff"]}
|
|
assert fields["window"]["observed"] is None
|
|
assert fields["window"]["recorded"]["initial_class"] == f"hh-{session_id}"
|
|
assert rig.daemon.session(session_id)["window"] is None
|
|
|
|
|
|
def test_a_window_that_lands_outside_its_desk_is_moved_onto_it(rig: Rig):
|
|
"""The case the class-matching rule could never handle.
|
|
|
|
Every allowlisted application keeps its own class, so the per-session rule
|
|
matches nothing and the window is swept to the quarantine backstop — a desk
|
|
created and left empty. The compositor reports each client's pid, so the
|
|
window can still be claimed: moved onto its own desk's workspace, with that
|
|
workspace made the visible one, and read back afterwards to say so.
|
|
"""
|
|
|
|
rig.compositor.auto_window = False
|
|
session_id = start(rig.daemon, "sleeper")
|
|
# It turns up on the main screen instead — where a quarantined window goes.
|
|
rig.compositor.add_window(f"hh-{session_id}", 1, "HEADLESS-1", pid=WINDOW_PID)
|
|
|
|
rig.daemon.call("container.reconcile", id=session_id)
|
|
|
|
record = rig.daemon.session(session_id)
|
|
desk = record["container"]
|
|
assert record["workspace"] == desk["workspace"], "the read-back says where it is"
|
|
assert record["foreground"] is True, "its desk is showing it"
|
|
assert desk["state"] != "degraded"
|
|
commands = rig.plan_commands()
|
|
assert (
|
|
f"dispatch movetoworkspacesilent {desk['workspace']},"
|
|
f"address:{record['window']['address']}" in commands
|
|
), commands
|
|
assert f"dispatch workspace {desk['workspace']}" in commands, commands
|
|
|
|
|
|
def test_a_window_already_on_its_desk_is_not_moved(rig: Rig):
|
|
"""The steady state costs nothing: a move is a real change on screen."""
|
|
|
|
session_id = start(rig.daemon, "sleeper")
|
|
|
|
rig.daemon.call("container.reconcile", id=session_id)
|
|
|
|
assert rig.daemon.session(session_id)["workspace"] == 1000
|
|
assert not [c for c in rig.plan_commands() if c.startswith("dispatch")]
|
|
|
|
|
|
# ===========================================================================
|
|
# the start-up scan
|
|
# ===========================================================================
|
|
|
|
|
|
def test_an_unattended_output_is_removed_when_the_broker_starts(short_tmpdir: Path):
|
|
"""A container must never be left running with nobody to own it."""
|
|
|
|
rig = make_rig(short_tmpdir)
|
|
try:
|
|
rig.daemon.stop()
|
|
rig.compositor.add_output("hh-leftover-aaaaaa")
|
|
rig.compositor.add_output("DP-9") # not ours, and must survive
|
|
|
|
rig.daemon.start()
|
|
|
|
assert "hh-leftover-aaaaaa" not in rig.compositor.outputs()
|
|
assert "DP-9" in rig.compositor.outputs()
|
|
assert "output remove hh-leftover-aaaaaa" in rig.plan_commands()
|
|
assert "output remove DP-9" not in rig.plan_commands()
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
def test_a_session_adopted_across_a_restart_keeps_its_container(short_tmpdir: Path):
|
|
rig = make_rig(short_tmpdir)
|
|
try:
|
|
session_id = start(rig.daemon, "sleeper")
|
|
output = rig.daemon.session(session_id)["container"]["output"]
|
|
rig.daemon.stop()
|
|
|
|
rig.daemon.start()
|
|
|
|
record = rig.daemon.session(session_id)
|
|
assert record["adopted"] is True
|
|
assert record["container"]["state"] == "owned"
|
|
assert output in rig.compositor.outputs(), "an adopted container is not an orphan"
|
|
# Its slot is not handed to the next session.
|
|
assert rig.daemon.session(start(rig.daemon, "sleeper"))["container"]["workspace"] == 1001
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
# ===========================================================================
|
|
# degraded mode — PLAN §4.4
|
|
# ===========================================================================
|
|
|
|
|
|
def test_with_no_compositor_ipc_sessions_still_live_and_die_normally(short_tmpdir: Path):
|
|
"""Lifecycle verbs never depend on the compositor.
|
|
|
|
The daemon has a Wayland socket to hand its children (so it starts) and no
|
|
Hyprland instance to query, which is exactly what a compositor that is up
|
|
but not answering IPC looks like from here.
|
|
"""
|
|
|
|
rig = make_rig(short_tmpdir, with_compositor=False)
|
|
try:
|
|
session_id = start(rig.daemon, "sleeper")
|
|
record = rig.daemon.session(session_id)
|
|
|
|
assert record["state"] == "ready"
|
|
assert record["container"] == {
|
|
"output": None,
|
|
"workspace": None,
|
|
"mode": None,
|
|
"created_by": "broker",
|
|
"state": "degraded",
|
|
}
|
|
# Nothing is guessed: no workspace, no window, no instance.
|
|
assert (record["workspace"], record["window"], record["signature"]) == (None, None, None)
|
|
assert record["compositor"]["ipc"] == "absent"
|
|
|
|
rig.daemon.call("touch", id=session_id)
|
|
reply = rig.daemon.call("kill", id=session_id, grace_s=0)
|
|
assert reply["ok"], reply
|
|
assert reply["session"]["state"] == "killed"
|
|
assert reply["session"]["survivors"] == []
|
|
assert reply["session"]["container_survivors"] == []
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
def test_a_degraded_session_cannot_be_aimed_at_and_says_why(short_tmpdir: Path):
|
|
rig = make_rig(short_tmpdir, with_compositor=False)
|
|
try:
|
|
session_id = start(rig.daemon, "sleeper")
|
|
|
|
reply = rig.daemon.call("pointer.acquire", id=session_id)
|
|
|
|
assert reply["ok"] is False
|
|
assert reply["error"] == "no_container"
|
|
assert ExitCode(10) == ExitCode.COMPOSITOR
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
# ===========================================================================
|
|
# the pointer, over the real control socket
|
|
# ===========================================================================
|
|
|
|
|
|
def test_a_whole_gesture_runs_through_the_broker_and_the_driver(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
output = f"hh-{session_id}"
|
|
|
|
acquired = rig.daemon.call("pointer.acquire", id=session_id)
|
|
assert acquired["ok"], acquired
|
|
lease = acquired["lease_id"]
|
|
assert acquired["bookmark"] == {
|
|
"x": 0.5,
|
|
"y": 0.5,
|
|
"output": output,
|
|
"at": acquired["bookmark"]["at"],
|
|
}
|
|
|
|
moved = rig.daemon.call("pointer.move", id=session_id, lease_id=lease, x=0.25, y=0.75)
|
|
assert moved["ok"], moved
|
|
assert (moved["bookmark"]["x"], moved["bookmark"]["y"]) == (0.25, 0.75)
|
|
|
|
clicked = rig.daemon.call("pointer.click", id=session_id, lease_id=lease, button="left")
|
|
assert clicked["ok"], clicked
|
|
|
|
released = rig.daemon.call("pointer.release", id=session_id, lease_id=lease)
|
|
assert released["ok"], released
|
|
assert released["released_by"] == "lease"
|
|
assert released["buttons_lifted"] == []
|
|
|
|
assert rig.driver.sink.calls == [
|
|
("warp", output, 0.5, 0.5),
|
|
("frame", output),
|
|
("warp", output, 0.25, 0.75),
|
|
("frame", output),
|
|
("button", output, 0x110, 1),
|
|
("frame", output),
|
|
("button", output, 0x110, 0),
|
|
("frame", output),
|
|
]
|
|
|
|
# The bookmark is in the record, which is what survives a broker restart.
|
|
record = rig.daemon.session(session_id)
|
|
assert record["pointer"]["bookmark"]["x"] == 0.25
|
|
assert record["pointer"]["released_by"] == "lease"
|
|
assert record["pointer"]["last_released_at"] == released["released_at"]
|
|
|
|
|
|
def test_the_cursor_is_leased_broker_wide_and_the_holder_is_named(rig: Rig):
|
|
first = start(rig.daemon, "sleeper")
|
|
second = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=first)["lease_id"]
|
|
|
|
refused = rig.daemon.call("pointer.acquire", id=second)
|
|
|
|
assert refused["ok"] is False
|
|
assert refused["error"] == "pointer_busy"
|
|
assert refused["holder"] == first
|
|
|
|
# And the other session cannot move it with someone else's lease either.
|
|
denied = rig.daemon.call("pointer.move", id=second, lease_id=lease, x=0.1, y=0.1)
|
|
assert denied["error"] == "no_lease"
|
|
|
|
state = rig.daemon.call("pointer.state")
|
|
assert state["holder"] == first
|
|
assert state["lease_id"] == lease
|
|
|
|
|
|
def test_a_released_lease_frees_the_cursor_for_the_next_session(rig: Rig):
|
|
first = start(rig.daemon, "sleeper")
|
|
second = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=first)["lease_id"]
|
|
rig.daemon.call("pointer.release", id=first, lease_id=lease)
|
|
|
|
taken = rig.daemon.call("pointer.acquire", id=second)
|
|
|
|
assert taken["ok"], taken
|
|
assert taken["bookmark"]["output"] == f"hh-{second}"
|
|
|
|
|
|
def test_a_button_left_down_is_lifted_when_the_lease_is_released(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=session_id)["lease_id"]
|
|
down = rig.daemon.call("pointer.button", id=session_id, lease_id=lease, button="left", state="down")
|
|
assert down["buttons"] == ["left"]
|
|
|
|
released = rig.daemon.call("pointer.release", id=session_id, lease_id=lease)
|
|
|
|
assert released["buttons_lifted"] == ["left"]
|
|
assert rig.driver.dispatcher._pressed == {}, "nothing may be left down on the driver"
|
|
|
|
|
|
def test_killing_a_session_that_holds_the_cursor_gives_it_back(rig: Rig):
|
|
first = start(rig.daemon, "sleeper")
|
|
second = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=first)["lease_id"]
|
|
rig.daemon.call("pointer.button", id=first, lease_id=lease, button="right", state="down")
|
|
|
|
rig.daemon.call("kill", id=first, grace_s=0)
|
|
|
|
assert rig.driver.dispatcher._pressed == {}
|
|
assert rig.daemon.call("pointer.state")["holder"] is None
|
|
assert rig.daemon.call("pointer.acquire", id=second)["ok"]
|
|
|
|
|
|
def test_pointer_verbs_do_not_reset_the_idle_clock(rig: Rig):
|
|
"""A session being clicked in is still one nobody has asked to keep."""
|
|
|
|
session_id = start(rig.daemon, "sleeper")
|
|
before = rig.daemon.session(session_id)["command_count"]
|
|
lease = rig.daemon.call("pointer.acquire", id=session_id)["lease_id"]
|
|
rig.daemon.call("pointer.move", id=session_id, lease_id=lease, x=0.3, y=0.3)
|
|
rig.daemon.call("pointer.click", id=session_id, lease_id=lease)
|
|
rig.daemon.call("pointer.release", id=session_id, lease_id=lease)
|
|
|
|
assert rig.daemon.session(session_id)["command_count"] == before
|
|
|
|
|
|
def test_a_retried_click_with_the_same_request_id_clicks_once(rig: Rig):
|
|
"""A click is the one mutation an agent cannot undo."""
|
|
|
|
session_id = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=session_id)["lease_id"]
|
|
rig.driver.sink.calls.clear()
|
|
|
|
first = rig.daemon.call(
|
|
"pointer.click", id=session_id, lease_id=lease, request_id="retry-me"
|
|
)
|
|
second = rig.daemon.call(
|
|
"pointer.click", id=session_id, lease_id=lease, request_id="retry-me"
|
|
)
|
|
|
|
assert first["ok"] and second["ok"]
|
|
assert second.get("deduplicated") is True
|
|
assert len(rig.driver.sink.of("button")) == 2, "one press and one release, not two"
|
|
|
|
|
|
def test_a_restored_bookmark_survives_a_daemon_restart(short_tmpdir: Path):
|
|
"""That is what putting it in the record, and not only in the lease, is for."""
|
|
|
|
rig = make_rig(short_tmpdir)
|
|
try:
|
|
session_id = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=session_id)["lease_id"]
|
|
rig.daemon.call("pointer.move", id=session_id, lease_id=lease, x=0.8, y=0.2)
|
|
rig.daemon.call("pointer.release", id=session_id, lease_id=lease)
|
|
rig.daemon.stop()
|
|
|
|
rig.daemon.start()
|
|
rig.driver.sink.calls.clear()
|
|
acquired = rig.daemon.call("pointer.acquire", id=session_id)
|
|
|
|
assert (acquired["bookmark"]["x"], acquired["bookmark"]["y"]) == (0.8, 0.2)
|
|
assert rig.driver.sink.of("warp") == [("warp", f"hh-{session_id}", 0.8, 0.2)]
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
def test_with_no_driver_the_pointer_verbs_say_so_and_the_lease_is_not_held(
|
|
short_tmpdir: Path,
|
|
):
|
|
rig = make_rig(short_tmpdir, with_driver=False)
|
|
try:
|
|
session_id = start(rig.daemon, "sleeper")
|
|
|
|
reply = rig.daemon.call("pointer.acquire", id=session_id)
|
|
|
|
assert reply["ok"] is False
|
|
assert reply["error"] == "driver_unavailable"
|
|
assert rig.daemon.call("pointer.state")["holder"] is None
|
|
finally:
|
|
_kill_everything(rig.daemon)
|
|
rig.stop()
|
|
|
|
|
|
# ===========================================================================
|
|
# an exit nobody asked for
|
|
# ===========================================================================
|
|
|
|
|
|
def test_an_application_that_dies_takes_its_container_with_it(rig: Rig):
|
|
session_id = start(rig.daemon, "sleeper")
|
|
output = f"hh-{session_id}"
|
|
pid = rig.daemon.session(session_id)["pid"]
|
|
|
|
os.kill(pid, signal.SIGKILL)
|
|
|
|
wait_until(
|
|
lambda: not rig.daemon.session(session_id)["live"],
|
|
timeout=10.0,
|
|
what="the daemon to notice the exit",
|
|
)
|
|
wait_until(
|
|
lambda: output not in rig.compositor.outputs(),
|
|
timeout=10.0,
|
|
what="the container to be taken down with it",
|
|
)
|
|
assert rig.daemon.session(session_id)["container"]["state"] == "removed"
|
|
# And its slot is free again.
|
|
assert rig.daemon.session(start(rig.daemon, "sleeper"))["container"]["workspace"] == 1000
|
|
|
|
|
|
def test_a_session_that_dies_holding_the_cursor_gives_it_back(rig: Rig):
|
|
"""Never leave a button down, even when nobody asked for the teardown."""
|
|
|
|
first = start(rig.daemon, "sleeper")
|
|
second = start(rig.daemon, "sleeper")
|
|
lease = rig.daemon.call("pointer.acquire", id=first)["lease_id"]
|
|
rig.daemon.call("pointer.button", id=first, lease_id=lease, button="left", state="down")
|
|
|
|
os.kill(rig.daemon.session(first)["pid"], signal.SIGKILL)
|
|
|
|
wait_until(
|
|
lambda: rig.daemon.call("pointer.state")["holder"] is None,
|
|
timeout=10.0,
|
|
what="the lease to come back",
|
|
)
|
|
assert rig.driver.dispatcher._pressed == {}
|
|
assert rig.daemon.call("pointer.acquire", id=second)["ok"]
|