Files
hyprland-headless-stream-pl…/tests/sessions/unit/test_keyboard_verbs.py
HermenixandClaude Opus 5 e6f4c3bb3f Stage 1 review fixes, and Stage 2: the broker, the CLI and the module
The Stage 1 review (docs/reviews/2026-10-04-stage1-review.md, verdict
yes-with-fixes) found a real bug, and it was the kind Stage 2 would have
cemented. All five findings:

(1) HIGH, and reproduced before fixing: `key` resolved the action and
    then used only its `code`. So `keyboard key A` sent a bare code 30
    and the window received `a`; on `de`, `at` lost its level-three mask
    and typed `q`. `type` was the only path that used the mask, which is
    why every `type` test stayed green. `key` now sends
    modifiers(baseline | mask) before the down and restores the baseline
    on the up -- the one-character `type` sequence -- and `Shift_L`
    keeps its key-then-mask order, which is the other path on purpose.

    The same hole aliased two names onto one keycode: `down A` then
    `down a` recorded both and pressed 30 twice, Hyprland dropped the
    second, and the held set lied until the lease ended. A second name
    for a code already down is now refused.

(2) HIGH: the shutdown comment claimed hyprland-conf.nix sets
    input:virtualkeyboard:release_pressed_on_close. It did not. The line
    is there now, with the note that it releases keys and still never
    clears a mask -- which is why release_all zeroes the mask on every
    path we control rather than relying on it.

(3) MEDIUM: nothing would have noticed the keymap upload stopping. A
    `main` that connected and listened without uploading passed every
    test in the tree. Now asserted on the real sink: uploaded once,
    before `listen` (one shared ordering log across both stand-ins), the
    payload NUL-terminated with `size == len(utf8) + 1` read back
    through the fd, format 1, one terminator not two, and modifiers(0)
    straight after.

(4) LOW: `key` up now forgets the name only after a successful send,
    like `button` -- otherwise a raise between the two leaves us
    believing a key is up that the compositor still has down, and
    release_all will not try again.

(5) LOW: `\r` no longer aliases to Return (CRLF would have become two
    newlines silently), and an empty layout is refused -- xkbcommon
    compiles "" as the same keymap as `us`, so `--xkb-layout ''` looked
    configured and typed `us`.

Several of the review's named false passes are closed too: Control's
mask is compared against mod_get_index("Control") rather than merely
"not Shift's"; the keymap text assertion names pc_us_inet/pc_de_inet
instead of substring-matching "us"; the capital-under-Control case
asserts the whole sequence; the exit-code mirror is compared against
hhstreamd.protocol; and the module's defaults are read out of
nix/module.nix rather than asserted against themselves.

Stage 2 proper:

  * broker verbs keyboard.key / keyboard.type, both in the mutation set,
    both through _refresh (so they refresh the lease and, like every
    pointer verb, do NOT count as activity)
  * the driver's `kind` token mapped: a bad keysym or character is
    invalid_argument (exit 2), a missing keyboard global stays
    driver_refused (exit 10). The 4096-scalar cap and the shape checks
    are broker-side, because only a broker-side invalid_argument is 2
  * keys[] on pointer.state, keys_lifted[] on pointer.release and on
    pointer_lease_timeout, one release_all for both halves
  * CLI `session keyboard type|key|down|up`, reusing the pointer lease
    and its cache; `type` takes one raw argument and interprets nothing;
    the audit records a character count and never the text
  * sessions.keyboard.{layout,model,variant,options} on the unit's argv,
    layout defaulting to "us" with a type that refuses a comma. NO
    [keyboard] TOML table: hhstreamd reads that file and the driver is a
    different unit, so it would be a setting with no effect
  * CONTRACT-sessions.md bumped to v3; README.dev.md item 3 and
    vm-pointer.nix's header corrected (both still said the conf ships
    follow_mouse = 0 and that the keyboard work would choose)

