"""``live.sock``: the four ops, over a real socket, against the shipped client. The server is `hhstream_live.control` and the client is `hhstreamd.live.LiveStreams` — both shipped, talking over a real ``AF_UNIX`` socket, so this is the one place the two halves of CONTRACT-sessions.md §3.5 are read against each other. Only the capture is substituted, because this machine has no compositor. The opposite choice from `tests/assert_stream.py`, and for the stated reason: what is being asserted here is that *this* client reaches *this* daemon, which a second implementation could say nothing about. The *wire format* is held honest separately, by the raw-JSON tests at the bottom that bypass the client entirely. """ from __future__ import annotations import contextlib import json import socket import threading from pathlib import Path import pytest from fake_jpeg import jpeg_bytes from hhstream_live import phrase as phrase_mod from hhstream_live.control import Control, ControlServer from hhstream_live.publisher import FPS_CAP, StreamRegistry from hhstreamd.live import Attachment, LiveRejected, LiveStreams, LiveUnavailable PORT = 9988 class FakeCapture: def grab(self) -> bytes: return jpeg_bytes() class Daemon: """The shipped control server, with a poll-interval accept loop.""" def __init__(self, socket_path: Path) -> None: self.registry = StreamRegistry() self.control = Control( self.registry, capture_for=lambda output: FakeCapture(), url_for=lambda phrase: f"http://127.0.0.1:{PORT}/{phrase}/", ) self.server = ControlServer(socket_path, self.control) self.server.listen() 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 _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 stop(self) -> None: 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() @pytest.fixture def short_tmpdir(): """A directory with a short path. Its own fixture rather than `tmp_path`, and the reason is the same one `tests/sessions/conftest.py` has: an ``AF_UNIX`` address is capped near 108 bytes and pytest's own paths are longer than that. Not imported from there -- these two suites have separate conftests, and a cross-import between them is how the collection collision in this tree started. """ import shutil import tempfile path = tempfile.mkdtemp(prefix="hhs") try: yield Path(path) finally: shutil.rmtree(path, ignore_errors=True) @pytest.fixture def daemon(short_tmpdir: Path): daemon = Daemon(short_tmpdir / "live.sock") try: yield daemon finally: daemon.stop() @pytest.fixture def client(daemon): client = LiveStreams(daemon.server.socket_path) try: yield client finally: client.close() # ── attach ───────────────────────────────────────────────────────────────── def test_attaching_publishes_an_output_and_returns_the_daemon_s_url(client, daemon): phrase = phrase_mod.generate() attachment = client.attach( phrase=phrase, output="hh-x", fps=5, session="x", label="chromium" ) assert isinstance(attachment, Attachment) assert (attachment.output, attachment.fps, attachment.session) == ("hh-x", 5, "x") assert attachment.viewers == 0 # The URL is the DAEMON's: the broker never assembles one, because it does # not own the port. assert attachment.url == f"http://127.0.0.1:{PORT}/{phrase}/" assert daemon.registry.get(phrase) is not None def test_attaching_the_same_phrase_twice_starts_no_second_capture(client, daemon): phrase = phrase_mod.generate() first = client.attach(phrase=phrase, output="hh-x", fps=5, session="x") again = client.attach(phrase=phrase, output="hh-x", fps=5, session="x") assert again.url == first.url assert len(daemon.registry.all()) == 1 def test_the_same_phrase_aimed_somewhere_else_is_refused(client, daemon): """A phrase is a credential for one view; re-pointing it silently would show somebody a desktop they were not given.""" phrase = phrase_mod.generate() client.attach(phrase=phrase, output="hh-x", fps=5) with pytest.raises(LiveRejected) as caught: client.attach(phrase=phrase, output="hh-other", fps=5) assert caught.value.kind == "invalid_argument" assert daemon.registry.get(phrase).spec.output == "hh-x" def test_a_phrase_that_is_not_of_the_shape_is_refused_without_echoing_it(client): """The refusal crosses a socket into the broker's log. It is a password.""" with pytest.raises(LiveRejected) as caught: client.attach(phrase="hunter2", output="hh-x", fps=5) assert caught.value.kind == "invalid_argument" assert "hunter2" not in str(caught.value) def test_a_rate_over_the_cap_is_refused_by_the_process_that_must_keep_up(client): with pytest.raises(LiveRejected) as caught: client.attach(phrase=phrase_mod.generate(), output="hh-x", fps=FPS_CAP + 1) assert caught.value.kind == "invalid_argument" assert str(FPS_CAP) in str(caught.value) @pytest.mark.parametrize("fps", [0, -1]) def test_a_nonsensical_rate_is_refused(client, fps): with pytest.raises(LiveRejected): client.attach(phrase=phrase_mod.generate(), output="hh-x", fps=fps) def test_an_empty_output_is_refused(client): with pytest.raises(LiveRejected) as caught: client.attach(phrase=phrase_mod.generate(), output=" ", fps=5) assert caught.value.kind == "invalid_argument" # ── detach, list, viewers ────────────────────────────────────────────────── def test_detaching_stops_the_capture_and_says_it_did(client, daemon): phrase = phrase_mod.generate() client.attach(phrase=phrase, output="hh-x", fps=5) assert client.detach(phrase) is True assert daemon.registry.get(phrase) is None def test_detaching_something_unattached_is_false_and_not_an_error(client): """`disable` after the daemon restarted is the ordinary case.""" assert client.detach(phrase_mod.generate()) is False def test_listing_returns_every_stream(client): phrases = [phrase_mod.generate() for _ in range(3)] for index, phrase in enumerate(phrases): client.attach(phrase=phrase, output=f"hh-{index}", fps=5, session=f"s-{index}") listed = client.list() assert {a.output for a in listed} == {"hh-0", "hh-1", "hh-2"} assert all(isinstance(a, Attachment) for a in listed) def test_viewers_reports_a_count_per_phrase(client, daemon): phrase = phrase_mod.generate() client.attach(phrase=phrase, output="hh-x", fps=5) assert client.viewers() == {phrase: 0} daemon.registry.get(phrase).add_viewer() daemon.registry.get(phrase).add_viewer() assert client.viewers() == {phrase: 2} def test_an_empty_daemon_lists_nothing_rather_than_failing(client): assert client.list() == [] assert client.viewers() == {} # ── failure ──────────────────────────────────────────────────────────────── def test_a_socket_that_is_not_there_is_unavailable(short_tmpdir: Path): client = LiveStreams(short_tmpdir / "nothing-here.sock") with pytest.raises(LiveUnavailable): client.list() def test_a_daemon_that_went_away_is_unavailable_and_not_a_stale_answer(client, daemon): client.attach(phrase=phrase_mod.generate(), output="hh-x", fps=5) assert client.list() # the connection is now held daemon.stop() with pytest.raises(LiveUnavailable): client.list() def test_the_client_reconnects_after_the_daemon_restarts(short_tmpdir: Path): """The held connection is checked for EOF before each write, as the driver's is -- so a restart costs one reconnect and not a dead client.""" path = short_tmpdir / "live.sock" first = Daemon(path) client = LiveStreams(path) try: client.attach(phrase=phrase_mod.generate(), output="hh-x", fps=5) first.stop() second = Daemon(path) try: # The new daemon knows nothing, which is the point: the client # reached it at all. assert client.list() == [] finally: second.stop() finally: client.close() # ── the wire format itself ───────────────────────────────────────────────── # # These bypass `LiveStreams` on purpose. The tests above prove the two shipped # halves agree with each other; these prove the *format* §3.5 freezes, which a # pair that agreed on something else would also pass. def raw(path: Path, message: dict) -> dict: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock: sock.settimeout(5) sock.connect(str(path)) with sock.makefile("rwb") as stream: stream.write(json.dumps(message).encode() + b"\n") stream.flush() return json.loads(stream.readline()) def test_the_frozen_op_names_and_reply_shape(daemon): path = daemon.server.socket_path phrase = phrase_mod.generate() attached = raw(path, {"op": "attach", "phrase": phrase, "output": "hh-x", "fps": 5}) assert attached["ok"] is True stream = attached["stream"] assert set(stream) >= {"phrase", "output", "fps", "session", "url", "viewers"} assert raw(path, {"op": "list"})["streams"][0]["output"] == "hh-x" assert raw(path, {"op": "viewers"})["viewers"] == {phrase: 0} assert raw(path, {"op": "detach", "phrase": phrase}) == {"ok": True, "detached": True} def test_an_unknown_op_is_refused_with_a_kind(daemon): reply = raw(daemon.server.socket_path, {"op": "levitate"}) assert reply["ok"] is False assert reply["kind"] == "invalid_argument" def test_malformed_json_is_refused_without_closing_the_connection(daemon): path = daemon.server.socket_path with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock: sock.settimeout(5) sock.connect(str(path)) with sock.makefile("rwb") as stream: stream.write(b"{not json\n") stream.flush() first = json.loads(stream.readline()) assert first["ok"] is False # Still answering: one bad line must not cost the broker its # connection, because the next op may be a `detach` in a teardown. stream.write(json.dumps({"op": "list"}).encode() + b"\n") stream.flush() assert json.loads(stream.readline())["ok"] is True def test_a_request_that_is_not_an_object_is_refused(daemon): reply = raw(daemon.server.socket_path, ["attach"]) # type: ignore[arg-type] assert reply["ok"] is False assert reply["kind"] == "invalid_argument"