A session could move a cursor and press it, but not scroll. The protocol already had the request -- zwlr_virtual_pointer_v1.axis(time, axis, value) -- it had simply never been implemented, in the driver or the broker. hhstream session pointer scroll <id> --axis vertical --amount 3 Positive is down (vertical) or right (horizontal): the protocol's direction, not a choice of ours, which is why direction travels in the sign and there is deliberately no up/down vocabulary layered over it. The output is whatever the last warp aimed at, exactly like a button, so scrolling somewhere else is a warp first -- and the lease is what keeps the whole gesture atomic. Bounded at 100 wheel clicks per request on both sides, because a decimal-point slip should be a refusal rather than a session scrolled somewhere unrecoverable. The resume point is re-stamped, not moved: the cursor did not go anywhere, so the coordinates are re-affirmed and only the stamp advances. Recorded in the contract as an amendment to the frozen op set, because adding an op to a frozen interface should be visible rather than implied. Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
697 lines
25 KiB
Python
697 lines
25 KiB
Python
"""The pointer verbs: the lease, the bookmark, and never leaving a button down.
|
|
|
|
The broker end is real (the manager, the lease, the driver client) and so is
|
|
the driver end (the shipped dispatcher and server over a real ``AF_UNIX``
|
|
socket). Only the Wayland sink and the clock are substituted — the clock
|
|
because expiry has to be testable without sleeping for thirty seconds, and the
|
|
sink because this machine has no compositor.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from fakes import FakeDriver
|
|
|
|
from hhstreamd.clock import ManualClock
|
|
from hhstreamd.manager import ManagerConfig, ManagerError, SessionManager
|
|
from hhstreamd.policy import Policy
|
|
from hhstreamd.protocol import ExitCode, exit_code_for
|
|
from hhstreamd.registry import ContainerState, Session, State, container_record
|
|
|
|
LEFT = 0x110
|
|
DOWN, UP = 1, 0
|
|
|
|
#: ``wl_pointer_axis``, mirrored from the driver for the same reason the button
|
|
#: codes above are: these tests assert the events, so they name the wire values.
|
|
VERTICAL, HORIZONTAL = 0, 1
|
|
|
|
|
|
def make_session(session_id: str = "foot-aaaaaa", *, container: bool = True) -> Session:
|
|
return Session(
|
|
id=session_id,
|
|
app="foot",
|
|
argv=["/usr/bin/foot"],
|
|
pid=4242,
|
|
pgid=4242,
|
|
sid=4242,
|
|
pid_starttime=918342,
|
|
cmdline_sha256="9f2c",
|
|
home="/home/someone",
|
|
runtime_dir=f"/run/hhstream/sessions/{session_id}",
|
|
created_at="2026-10-01T09:14:02Z",
|
|
created_boottime=1000.0,
|
|
last_activity_at="2026-10-01T09:14:02Z",
|
|
last_activity_boottime=1000.0,
|
|
idle_timeout_s=10800.0,
|
|
state=State.READY,
|
|
container=(
|
|
container_record(
|
|
output=f"hh-{session_id}",
|
|
workspace=1000,
|
|
mode=(1280, 720),
|
|
created_by="broker",
|
|
state=ContainerState.OWNED,
|
|
)
|
|
if container
|
|
else None
|
|
),
|
|
)
|
|
|
|
|
|
class Harness:
|
|
def __init__(self, manager: SessionManager, fake: FakeDriver, clock: ManualClock) -> None:
|
|
self.manager = manager
|
|
self.fake = fake
|
|
self.clock = clock
|
|
|
|
def add(self, session_id: str = "foot-aaaaaa", **kwargs) -> Session:
|
|
return self.manager.registry.add(make_session(session_id, **kwargs))
|
|
|
|
def run(self, coro):
|
|
return asyncio.run(coro)
|
|
|
|
|
|
@pytest.fixture
|
|
def harness(short_tmpdir: Path):
|
|
fake = FakeDriver(short_tmpdir / "p.sock")
|
|
clock = ManualClock(boottime=1000.0)
|
|
manager = SessionManager(
|
|
ManagerConfig(
|
|
state_dir=short_tmpdir / "state",
|
|
runtime_dir=short_tmpdir / "run",
|
|
policy=Policy(),
|
|
pointer_socket=fake.socket_path,
|
|
pointer_ttl_s=30.0,
|
|
pointer_max_s=300.0,
|
|
),
|
|
clock=clock,
|
|
)
|
|
try:
|
|
yield Harness(manager, fake, clock)
|
|
finally:
|
|
if manager.driver is not None:
|
|
manager.driver.close()
|
|
fake.stop()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# acquiring
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_acquire_with_no_bookmark_aims_at_the_centre_of_the_container(harness):
|
|
harness.add()
|
|
|
|
reply = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
assert reply["lease_id"]
|
|
assert reply["bookmark"] == {
|
|
"x": 0.5,
|
|
"y": 0.5,
|
|
"output": "hh-foot-aaaaaa",
|
|
"at": reply["bookmark"]["at"],
|
|
}
|
|
assert harness.fake.sink.calls == [
|
|
("warp", "hh-foot-aaaaaa", 0.5, 0.5),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
|
|
|
|
def test_acquire_restores_the_position_the_session_was_left_at(harness):
|
|
session = harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=0.25, y=0.75))
|
|
harness.run(harness.manager.pointer_release("foot-aaaaaa", lease))
|
|
harness.fake.sink.calls.clear()
|
|
|
|
reply = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.25, 0.75)
|
|
assert harness.fake.sink.of("warp") == [("warp", "hh-foot-aaaaaa", 0.25, 0.75)]
|
|
assert session.pointer["bookmark"]["x"] == 0.25
|
|
|
|
|
|
def test_restore_false_goes_to_the_centre_even_with_a_bookmark(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=0.1, y=0.1))
|
|
harness.run(harness.manager.pointer_release("foot-aaaaaa", lease))
|
|
harness.fake.sink.calls.clear()
|
|
|
|
reply = harness.run(harness.manager.pointer_acquire("foot-aaaaaa", restore=False))
|
|
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.5, 0.5)
|
|
|
|
|
|
def test_a_bookmark_from_another_output_is_not_a_position_in_this_one(harness):
|
|
"""A container is rebuilt with a new name; the old fraction is not a place."""
|
|
|
|
session = harness.add()
|
|
session.pointer = {
|
|
"bookmark": {"x": 0.9, "y": 0.9, "output": "hh-gone", "at": "2026-01-01T00:00:00Z"},
|
|
"last_released_at": None,
|
|
"released_by": None,
|
|
}
|
|
|
|
reply = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.5, 0.5)
|
|
|
|
|
|
def test_a_second_session_is_told_who_holds_the_cursor(harness):
|
|
"""There is one cursor, so the answer is "wait", with a name attached."""
|
|
|
|
harness.add("foot-aaaaaa")
|
|
harness.add("foot-bbbbbb")
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("foot-bbbbbb"))
|
|
|
|
assert exc.value.error == "pointer_busy"
|
|
assert exit_code_for(exc.value.error) == ExitCode.BUSY
|
|
assert exc.value.fields["holder"] == "foot-aaaaaa"
|
|
|
|
|
|
def test_a_session_with_no_container_has_nowhere_to_aim(harness):
|
|
"""Aiming at "wherever the cursor is" is how a click lands next door."""
|
|
|
|
harness.add("foot-aaaaaa", container=False)
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
assert exc.value.error == "no_container"
|
|
assert exit_code_for(exc.value.error) == ExitCode.COMPOSITOR
|
|
|
|
|
|
def test_a_lease_that_could_not_be_aimed_is_not_left_held(harness):
|
|
harness.add()
|
|
harness.fake.stop()
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
assert exc.value.error == "driver_unavailable"
|
|
assert exit_code_for(exc.value.error) == ExitCode.COMPOSITOR
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# moving
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_every_move_writes_the_bookmark_to_the_record(harness):
|
|
"""So a broker that dies mid-gesture still leaves the last real position."""
|
|
|
|
session = harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
for x in (0.1, 0.2, 0.3):
|
|
reply = harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=x, y=0.5))
|
|
assert reply["bookmark"]["x"] == x
|
|
assert session.pointer["bookmark"]["x"] == x
|
|
|
|
# And in the lease, which is what `release` reports.
|
|
outcome = harness.manager.pointer.release("foot-aaaaaa", lease, "test")
|
|
assert outcome.bookmark.x == 0.3
|
|
|
|
|
|
def test_a_relative_move_is_applied_to_the_bookmark_and_clamped(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
reply = harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, dx=0.25, dy=-0.25))
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.75, 0.25)
|
|
|
|
# Running into the edge of the screen is what a mouse does.
|
|
reply = harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, dx=5.0, dy=-5.0))
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (1.0, 0.0)
|
|
|
|
|
|
@pytest.mark.parametrize("bad", [1.4, -0.1, "0.5", True, None])
|
|
def test_an_absolute_coordinate_outside_the_frame_is_a_usage_error(harness, bad):
|
|
"""A caller that computed 1.4 has a bug; clamping it would hide it."""
|
|
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=bad, y=0.5))
|
|
assert exc.value.error == "invalid_argument"
|
|
|
|
|
|
def test_moving_without_the_lease_is_nine_and_not_eight(harness):
|
|
harness.add("foot-aaaaaa")
|
|
harness.add("foot-bbbbbb")
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_move("foot-bbbbbb", lease, x=0.5, y=0.5))
|
|
|
|
assert exc.value.error == "no_lease"
|
|
assert exit_code_for(exc.value.error) == ExitCode.NO_LEASE
|
|
|
|
|
|
def test_a_stale_lease_id_is_refused_even_for_the_holder(harness):
|
|
harness.add()
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", "not-the-lease", x=0.5, y=0.5))
|
|
assert exc.value.error == "no_lease"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# buttons
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_a_button_goes_down_and_up_through_the_driver(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
assert harness.run(
|
|
harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down")
|
|
)["buttons"] == ["left"]
|
|
assert harness.run(
|
|
harness.manager.pointer_button("foot-aaaaaa", lease, "left", "up")
|
|
)["buttons"] == []
|
|
|
|
assert harness.fake.sink.calls == [
|
|
("button", "hh-foot-aaaaaa", LEFT, DOWN),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
("button", "hh-foot-aaaaaa", LEFT, UP),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
|
|
|
|
def test_a_click_is_a_press_and_a_release_each_committed(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
reply = harness.run(harness.manager.pointer_click("foot-aaaaaa", lease, "left", 2))
|
|
|
|
assert reply["count"] == 2
|
|
assert harness.fake.sink.calls == [
|
|
("button", "hh-foot-aaaaaa", LEFT, DOWN),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
("button", "hh-foot-aaaaaa", LEFT, UP),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
] * 2
|
|
assert harness.manager.pointer.pressed() == []
|
|
|
|
|
|
@pytest.mark.parametrize("bad", [0, 99, "two", True, 1.5])
|
|
def test_a_click_count_off_the_wire_is_bounded(harness, bad):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_click("foot-aaaaaa", lease, "left", bad))
|
|
assert exc.value.error == "invalid_argument"
|
|
|
|
|
|
def test_an_unknown_button_is_refused_by_the_driver_not_invented(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "pinky", "down"))
|
|
|
|
assert exc.value.error == "driver_refused"
|
|
assert harness.manager.pointer.pressed() == [], "a refused press must not be mirrored"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# releasing and expiry
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_release_lifts_what_was_down_and_stamps_the_record(harness):
|
|
session = harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=0.4, y=0.6))
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
|
|
|
|
reply = harness.run(harness.manager.pointer_release("foot-aaaaaa", lease))
|
|
|
|
assert reply["buttons_lifted"] == ["left"]
|
|
assert reply["released_by"] == "lease"
|
|
assert reply["bookmark"]["x"] == 0.4
|
|
assert session.pointer["released_by"] == "lease"
|
|
assert session.pointer["last_released_at"] == reply["released_at"]
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
|
|
|
|
def test_an_idle_lease_expires_and_the_button_it_left_down_is_lifted(harness):
|
|
"""The order is the contract's: `pressed()` is read before `expire()`,
|
|
because `expire()` drops the lease's button set with the lease."""
|
|
|
|
session = harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
|
|
harness.clock.advance(31.0)
|
|
|
|
expired = harness.run(harness.manager._expire_pointer())
|
|
|
|
assert expired == {
|
|
"session": "foot-aaaaaa",
|
|
"lease_id": lease,
|
|
"buttons_lifted": ["left"],
|
|
}
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
assert harness.fake.sink.calls[-2:] == [
|
|
("button", "hh-foot-aaaaaa", LEFT, UP),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
assert session.pointer["released_by"] == "timeout"
|
|
|
|
|
|
def test_an_expired_lease_is_noticed_by_the_next_verb_as_well(harness):
|
|
"""So the cursor is free for someone else even with no sweep in between."""
|
|
|
|
harness.add("foot-aaaaaa")
|
|
harness.add("foot-bbbbbb")
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
harness.clock.advance(31.0)
|
|
|
|
reply = harness.run(harness.manager.pointer_acquire("foot-bbbbbb"))
|
|
|
|
assert reply["id"] == "foot-bbbbbb"
|
|
assert harness.manager.pointer.state()["holder"] == "foot-bbbbbb"
|
|
|
|
|
|
def test_a_refresh_loop_still_loses_the_cursor_at_the_hard_cap(harness):
|
|
"""A stuck agent must not be able to hold the mouse forever."""
|
|
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
for _ in range(12):
|
|
harness.clock.advance(25.0)
|
|
try:
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=0.5, y=0.5))
|
|
except ManagerError as exc:
|
|
assert exc.error == "no_lease"
|
|
break
|
|
else: # pragma: no cover - the cap did not fire
|
|
pytest.fail("the hard cap never expired the lease")
|
|
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
|
|
|
|
def test_a_caller_supplied_ttl_applies_to_this_lease_and_then_goes_away(harness):
|
|
harness.add("foot-aaaaaa")
|
|
harness.add("foot-bbbbbb")
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa", ttl_s=5.0))
|
|
harness.clock.advance(6.0)
|
|
|
|
assert harness.run(harness.manager._expire_pointer()) is not None
|
|
assert harness.manager.pointer.ttl_s == 30.0, "the default must come back"
|
|
|
|
harness.run(harness.manager.pointer_acquire("foot-bbbbbb"))
|
|
harness.clock.advance(6.0)
|
|
assert harness.run(harness.manager._expire_pointer()) is None
|
|
|
|
|
|
def test_a_ttl_beyond_the_hard_cap_is_refused(harness):
|
|
harness.add()
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa", ttl_s=10_000))
|
|
assert exc.value.error == "invalid_argument"
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
|
|
|
|
def test_expiry_with_no_driver_is_loud_rather_than_silent(harness, caplog):
|
|
"""A button we could not lift is the one thing that must never be quiet."""
|
|
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
|
|
harness.fake.stop()
|
|
harness.clock.advance(31.0)
|
|
|
|
with caplog.at_level("ERROR"):
|
|
harness.run(harness.manager._expire_pointer())
|
|
|
|
assert "a button may still be down" in caplog.text
|
|
assert harness.manager.pointer.state()["holder"] is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# the rest of the contract
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_no_pointer_verb_counts_as_activity(harness):
|
|
"""A session being clicked in is still one nobody has asked to keep."""
|
|
|
|
session = harness.add()
|
|
before = (session.last_activity_boottime, session.command_count)
|
|
harness.clock.advance(100.0)
|
|
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_move("foot-aaaaaa", lease, x=0.5, y=0.5))
|
|
harness.run(harness.manager.pointer_click("foot-aaaaaa", lease))
|
|
harness.manager.pointer_state()
|
|
harness.run(harness.manager.pointer_release("foot-aaaaaa", lease))
|
|
|
|
assert (session.last_activity_boottime, session.command_count) == before
|
|
|
|
|
|
def test_pointer_state_names_the_holder_and_what_is_down(harness):
|
|
harness.add()
|
|
assert harness.manager.pointer_state()["holder"] is None
|
|
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "right", "down"))
|
|
|
|
state = harness.manager.pointer_state()
|
|
assert state["holder"] == "foot-aaaaaa"
|
|
assert state["lease_id"] == lease
|
|
assert state["buttons"] == ["right"]
|
|
assert state["bookmark"]["output"] == "hh-foot-aaaaaa"
|
|
|
|
|
|
def test_a_dead_session_cannot_be_aimed_at(harness):
|
|
session = harness.add()
|
|
harness.manager.registry.terminate(session, State.EXITED)
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
assert exc.value.error == "session_exited"
|
|
|
|
|
|
def test_an_unknown_session_is_three_not_a_lease_error(harness):
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_acquire("nope-zzzzzz"))
|
|
assert exit_code_for(exc.value.error) == ExitCode.NO_SUCH_SESSION
|
|
|
|
|
|
def test_no_driver_configured_at_all_is_reported_as_unavailable(short_tmpdir: Path):
|
|
manager = SessionManager(
|
|
ManagerConfig(
|
|
state_dir=short_tmpdir / "state",
|
|
runtime_dir=short_tmpdir / "run",
|
|
policy=Policy(),
|
|
# Explicitly nothing, rather than the derived default.
|
|
pointer_socket=short_tmpdir / "no-driver-here.sock",
|
|
),
|
|
clock=ManualClock(boottime=1000.0),
|
|
)
|
|
manager.registry.add(make_session())
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
asyncio.run(manager.pointer_acquire("foot-aaaaaa"))
|
|
assert exc.value.error == "driver_unavailable"
|
|
|
|
|
|
def test_releasing_with_someone_elses_lease_lifts_nothing(harness):
|
|
"""The refusal has to come before anything reaches the driver.
|
|
|
|
Otherwise ``pointer.release`` is a way for any session to drop the
|
|
holder's buttons mid-drag on its way to being told no.
|
|
"""
|
|
|
|
harness.add("foot-aaaaaa")
|
|
harness.add("foot-bbbbbb")
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
|
|
harness.fake.sink.calls.clear()
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_release("foot-bbbbbb", lease))
|
|
|
|
assert exc.value.error == "no_lease"
|
|
assert harness.fake.sink.calls == []
|
|
assert harness.manager.pointer.pressed() == ["left"]
|
|
assert harness.manager.pointer.state()["holder"] == "foot-aaaaaa"
|
|
|
|
|
|
def test_a_stale_lease_id_cannot_release_the_current_one(harness):
|
|
harness.add()
|
|
first = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.run(harness.manager.pointer_release("foot-aaaaaa", first))
|
|
second = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_release("foot-aaaaaa", first))
|
|
|
|
assert exc.value.error == "no_lease"
|
|
assert harness.manager.pointer.state()["lease_id"] == second
|
|
|
|
|
|
def test_the_sweeper_expires_a_lease_nobody_came_back_for(short_tmpdir: Path):
|
|
"""The TTL is only a promise if something checks it unprompted.
|
|
|
|
An agent that acquired, pressed a button and died would otherwise hold the
|
|
cursor — with the button down — until some other session happened to try.
|
|
"""
|
|
|
|
fake = FakeDriver(short_tmpdir / "p.sock")
|
|
clock = ManualClock(boottime=1000.0)
|
|
manager = SessionManager(
|
|
ManagerConfig(
|
|
state_dir=short_tmpdir / "state",
|
|
runtime_dir=short_tmpdir / "run",
|
|
policy=Policy(),
|
|
pointer_socket=fake.socket_path,
|
|
pointer_ttl_s=30.0,
|
|
# Short, so the test waits on the sweep and not on the TTL; the
|
|
# TTL itself is the injected clock's business.
|
|
pointer_sweep_s=0.01,
|
|
),
|
|
clock=clock,
|
|
)
|
|
session = manager.registry.add(make_session())
|
|
|
|
async def scenario():
|
|
lease = (await manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
await manager.pointer_button("foot-aaaaaa", lease, "left", "down")
|
|
sweeper = asyncio.create_task(manager._sweep_pointer())
|
|
clock.advance(31.0)
|
|
for _ in range(500):
|
|
await asyncio.sleep(0.01)
|
|
if manager.pointer.state()["holder"] is None:
|
|
break
|
|
sweeper.cancel()
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await sweeper
|
|
|
|
try:
|
|
asyncio.run(scenario())
|
|
assert manager.pointer.state()["holder"] is None
|
|
assert fake.dispatcher._pressed == {}, "the sweep lifted it on the driver"
|
|
assert session.pointer["released_by"] == "timeout"
|
|
finally:
|
|
if manager.driver is not None:
|
|
manager.driver.close()
|
|
fake.stop()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# scrolling
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_scroll_drives_axis_then_frame_on_the_sessions_own_output(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
reply = harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "vertical", 3))
|
|
|
|
assert (reply["axis"], reply["amount"]) == ("vertical", 3.0)
|
|
assert harness.fake.sink.calls == [
|
|
("axis", "hh-foot-aaaaaa", VERTICAL, 3.0),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
|
|
|
|
def test_scrolling_up_is_the_sign_and_not_a_different_verb(harness):
|
|
"""One verb, one axis name, and the protocol's sign carries the direction."""
|
|
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "vertical", -3))
|
|
|
|
assert harness.fake.sink.calls == [
|
|
("axis", "hh-foot-aaaaaa", VERTICAL, -3.0),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
|
|
|
|
def test_a_horizontal_scroll_uses_the_other_axis(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "horizontal", 2))
|
|
|
|
assert harness.fake.sink.calls == [
|
|
("axis", "hh-foot-aaaaaa", HORIZONTAL, 2.0),
|
|
("frame", "hh-foot-aaaaaa"),
|
|
]
|
|
|
|
|
|
def test_a_scroll_restamps_the_resume_point_without_moving_it(harness):
|
|
"""The cursor stays put -- and the record must not pretend otherwise."""
|
|
|
|
session = harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
before = dict(session.pointer["bookmark"])
|
|
|
|
harness.clock.advance(7.0)
|
|
reply = harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "vertical", 3))
|
|
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (before["x"], before["y"])
|
|
assert reply["bookmark"]["output"] == before["output"]
|
|
assert reply["bookmark"]["at"] != before["at"], "the session acted, so the stamp moved"
|
|
assert harness.manager.pointer.state()["holder"] == "foot-aaaaaa"
|
|
|
|
|
|
@pytest.mark.parametrize("bad", [0, 0.0, 101, -101, "three", True, None])
|
|
def test_a_scroll_amount_off_the_wire_is_bounded(harness, bad):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "vertical", bad))
|
|
|
|
assert exc.value.error == "invalid_argument"
|
|
|
|
|
|
def test_an_unknown_axis_is_refused_by_the_driver_not_invented(harness):
|
|
harness.add()
|
|
lease = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))["lease_id"]
|
|
harness.fake.sink.calls.clear()
|
|
|
|
with pytest.raises(ManagerError) as exc:
|
|
harness.run(harness.manager.pointer_scroll("foot-aaaaaa", lease, "diagonal", 3))
|
|
|
|
assert exc.value.error == "driver_refused"
|
|
assert harness.fake.sink.calls == [], "a refused scroll must emit nothing"
|
|
|
|
|
|
def test_a_scroll_without_the_lease_is_refused(harness):
|
|
session = harness.add()
|
|
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
|
|
harness.fake.sink.calls.clear()
|
|
|
|
with pytest.raises(ManagerError):
|
|
harness.run(
|
|
harness.manager.pointer_scroll("foot-aaaaaa", "not-this-lease", "vertical", 3)
|
|
)
|
|
|
|
assert harness.fake.sink.calls == []
|
|
assert session.pointer.get("bookmark") is not None, "a refused scroll changes nothing"
|