"""A compositor and a pointer driver that are real sockets and nothing else. Both fakes bind an actual ``AF_UNIX`` listener and speak the real wire format. Nothing here patches :mod:`socket`, :mod:`subprocess` or any method on the code under test: a mock would pass while the things that actually break — a half- closed request, a reply that is prose where JSON was promised, a driver that went away mid-gesture — went untested. This is the same choice ``tests/ipc`` made, for the same reason. What they prove and what they do not: * :class:`FakeCompositor` proves the **wiring** — that the broker sends the plan's commands in the plan's order, parses what comes back and writes the compositor's answer rather than its own intention into the record. It does not prove that Hyprland agrees: it answers ``ok`` because it was asked politely, and the real compositor's behaviour for ``output create headless`` is marked unverified in the plan. Every test here is a test of this broker. * :class:`FakeDriver` runs the **real dispatcher** from :mod:`hhstream_pointer.ops`, behind the **real handler wrapper** from :mod:`hhstream_pointer.__main__` and the **real server** from :mod:`hhstream_pointer.server`, with only the Wayland sink replaced by a recorder. So the protocol, the framing, the driver's own button bookkeeping and — importantly — which backend failures become ``ok: false`` and which kill the connection are the shipped ones; only the compositor is absent. """ from __future__ import annotations import json import socket import threading from pathlib import Path from typing import Any import pytest from hhstream_pointer.__main__ import _handler from hhstream_pointer.ops import Dispatcher from hhstream_pointer.server import PointerServer #: Linux's sun_path is 108 bytes including the NUL. SUN_PATH_MAX = 107 #: The pid the fake gives a window it conjures for a window rule. Fixed, and #: not the session's: the compositor is the authority on what is on screen, and #: a fake that echoed the broker's own pid back could not catch a broker that #: wrote its intention into the record instead of the read-back. WINDOW_PID = 424242 def check_path(path: Path) -> None: if len(str(path).encode()) > SUN_PATH_MAX: pytest.skip(f"socket path too long for AF_UNIX ({len(str(path))} bytes): {path}") class FakeCompositor: """A Hyprland request socket with state: outputs, workspaces and windows. Laid out the way Hyprland lays one out — ``/hypr// .socket.sock`` — so the broker's own discovery finds it, and answering ``j/monitors``, ``j/workspaces``, ``j/clients`` with JSON of the shape ``-j`` produces. It is stateful because the interesting assertions are about state: an ``output create`` has to show up in the next ``monitors``, an ``output remove`` has to make it and its windows disappear, and an orphan scan is only meaningful against a compositor that still has the orphan. """ def __init__(self, runtime_dir: Path, signature: str = "fake_1700000000") -> None: self.runtime_dir = Path(runtime_dir) self.signature = signature self.directory = self.runtime_dir / "hypr" / signature self.directory.mkdir(parents=True, exist_ok=True) self.socket_path = self.directory / ".socket.sock" check_path(self.socket_path) #: Commands received, in order, exactly as they arrived on the wire. self.commands: list[str] = [] #: ``initial_class`` -> ``(workspace, monitor)`` from the window rules. self.rules: dict[str, tuple[int, str]] = {} #: Commands to answer with prose instead of ``ok`` (a refusal). self.refuse: set[str] = set() #: When true, installing an anchored window rule also conjures the #: window it describes — which is what a compositor with a cooperating #: application does, and what the read-back path needs to have happen. self.auto_window = True self._lock = threading.Lock() self._monitors: list[dict[str, Any]] = [ { "id": 0, "name": "HEADLESS-1", "x": 0, "y": 0, "width": 1920, "height": 1080, "scale": 1.0, "activeWorkspace": {"id": 1, "name": "1"}, } ] self._workspaces: list[dict[str, Any]] = [ {"id": 1, "name": "1", "monitor": "HEADLESS-1", "windows": 0} ] self._clients: list[dict[str, Any]] = [] self._next_address = 0x1000 self._stop = threading.Event() self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self._sock.bind(str(self.socket_path)) self._sock.listen(8) self._sock.settimeout(0.05) self._thread = threading.Thread(target=self._serve, daemon=True) self._thread.start() # -- inspection, for the tests --------------------------------------- def outputs(self) -> list[str]: with self._lock: return [m["name"] for m in self._monitors] def workspaces_on(self, output: str) -> list[int]: with self._lock: return [w["id"] for w in self._workspaces if w["monitor"] == output] def windows(self) -> list[str]: with self._lock: return [c["initialClass"] for c in self._clients] def add_output(self, name: str) -> None: """Create an output behind the broker's back — an orphan from a crash.""" with self._lock: self._create_output(name) def add_window( self, initial_class: str, workspace: int, monitor: str, *, pid: int = WINDOW_PID ) -> str: with self._lock: return self._create_window(initial_class, workspace, monitor, pid) def focus(self, output: str, workspace: int) -> None: """Make ``workspace`` the active one on ``output`` (the foreground join).""" with self._lock: for monitor in self._monitors: if monitor["name"] == output: monitor["activeWorkspace"] = {"id": workspace, "name": str(workspace)} def stop(self) -> None: self._stop.set() self._sock.close() self._thread.join(timeout=5.0) # -- the socket ------------------------------------------------------- def _serve(self) -> None: while not self._stop.is_set(): try: conn, _ = self._sock.accept() except (TimeoutError, socket.timeout): continue except OSError: return try: self._handle(conn) finally: conn.close() def _handle(self, conn: socket.socket) -> None: # The client half-closes after writing, so the request ends at EOF. conn.settimeout(5.0) received = b"" while True: try: chunk = conn.recv(4096) except OSError: return if not chunk: break received += chunk text = received.decode("utf-8", errors="replace") flags, separator, command = text.partition("/") if not separator: flags, command = "", text command = command.strip() with self._lock: self.commands.append(command) reply = self._reply(command) try: conn.sendall(reply.encode()) except OSError: pass # -- the command set -------------------------------------------------- def _reply(self, command: str) -> str: if command in self.refuse: return "Invalid command" if command == "version": return "Hyprland 0.56.2 built from branch at commit 0000000\nTag: v0.56.2\n" if command == "monitors": return json.dumps(self._monitors) if command == "workspaces": return json.dumps(self._workspaces) if command == "clients": return json.dumps(self._clients) if command == "cursorpos": return json.dumps({"x": 0, "y": 0}) words = command.split() if words[:3] == ["output", "create", "headless"] and len(words) == 4: self._create_output(words[3]) return "ok" if words[:2] == ["output", "remove"] and len(words) == 3: return "ok" if self._remove_output(words[2]) else f"no such output {words[2]}" if words[:1] == ["keyword"]: return self._keyword(command[len("keyword") :].strip()) return f"unknown request {command!r}" def _keyword(self, rest: str) -> str: name, _, body = rest.partition(" ") if name == "workspace": return self._keyword_workspace(body) if name == "windowrule": return self._keyword_windowrule(body) if name == "monitor": return self._keyword_monitor(body) return f"unknown keyword {name!r}" def _keyword_workspace(self, body: str) -> str: # `, monitor:, default:true, persistent:true` parts = [p.strip() for p in body.split(",")] slot = int(parts[0]) monitor = next((p.split(":", 1)[1] for p in parts if p.startswith("monitor:")), None) if monitor is None: return "workspace rule has no monitor" if not any(w["id"] == slot for w in self._workspaces): self._workspaces.append( {"id": slot, "name": str(slot), "monitor": monitor, "windows": 0} ) return "ok" def _keyword_windowrule(self, body: str) -> str: # `match:initial_class ^hh-x$, workspace 1000, monitor hh-x` parts = [p.strip() for p in body.split(",")] match = parts[0] if not match.startswith("match:initial_class "): return "unsupported rule" pattern = match[len("match:initial_class ") :] workspace = next((p[len("workspace ") :] for p in parts if p.startswith("workspace ")), None) monitor = next((p[len("monitor ") :] for p in parts if p.startswith("monitor ")), None) if pattern == ".*" or monitor is None or workspace is None: # The quarantine backstop: recorded so a test can assert it was # installed, and first, but it conjures nothing. self.rules[pattern] = (0, workspace or "") return "ok" initial_class = pattern.strip("^$") self.rules[initial_class] = (int(workspace), monitor) if self.auto_window: self._create_window(initial_class, int(workspace), monitor, WINDOW_PID) return "ok" def _keyword_monitor(self, body: str) -> str: # `,x,auto,1` parts = body.split(",") name = parts[0] width, _, height = parts[1].partition("x") for monitor in self._monitors: if monitor["name"] == name: monitor["width"] = int(width) monitor["height"] = int(height) return "ok" return f"no such monitor {name}" # -- state ------------------------------------------------------------ def _create_output(self, name: str) -> None: if any(m["name"] == name for m in self._monitors): return self._monitors.append( { "id": len(self._monitors), "name": name, "x": 1920 * len(self._monitors), "y": 0, "width": 1280, "height": 720, "scale": 1.0, "activeWorkspace": None, } ) def _remove_output(self, name: str) -> bool: before = len(self._monitors) self._monitors = [m for m in self._monitors if m["name"] != name] if len(self._monitors) == before: return False gone = {w["id"] for w in self._workspaces if w["monitor"] == name} self._workspaces = [w for w in self._workspaces if w["monitor"] != name] # Hyprland destroys a window with its surface; the fake destroys the # ones that were on the output's workspaces, which is the behaviour the # teardown cross-check is written against. self._clients = [c for c in self._clients if c["workspace"]["id"] not in gone] return True def _create_window(self, initial_class: str, workspace: int, monitor: str, pid: int) -> str: self._next_address += 0x10 address = hex(self._next_address) self._clients.append( { "address": address, "mapped": True, "hidden": False, "at": [0, 0], "size": [1280, 720], "workspace": {"id": workspace, "name": str(workspace)}, "monitor": next( (m["id"] for m in self._monitors if m["name"] == monitor), 0 ), "class": initial_class, "initialClass": initial_class, "title": "a window, with a comma in its title", "pid": pid, } ) for entry in self._workspaces: if entry["id"] == workspace: entry["windows"] += 1 # A window that maps makes its workspace the active one on its output, # which is what the `foreground` join reads. for entry in self._monitors: if entry["name"] == monitor: entry["activeWorkspace"] = {"id": workspace, "name": str(workspace)} return address class RecordingSink: """A :class:`hhstream_pointer.ops.PointerSink` that writes nothing anywhere.""" def __init__(self) -> None: self.calls: list[tuple] = [] #: An exception to raise from the next call. The shipped driver #: answers an ``OutputUnknown`` on the wire and lets anything else #: take the connection down, so which one is raised here decides which #: of the broker's two failure paths is being tested. self.fail: Exception | None = None def motion_absolute(self, output: str, x: float, y: float) -> None: self._check() self.calls.append(("warp", output, round(x, 6), round(y, 6))) def button(self, output: str, code: int, state: int) -> None: self._check() self.calls.append(("button", output, code, state)) def frame(self, output: str) -> None: self._check() self.calls.append(("frame", output)) def _check(self) -> None: if self.fail is not None: raise self.fail def of(self, kind: str) -> list[tuple]: return [c for c in self.calls if c[0] == kind] class FakeDriver: """The shipped driver with its Wayland sink replaced by a recorder. The dispatcher, the handler wrapper and the per-connection protocol loop are the shipped ones. The **accept loop** is not: ``serve_forever`` blocks in ``accept()`` for ever 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. Four lines with a poll interval replace it; everything a test is actually asserting about still runs the real code. """ def __init__(self, socket_path: Path) -> None: check_path(Path(socket_path)) self.socket_path = Path(socket_path) self.sink = RecordingSink() self.dispatcher = Dispatcher(self.sink) self.server = PointerServer(self.socket_path, _handler(self.dispatcher)) 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 conn.settimeout(None) self.connections.append(conn) try: self.server._serve_connection(conn) except Exception: # The shipped `main` lets a backend failure out of the serve # loop and exits with code 10 — a driver talking to a dead # display has nothing useful left to say. The fake ends its # thread for the same reason, so the broker sees the same # thing: a connection that closed without answering. return finally: conn.close() def stop(self) -> None: """Stop the way a killed process stops: listener *and* connections. The shipped driver never has to do this — the kernel closes its fds when it exits — but a fake that left the broker's held connection open would not look like a driver that restarted, which is one of the things the client has to get right. """ self._stop.set() for conn in self.connections: try: conn.shutdown(socket.SHUT_RDWR) except OSError: pass conn.close() self._thread.join(timeout=5.0) self.server.close()