Files
hyprland-headless-stream-pl…/tests/sessions/unit/test_stream_verbs.py
T
HermenixandClaude Opus 5 b4abd085cc test(stream): both ends of live.sock, the broker's verbs, and a real viewer in a guest
Three layers, because the stream has three and each one can be wrong on its own.

`tests/live/test_live_control.py` (20 tests) runs `Control` against a fake
capture: the four ops, `attach` idempotent on the phrase, the same phrase aimed
at another output refused, a malformed phrase refused *without the value in the
message*, and `fps` defaulting to the daemon's when the broker sends none.

`tests/sessions/unit/test_stream_verbs.py` (24 tests) runs the broker against a
fake daemon, and its subjects are the decisions rather than the plumbing: no
container output is a refusal and never a fallback to the main output; a
re-`enable` returns the same phrase and a different one is exit 8; a down daemon
turns `attached` false rather than failing a read; the sweep touches a watched
session and leaves an unwatched one alone; teardown detaches before the
container is destroyed.

`tests/unit/test_mcp_*` grow the two tools, the two resources and the three
`session_start` arguments, with the read-only half asserted *absent* as a tool
by name -- re-adding one should be a failure, not a silent widening.

`checks/vm-stream.nix` is the new guest check, and it exists for the two things
none of the above can say:

1. **That `grim` captures a real compositor from inside a unit.** It reads
   actual JPEGs off `/<phrase>/stream.mjpg` with `checks/lib/mjpeg_read.py`, a
   hand-rolled multipart reader that shares no code with the server -- a parser
   that did could not tell you the boundary was wrong. It framed on SOI/EOI
   rather than `Content-Length` for the same reason. This is what caught the
   unit's missing `XDG_RUNTIME_DIR`: `frames: [25827, 25827, 25827]` now, ten
   capture failures and a stream that gave up before.
2. **That a connected viewer moves the idle clock.** That needs the broker's
   real sweep, on a real timer, with a client genuinely still there a minute
   later -- hence `--hold`, and hence a check that spends ~90 seconds twice. The
   negative control runs first, because if the sweep touched an unwatched stream
   the positive case would pass for the wrong reason. Measured in the guest:
   with nobody watching `580s -> 502s` remaining, with a viewer `499s -> 596s`.

It also asserts the phrase is in neither the audit log nor a 404 body, that the
old URL stops serving after `disable`, that `disable` then `enable` rotates it,
that `kill` takes the stream down and leaves the daemon up, and that
`start --stream` yields an id and a URL that serves frames.

No clock is injected anywhere in this check. An injected one would prove the
arithmetic, which the unit tests already do, and not the daemon.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011ZeH65zd6pFTgBSu52W9PE
2026-10-11 22:49:18 +00:00

520 lines
19 KiB
Python