And the operator decision that acquire grabs both devices: it now sends
two warps a real pixel apart, because one warp onto an idle cursor moves
the cursor and not keyboard focus. follow_mouse_threshold = 0 is set
explicitly in hyprland-conf.nix since the second warp depends on it,
`dispatch focuswindow` is the fallback when the nudge cannot be sent,
and the reply and audit carry which mechanism ran. The acquire test
asserts the pair and that they floor to different pixels -- a test that
only saw wl_pointer.enter would pass while the first keystroke went to
the wrong window.

  nix develop -c python -m pytest tests/pointer tests/sessions/unit -q
  605 passed in 27.11s

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GhNPM6rGcuzxocM1nATnuM
2026-10-04 04:11:24 +00:00

664 lines
24 KiB
Python

"""The keyboard verbs: the pointer lease, the key mirror, and the exit codes.
Harness copied from ``test_pointer_verbs.py``, and the same things are real:
the manager, the lease, the driver client, and the shipped dispatcher and
server over a real ``AF_UNIX`` socket — plus a real compiled ``us`` keymap, so
an assertion about which evdev code went on the wire is an assertion about the
layout and not about a stub that agreed with it. Only the Wayland sink and the
clock are substituted.
Two things these tests are careful about, both of them false passes the
verification doc names:
* **the clock does not advance anything by itself.** A test that moves
``ManualClock`` and then asserts the lease is gone would pass against a
broker that never expires anything: expiry runs in ``_expire_pointer``, from
the sweeper or from the next verb, so every expiry case here calls one of
those explicitly.
* **a refusal is asserted by its exit code and by the sink.** "The reply said
`ok: false`" is satisfied by a handler that typed the string and then
errored, so the sink's call list is checked too.
"""
from __future__ import annotations
import asyncio
from pathlib import Path
import pytest
from fakes import KEY_A, KEY_LEFTCTRL, KEY_LEFTSHIFT, FakeDriver, us_keymap
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
DOWN, UP = 1, 0
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)
def acquire(self, session_id: str = "foot-aaaaaa") -> str:
"""Add the session if it is not there yet, then take the lease.
Convenience, and deliberate: almost every test here is about what
happens *after* a lease exists, and spelling out the `add` each time
buys nothing. The tests that care about two sessions add them by hand.
"""
if self.manager.registry.get(session_id) is None:
self.add(session_id)
lease = self.run(self.manager.pointer_acquire(session_id))["lease_id"]
# Acquire's own two focus warps are not what any of these tests are
# about, so they are dropped here rather than skipped past in every
# assertion.
self.fake.sink.calls.clear()
return lease
def keys(self) -> list[str]:
return self.manager.pointer_state()["keys"]
def _harness(short_tmpdir: Path, *, keyboard: bool = True):
fake = FakeDriver(short_tmpdir / "p.sock", keyboard=keyboard)
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()
@pytest.fixture
def harness(short_tmpdir: Path):
yield from _harness(short_tmpdir)
@pytest.fixture
def keyboardless(short_tmpdir: Path):
"""A driver whose compositor advertises no virtual-keyboard global."""
yield from _harness(short_tmpdir, keyboard=False)
# ---------------------------------------------------------------------------
# the lease is the pointer's
# ---------------------------------------------------------------------------
def test_typing_without_a_lease_is_no_lease_and_not_busy(harness):
"""Exit 9 and not 8: 9 says "acquire one", 8 says "wait for someone"."""
harness.add()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_type("foot-aaaaaa", "nonesuch", "hello"))
assert exc.value.error == "no_lease"
assert exit_code_for(exc.value.error) == ExitCode.NO_LEASE
assert harness.fake.sink.calls == []
def test_another_sessions_lease_is_also_no_lease(harness):
harness.add("foot-aaaaaa")
harness.add("foot-bbbbbb")
lease = harness.acquire("foot-aaaaaa")
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_type("foot-bbbbbb", lease, "hello"))
# Not `pointer_busy`: B is not being told to wait its turn, it is being
# told this lease id is not its own.
assert exc.value.error == "no_lease"
assert harness.fake.sink.calls == []
def test_a_second_acquire_while_a_key_is_held_is_busy_and_leaves_the_key(harness):
harness.add("foot-aaaaaa")
harness.add("foot-bbbbbb")
lease = harness.acquire("foot-aaaaaa")
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
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
# Still the first holder's, and still held: a refused acquire must not
# disturb a chord someone is in the middle of.
assert harness.manager.pointer.state()["holder"] == "foot-aaaaaa"
assert harness.keys() == ["Shift_L"]
def test_the_holder_cannot_acquire_a_second_lease_either(harness):
"""Unchanged by the keyboard, and asserted here because typing is where a
second id would do the most damage: a half-typed chord whose lease was
silently replaced fails with "stale lease" for no visible reason."""
harness.add()
harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
assert exc.value.error == "pointer_busy"
# ---------------------------------------------------------------------------
# what goes on the wire
# ---------------------------------------------------------------------------
def test_typing_a_capital_sends_the_mask_then_the_key(harness):
lease = harness.acquire()
reply = harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "A"))
shift = us_keymap().modifier_mask("Shift_L")
assert harness.fake.sink.calls == [
("modifiers", shift, 0, 0, 0),
("key", KEY_A, DOWN),
("key", KEY_A, UP),
("modifiers", 0, 0, 0, 0),
]
# No synthetic Shift keycode: this compositor does not derive the mask from
# an injected key, and sending both is how a toolkit shifts twice.
assert not any(c[0] == "key" and c[1] == KEY_LEFTSHIFT for c in harness.fake.sink.calls)
assert reply["chars"] == 1
assert reply["keys"] == []
def test_typing_leaves_nothing_held(harness):
lease = harness.acquire()
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "hello"))
assert harness.keys() == []
def test_a_held_modifier_survives_a_type_and_ors_into_it(harness):
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Control_L", "down"))
harness.fake.sink.calls.clear()
reply = harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "c"))
control = us_keymap().modifier_mask("Control_L")
assert harness.fake.sink.calls[0] == ("modifiers", control, 0, 0, 0)
# Restored to the baseline, not to zero: Control was not this type's to
# lift, and `down Control_L` + `type c` + `up Control_L` is how a chord is
# spelled across three CLI invocations.
assert harness.fake.sink.calls[-1] == ("modifiers", control, 0, 0, 0)
assert reply["keys"] == ["Control_L"]
assert harness.keys() == ["Control_L"]
def test_a_key_down_is_mirrored_in_the_lease_by_name(harness):
lease = harness.acquire()
reply = harness.run(
harness.manager.keyboard_key("foot-aaaaaa", lease, "Control_L", "down")
)
# The reply and the lease both speak names; only the sink sees the code.
assert reply["keys"] == ["Control_L"]
assert harness.keys() == ["Control_L"]
assert ("key", KEY_LEFTCTRL, DOWN) in harness.fake.sink.calls
def test_pointer_state_reports_held_keys_beside_held_buttons(harness):
lease = harness.acquire()
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
state = harness.manager.pointer_state()
assert state["buttons"] == ["left"]
assert state["keys"] == ["Shift_L"]
def test_an_up_of_a_key_that_was_not_down_changes_nothing(harness):
lease = harness.acquire()
reply = harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "up"))
assert reply["keys"] == []
# Nothing on the wire either: a key-up the compositor has no matching
# key-down for puts its `m_pressed` out of step with ours.
assert harness.fake.sink.calls == []
# ---------------------------------------------------------------------------
# exit codes (the verification doc's change 1)
# ---------------------------------------------------------------------------
def test_an_unmappable_character_is_exit_2_and_types_nothing(harness):
"""The driver's token is what makes this 2 rather than 10.
Without it the refusal arrives as `driver_refused`, which is exit 10 and
says "the compositor failed" about a character that is simply not on the
layout. `é` is the case: perfectly well formed, unmappable on `us`.
"""
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "café"))
assert exc.value.error == "invalid_argument"
assert exit_code_for(exc.value.error) == ExitCode.USAGE
# No prefix: "c", "a" and "f" must not have been typed.
assert harness.fake.sink.calls == []
def test_the_refusal_does_not_carry_the_string_it_refused(harness):
"""A typed string is a password as often as not, and this reason is logged."""
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "hunter2é"))
assert "hunter2" not in exc.value.reason
assert "é" not in exc.value.reason
assert "scalar 7" in exc.value.reason
def test_an_unknown_keysym_is_exit_2(harness):
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(
harness.manager.keyboard_key("foot-aaaaaa", lease, "NoSuchKeysym", "down")
)
assert exit_code_for(exc.value.error) == ExitCode.USAGE
assert harness.keys() == []
@pytest.mark.parametrize(
"text, fragment",
[(None, "must be a string"), (7, "must be a string"), (["a"], "must be a string")],
)
def test_a_text_that_is_not_a_string_is_exit_2_before_the_driver(harness, text, fragment):
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, text))
assert exc.value.error == "invalid_argument"
assert fragment in exc.value.reason
assert harness.fake.sink.calls == []
def test_a_string_over_the_cap_is_exit_2_at_the_broker(harness):
"""Checked here and not only in the driver, because only a broker-side
`invalid_argument` produces exit 2 — a driver-side length refusal would
arrive as a compositor failure unless it carried the token."""
from hhstreamd.manager import MAX_TYPE_SCALARS
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(
harness.manager.keyboard_type("foot-aaaaaa", lease, "a" * (MAX_TYPE_SCALARS + 1))
)
assert exc.value.error == "invalid_argument"
assert str(MAX_TYPE_SCALARS) in exc.value.reason
assert harness.fake.sink.calls == []
def test_exactly_the_cap_is_accepted(harness):
from hhstreamd.manager import MAX_TYPE_SCALARS
lease = harness.acquire()
reply = harness.run(
harness.manager.keyboard_type("foot-aaaaaa", lease, "a" * MAX_TYPE_SCALARS)
)
assert reply["chars"] == MAX_TYPE_SCALARS
@pytest.mark.parametrize("state", [None, "sideways", "DOWN", 1])
def test_a_bad_key_state_is_exit_2(harness, state):
lease = harness.acquire()
with pytest.raises(ManagerError) as exc:
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "a", state))
assert exc.value.error == "invalid_argument"
assert harness.fake.sink.calls == []
def test_no_keyboard_global_is_exit_10_and_the_cursor_still_works(keyboardless):
"""A compositor with no `zwp_virtual_keyboard_manager_v1`.
Exit 10 and not 2: the caller's request was fine. And the pointer half has
to keep working, which is the whole reason a missing keyboard global does
not abort the driver's start-up the way a version-1 pointer manager does.
"""
keyboardless.add()
lease = keyboardless.acquire()
with pytest.raises(ManagerError) as exc:
keyboardless.run(keyboardless.manager.keyboard_type("foot-aaaaaa", lease, "hi"))
assert exc.value.error == "driver_refused"
assert exit_code_for(exc.value.error) == ExitCode.COMPOSITOR
# The cursor is unaffected.
moved = keyboardless.run(
keyboardless.manager.pointer_move("foot-aaaaaa", lease, x=0.25, y=0.75)
)
assert moved["bookmark"]["x"] == 0.25
def test_a_refused_key_is_not_recorded_as_held(harness):
"""The driver first, then the mirror — the `pointer_button` order.
The reverse mistake is harmless (`release_all` lifts what the *driver*
recorded), but recording a key the driver refused means `release_all` later
asks it to lift something it never pressed.
"""
lease = harness.acquire()
with pytest.raises(ManagerError):
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "NoSuchKeysym", "down"))
assert harness.keys() == []
assert harness.manager.pointer_state()["keys"] == []
# ---------------------------------------------------------------------------
# the TTL
# ---------------------------------------------------------------------------
def test_typing_refreshes_the_lease(harness):
"""`type` goes through `_refresh`, so it moves the idle deadline.
The clock is advanced in two steps with a `type` between them: 20s, type,
20s. Without the refresh that is 40s against a 30s TTL and the lease is
gone; with it, the second 20s is measured from the type.
"""
harness.add()
lease = harness.acquire()
harness.clock.advance(20.0)
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "hello"))
harness.clock.advance(20.0)
# The next verb is what notices an expiry, so this is the honest way to ask
# "is the lease still alive" -- not reading `state()`, which never expires
# anything.
harness.run(harness.manager._expire_pointer())
assert harness.manager.pointer.state()["holder"] == "foot-aaaaaa"
def test_the_hard_cap_still_beats_a_typing_loop(harness):
harness.add()
lease = harness.acquire()
for _ in range(20):
harness.clock.advance(20.0)
with __import__("contextlib").suppress(ManagerError):
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "x"))
assert harness.manager.pointer.state()["holder"] is None
def test_an_expired_lease_lifts_the_key_it_left_down(harness):
"""The expiry contract, with a key: read before `expire()`, then one
`release_all` on the driver, and the mask zeroed after the key-up."""
harness.add()
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
harness.fake.sink.calls.clear()
harness.clock.advance(31.0)
expired = harness.run(harness.manager._expire_pointer())
assert expired["keys_lifted"] == ["Shift_L"]
assert harness.fake.sink.calls == [
("key", KEY_LEFTSHIFT, UP),
# Not optional. A virtual key-up clears no modifier state on this
# compositor, so without this the next holder inherits Shift.
("modifiers", 0, 0, 0, 0),
]
assert harness.manager.pointer.state()["holder"] is None
assert harness.keys() == []
def test_expiry_lifts_buttons_and_keys_in_one_release_all(harness):
harness.add()
lease = harness.acquire()
harness.run(harness.manager.pointer_button("foot-aaaaaa", lease, "left", "down"))
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Control_L", "down"))
harness.fake.sink.calls.clear()
harness.clock.advance(31.0)
expired = harness.run(harness.manager._expire_pointer())
assert expired["buttons_lifted"] == ["left"]
assert expired["keys_lifted"] == ["Control_L"]
# Buttons first with their frame, then keys, then the mask. One round trip.
assert [c[0] for c in harness.fake.sink.calls] == [
"button",
"frame",
"key",
"modifiers",
]
def test_a_held_key_does_not_leak_to_the_next_holder(harness):
harness.add("foot-aaaaaa")
harness.add("foot-bbbbbb")
lease = harness.acquire("foot-aaaaaa")
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
harness.clock.advance(31.0)
harness.run(harness.manager._expire_pointer())
harness.acquire("foot-bbbbbb")
assert harness.keys() == []
def test_typing_does_not_count_as_activity(harness):
"""`touch` is the only mark of activity, and typing is not it.
Both halves are asserted: the timestamp and the counter. A future change
that moved the timestamp without counting a command would pass a
counter-only test.
"""
session = harness.add()
lease = harness.acquire()
before_at = session.last_activity_at
before_boottime = session.last_activity_boottime
before_count = session.command_count
harness.clock.advance(5.0)
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, "hello"))
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
assert session.last_activity_boottime == before_boottime
assert session.last_activity_at == before_at
assert session.command_count == before_count
# ---------------------------------------------------------------------------
# release, kill, and the audit
# ---------------------------------------------------------------------------
def test_release_lifts_held_keys_and_reports_them(harness):
harness.add()
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
reply = harness.run(harness.manager.pointer_release("foot-aaaaaa", lease))
assert reply["keys_lifted"] == ["Shift_L"]
assert reply["buttons_lifted"] == []
assert harness.manager.pointer_state()["keys"] == []
def test_killing_the_holder_lifts_its_keys(harness):
harness.add()
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Control_L", "down"))
harness.fake.sink.calls.clear()
harness.run(harness.manager._drop_lease_for(harness.manager.registry.get("foot-aaaaaa"), "kill"))
assert ("key", KEY_LEFTCTRL, UP) in harness.fake.sink.calls
assert ("modifiers", 0, 0, 0, 0) in harness.fake.sink.calls
assert harness.manager.pointer.state()["holder"] is None
assert lease # the id is still the one we were given; nothing replayed it
def test_the_audit_records_a_character_count_and_never_the_text(harness):
harness.add()
lease = harness.acquire()
secret = "hunter2"
harness.run(harness.manager.keyboard_type("foot-aaaaaa", lease, secret))
events = harness.manager.audit.tail(50, session="foot-aaaaaa")
typed = [e for e in events if e.get("event") == "keyboard_type"]
assert len(typed) == 1
assert typed[0]["chars"] == len(secret)
assert "text" not in typed[0]
# And not hiding anywhere else in the line either.
assert secret not in str(typed[0])
def test_the_audit_records_a_keysym_name_which_is_not_a_secret(harness):
harness.add()
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Return", "down"))
events = harness.manager.audit.tail(50, session="foot-aaaaaa")
pressed = [e for e in events if e.get("event") == "keyboard_key"]
assert pressed[-1]["key"] == "Return"
assert pressed[-1]["state"] == "down"
def test_the_expiry_audit_event_records_the_keys_it_lifted(harness):
harness.add()
lease = harness.acquire()
harness.run(harness.manager.keyboard_key("foot-aaaaaa", lease, "Shift_L", "down"))
harness.clock.advance(31.0)
harness.run(harness.manager._expire_pointer())
events = harness.manager.audit.tail(50)
timeout = [e for e in events if e.get("event") == "pointer_lease_timeout"][-1]
assert timeout["keys_pressed"] == ["Shift_L"]
assert timeout["keys_lifted"] == ["Shift_L"]
# ---------------------------------------------------------------------------
# acquire takes the keyboard, not only the cursor
# ---------------------------------------------------------------------------
def test_acquire_sends_two_motions_so_keyboard_focus_moves(harness):
"""One warp is not enough, and that is measured, not assumed.
Hyprland zeroes `m_mousePosDelta` when the previous cursor movement was
over 0.5s ago and compares it against `follow_mouse_threshold` (0) to
decide keyboard focus, so a single warp onto an idle cursor delivers
`wl_pointer.enter` and no `wl_keyboard.enter`. The aimed window gets the
cursor and the previously focused one keeps the keys — and then the first
key of the lease goes to the wrong window.
A check that only looked for pointer delivery would pass while that
happened, which is why this asserts the *pair*.
"""
harness.add()
reply = harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
warps = harness.fake.sink.of("warp")
assert len(warps) == 2, "a single warp does not move keyboard focus"
# The second one is the bookmark, so a restore is not a few pixels off.
assert (warps[1][2], warps[1][3]) == (0.5, 0.5)
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.5, 0.5)
# And they are different *floored* pixels at the frozen 1280x720 container
# mode: `mouseMoveUnified` returns before it touches the delta when the
# floored position has not changed.
assert round(warps[0][3] * 720) != round(warps[1][3] * 720)
assert reply["focus"] == "warp"
def test_the_focus_mechanism_is_recorded_in_the_audit(harness):
harness.add()
harness.run(harness.manager.pointer_acquire("foot-aaaaaa"))
events = harness.manager.audit.tail(50, session="foot-aaaaaa")
acquired = [e for e in events if e.get("event") == "pointer_acquired"][-1]
# So a session that ends up typing into the wrong window can be told apart
# from one that never tried to take focus.
assert acquired["focus"] == "warp"