"""The stream verbs: the phrase, the record, the teardown order and the sweep.
Both ends are real. The broker end is the manager, its `LiveStreams` client
and its registry; the daemon end is the shipped `Control` and `ControlServer`
over a real ``AF_UNIX`` socket. Only two things are substituted: the clock,
because the viewer sweep's effect on an idle deadline has to be testable
without waiting a minute, and the *capture*, because this machine has no
compositor — a `grim` here would fail for a reason none of these tests are
about.
What that leaves real is everything the feature actually turns on: that a
phrase minted by the broker is one the daemon accepts, that it survives a
re-enable, that a stream is detached before its output is removed, and that a
connected viewer moves the idle clock when nothing else does.
"""
from __future__ import annotations
import asyncio
import contextlib
import socket
import threading
from pathlib import Path
import pytest
from fakes import check_path
from hhstream_live import phrase as phrase_mod
from hhstream_live.control import Control, ControlServer
from hhstream_live.publisher import StreamRegistry
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
#: A JPEG the publisher will accept without a compositor. One pixel, enough
#: for `Stream` to have captured something.
ONE_PIXEL_JPEG = b"\xff\xd8\xff\xd9"
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 FakeCapture:
"""A capture with no compositor. Counts grabs so a test can see one."""
def __init__(self) -> None:
self.grabs = 0
def grab(self) -> bytes:
self.grabs += 1
return ONE_PIXEL_JPEG
class FakeLiveDaemon:
"""The shipped `Control` and protocol loop, with a poll-interval accept.
The accept loop is the one thing not shipped, for `FakeDriver`'s reason:
``serve_forever`` blocks in ``accept()`` by design and closing a listening
socket does not reliably wake a thread already inside it, so a fake that
used it would cost every test the stop timeout.
"""
PORT = 9988
def __init__(self, socket_path: Path) -> None:
check_path(Path(socket_path))
self.registry = StreamRegistry()
self.captures: dict[str, FakeCapture] = {}
self.control = Control(
self.registry,
capture_for=self._capture_for,
url_for=lambda phrase: f"http://127.0.0.1:{self.PORT}/{phrase}/",
)
self.server = ControlServer(Path(socket_path), self.control)
self.server.listen()
self.socket_path = Path(socket_path)
self.connections: list[socket.socket] = []
self._stop = threading.Event()
self._listener = self.server._sock
self._listener.settimeout(0.05)
self._thread = threading.Thread(target=self._serve, daemon=True)
self._thread.start()
def _capture_for(self, output: str) -> FakeCapture:
capture = FakeCapture()
self.captures[output] = capture
return capture
def _serve(self) -> None:
while not self._stop.is_set():
try:
conn, _ = self._listener.accept()
except (TimeoutError, socket.timeout):
continue
except OSError:
return
self.connections.append(conn)
with conn:
self.server._serve_connection(conn)
def watch(self, phrase: str, viewers: int = 1) -> None:
"""Pretend ``viewers`` browsers are connected to ``phrase``."""
stream = self.registry.get(phrase)
assert stream is not None, "nothing is published under that phrase"
for _ in range(viewers):
stream.add_viewer()
def unwatch(self, phrase: str) -> None:
stream = self.registry.get(phrase)
assert stream is not None
while stream.viewers:
stream.remove_viewer()
def outputs(self) -> list[str]:
return [s.spec.output for s in self.registry.all()]
def stop(self) -> None:
"""Stop answering, for real.
Shutting the *accepted* connections down matters and is easy to get
wrong: the broker holds one open between ops, so a stop that only
closed the listener would leave a thread still sitting in `readline`
and still answering `list` -- and the "the daemon is down" tests would
pass against a daemon that was up.
"""
self._stop.set()
for conn in self.connections:
with contextlib.suppress(OSError):
conn.shutdown(socket.SHUT_RDWR)
self._thread.join(timeout=2)
self.registry.stop_all()
self.server.close()
class Harness:
def __init__(self, manager: SessionManager, daemon: FakeLiveDaemon, clock: ManualClock):
self.manager = manager
self.daemon = daemon
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):
daemon = FakeLiveDaemon(short_tmpdir / "live.sock")
clock = ManualClock(boottime=1000.0)
manager = SessionManager(
ManagerConfig(
state_dir=short_tmpdir / "state",
runtime_dir=short_tmpdir / "run",
policy=Policy(),
live_socket=daemon.socket_path,
),
clock=clock,
)
try:
yield Harness(manager, daemon, clock)
finally:
if manager.live is not None:
manager.live.close()
daemon.stop()
# ── enable ─────────────────────────────────────────────────────────────────
def test_enabling_mints_a_phrase_the_daemon_accepts_and_publishes(harness):
harness.add()
reply = harness.run(harness.manager.stream_enable("foot-aaaaaa"))
stream = reply["stream"]
assert stream["enabled"] is True
assert stream["attached"] is True
assert stream["output"] == "hh-foot-aaaaaa"
# The phrase the broker minted is one the daemon's own validator took.
assert phrase_mod.validate(stream["phrase"]) == stream["phrase"]
assert stream["url"].endswith(f"/{stream['phrase']}/")
# ...and the daemon really is publishing that output.
assert harness.daemon.outputs() == ["hh-foot-aaaaaa"]
def test_the_phrase_is_in_the_record_so_it_survives_a_restart(harness):
harness.add()
first = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]
stored = harness.manager.registry.get("foot-aaaaaa").stream
assert stored["phrase"] == first["phrase"]
# And it is on disk, not just in memory: a URL somebody was read out to
# must not change because the broker bounced.
records, broken = harness.manager.registry.load_records()
assert broken == []
on_disk = {record.id: record for record in records}
assert on_disk["foot-aaaaaa"].stream["phrase"] == first["phrase"]
def test_re_enabling_returns_the_same_phrase_and_starts_no_second_capture(harness):
harness.add()
first = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]
again = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]
assert again["phrase"] == first["phrase"]
assert again["url"] == first["url"]
# One stream on the daemon, not two: a re-enable after a restart must not
# double the grim rate on one output.
assert len(harness.daemon.registry.all()) == 1
def test_a_phrase_that_is_not_this_session_s_is_refused_not_rotated(harness):
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
mine = harness.manager.registry.get("foot-aaaaaa").stream["phrase"]
with pytest.raises(ManagerError) as caught:
harness.run(
harness.manager.stream_enable("foot-aaaaaa", phrase=phrase_mod.generate())
)
assert caught.value.error == "stream_busy"
assert exit_code_for(caught.value.error) == ExitCode.BUSY
# The stored one is untouched: somebody may be holding its URL.
assert harness.manager.registry.get("foot-aaaaaa").stream["phrase"] == mine
def test_disable_then_enable_rotates_the_phrase(harness):
harness.add()
first = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]["phrase"]
harness.run(harness.manager.stream_disable("foot-aaaaaa"))
second = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]["phrase"]
assert second != first
assert harness.daemon.registry.get(first) is None
def test_a_caller_s_own_phrase_is_held_to_the_generated_shape(harness):
harness.add()
with pytest.raises(ManagerError) as caught:
harness.run(harness.manager.stream_enable("foot-aaaaaa", phrase="a-b-c"))
assert caught.value.error == "invalid_argument"
assert exit_code_for(caught.value.error) == ExitCode.USAGE
# The refusal must not echo the phrase: this reason is logged.
assert "a-b-c" not in caught.value.reason
def test_a_session_with_no_container_is_refused_and_never_falls_back(harness):
"""The main output carries every other session. This is the one that matters."""
harness.add(container=False)
with pytest.raises(ManagerError) as caught:
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
assert caught.value.error == "stream_unavailable"
assert exit_code_for(caught.value.error) == ExitCode.COMPOSITOR
assert harness.daemon.outputs() == []
def test_a_bad_rate_is_a_usage_error_from_the_broker(harness):
harness.add()
for bad in (0, -1):
with pytest.raises(ManagerError) as caught:
harness.run(harness.manager.stream_enable("foot-aaaaaa", fps=bad))
assert caught.value.error == "invalid_argument"
def test_a_rate_over_the_daemon_s_cap_is_refused_by_the_daemon(harness):
"""The cap belongs to the process that has to keep up with it."""
harness.add()
with pytest.raises(ManagerError) as caught:
harness.run(harness.manager.stream_enable("foot-aaaaaa", fps=1000))
# The daemon's `invalid_argument` kind, mapped to exit 2 by the broker.
assert caught.value.error == "invalid_argument"
assert harness.daemon.outputs() == []
def test_no_daemon_configured_is_unavailable_and_not_a_dead_session(harness, short_tmpdir):
manager = SessionManager(
ManagerConfig(
state_dir=short_tmpdir / "s2",
runtime_dir=short_tmpdir / "r2",
policy=Policy(),
live_socket=short_tmpdir / "nothing-here.sock",
),
clock=ManualClock(boottime=1000.0),
)
manager.registry.add(make_session())
with pytest.raises(ManagerError) as caught:
asyncio.run(manager.stream_enable("foot-aaaaaa"))
assert caught.value.error == "stream_unavailable"
# Exit 10, which the table defines as "the session is NOT lost".
assert exit_code_for(caught.value.error) == ExitCode.COMPOSITOR
assert manager.registry.get("foot-aaaaaa").live
# ── disable ────────────────────────────────────────────────────────────────
def test_disabling_stops_the_capture_and_clears_the_record(harness):
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
reply = harness.run(harness.manager.stream_disable("foot-aaaaaa"))
assert reply["detached"] is True
assert reply["stream"] is None
assert harness.manager.registry.get("foot-aaaaaa").stream is None
assert harness.daemon.outputs() == []
def test_disabling_a_stream_the_daemon_forgot_is_not_an_error(harness):
"""The ordinary case after the daemon restarts; the record still clears."""
harness.add()
stream = harness.run(harness.manager.stream_enable("foot-aaaaaa"))["stream"]
harness.daemon.registry.remove(stream["phrase"]) # as a restart would
reply = harness.run(harness.manager.stream_disable("foot-aaaaaa"))
assert reply["detached"] is False
assert harness.manager.registry.get("foot-aaaaaa").stream is None
def test_disabling_a_session_with_no_stream_says_so(harness):
harness.add()
with pytest.raises(ManagerError) as caught:
harness.run(harness.manager.stream_disable("foot-aaaaaa"))
assert caught.value.error == "stream_unavailable"
# ── reading ────────────────────────────────────────────────────────────────
def test_the_listing_merges_the_daemon_s_view_into_the_records(harness):
harness.add("foot-aaaaaa")
harness.add("foot-bbbbbb")
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
phrase = harness.manager.registry.get("foot-aaaaaa").stream["phrase"]
harness.daemon.watch(phrase, viewers=3)
reply = harness.manager.stream_list()
assert reply["available"] is True
assert [row["id"] for row in reply["streams"]] == ["foot-aaaaaa"]
assert reply["streams"][0]["viewers"] == 3
assert reply["streams"][0]["attached"] is True
def test_a_down_daemon_turns_attached_false_rather_than_failing_the_read(harness):
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
harness.daemon.stop()
reply = harness.manager.stream_list()
assert reply["available"] is False
row = reply["streams"][0]
assert row["attached"] is False
# No stale URL and no stale count: absent is the honest answer.
assert "url" not in row
assert "viewers" not in row
# The phrase is still there, which is what makes a re-enable the same URL.
assert row["phrase"]
def test_status_of_a_session_with_no_stream_is_a_null_not_an_error(harness):
harness.add()
assert harness.manager.stream_status("foot-aaaaaa")["stream"] is None
def test_status_with_no_id_is_the_listing(harness):
harness.add()
assert "streams" in harness.manager.stream_status(None)
# ── the idle clock ─────────────────────────────────────────────────────────
def test_enabling_and_reading_do_not_touch_the_idle_clock(harness):
session = harness.add()
before = session.last_activity_boottime
harness.clock.advance(300.0)
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
harness.manager.stream_list()
harness.manager.stream_status("foot-aaaaaa")
assert harness.manager.registry.get("foot-aaaaaa").last_activity_boottime == before
def test_a_connected_viewer_is_activity_and_moves_the_deadline(harness):
"""The one exception to "`touch` is the only mark of activity"."""
session = harness.add()
before = session.last_activity_boottime
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
phrase = harness.manager.registry.get("foot-aaaaaa").stream["phrase"]
harness.daemon.watch(phrase)
harness.clock.advance(600.0)
touched = harness.run(harness.manager._touch_watched())
assert touched == ["foot-aaaaaa"]
after = harness.manager.registry.get("foot-aaaaaa").last_activity_boottime
assert after == before + 600.0
def test_an_enabled_stream_nobody_watches_keeps_nothing_alive(harness):
"""Otherwise a forgotten `enable` would be an immortal session."""
session = harness.add()
before = session.last_activity_boottime
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
harness.clock.advance(600.0)
assert harness.run(harness.manager._touch_watched()) == []
assert harness.manager.registry.get("foot-aaaaaa").last_activity_boottime == before
def test_the_sweep_touches_only_the_sessions_being_watched(harness):
harness.add("foot-aaaaaa")
harness.add("foot-bbbbbb")
for session_id in ("foot-aaaaaa", "foot-bbbbbb"):
harness.run(harness.manager.stream_enable(session_id))
watched = harness.manager.registry.get("foot-bbbbbb").stream["phrase"]
harness.daemon.watch(watched)
assert harness.run(harness.manager._touch_watched()) == ["foot-bbbbbb"]
def test_the_sweep_survives_a_daemon_that_is_not_there(harness):
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
harness.daemon.stop()
assert harness.run(harness.manager._touch_watched()) == []
def test_the_viewer_audit_entry_never_carries_the_phrase(harness):
"""The audit log is read by whoever can read logs, and this is a password."""
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
phrase = harness.manager.registry.get("foot-aaaaaa").stream["phrase"]
harness.daemon.watch(phrase)
harness.run(harness.manager._touch_watched())
written = (Path(harness.manager.config.state_dir) / "events.jsonl").read_text()
assert "stream_viewer_activity" in written
assert "stream_enable" in written
assert phrase not in written
# ── teardown order ─────────────────────────────────────────────────────────
def test_a_kill_detaches_the_stream_before_removing_the_output(harness):
"""Order is load-bearing: a capture aimed at a removed output fails every
time, and the daemon's failure budget would close the viewers saying
"unknown output" instead of the session simply ending."""
harness.add()
harness.run(harness.manager.stream_enable("foot-aaaaaa"))
order: list[str] = []
real_detach = harness.manager._detach_stream
real_destroy = harness.manager._destroy_container
async def detach(session):
order.append("detach")
return await real_detach(session)
def destroy(session):
order.append("output remove")
return real_destroy(session)
harness.manager._detach_stream = detach
harness.manager._destroy_container = destroy
harness.run(
harness.manager.teardown(
harness.manager.registry.get("foot-aaaaaa"), reason="kill", grace_s=0.1
)
)
assert order == ["detach", "output remove"]
assert harness.daemon.outputs() == []