Wires a `checks` output into the flake, one file per check under checks/, all three asserting docs/CONTRACT.md rather than the implementation: - unit: pytest over tests/unit/ in the build sandbox, against the nix/package.nix build. Refuses an empty suite -- pytest exits 0 when every test was skipped or deselected, so checks/lib/check_report.py parses the JUnit report and fails on zero collected or zero executed. - vm-basic: nixosTest with captureCommand pointed at tests/fake_capture.py, which emits one fixed deterministic PNG. Because the image never changes, "two frames arrived and they are the same bytes" is an assertion about the framing rather than a coincidence. - vm-hyprland: the same machine with no captureCommand override, so grim captures the real compositor. Deliberately impatient -- bounded timeouts, no retry loops, and a full diagnostics dump (compositor log, hyprctl monitors, both journals) before any failure propagates. tests/assert_stream.py is a second, independent reader of the contract: it shares no code with hhstream.client, so a framing bug present in both the server's writer and the shipped client's reader still fails. The unit suite's negative tests use a `rejects` fixture instead of pytest.raises(Exception), which an unimplemented stub's NotImplementedError would otherwise satisfy. Three defects found in code this branch does not own, recorded in README.dev.md rather than worked around: - nix/module.nix has no config side, so neither unit exists and both VM checks fail at their first wait; - services.hyprland-headless-stream.package is declared with no default, against docs/CONTRACT.md; - src/hhstream/*.py is all stubs, so 66 of 70 unit tests fail. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017YXMoCNxzScTaKNr43GQNz
221 lines
6.2 KiB
Python
221 lines
6.2 KiB
Python
"""Shared fixtures for the unit suite.
|
|
|
|
Everything here is standard library. The tests never touch a socket outside
|
|
their own `tmp_path`, never spawn a compositor, and never read the host's
|
|
configuration: the capture backend is a `python3 -c` one-liner and the server is
|
|
driven in-process.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import socket
|
|
import struct
|
|
import sys
|
|
import threading
|
|
import zlib
|
|
|
|
import pytest
|
|
|
|
CONTRACT_SOCKET = "/run/hyprland-headless-stream/stream.sock"
|
|
|
|
# AF_UNIX addresses are capped near 108 bytes; a long tmp_path would fail with a
|
|
# confusing OSError instead of the assertion the test is about.
|
|
SUN_PATH_MAX = 100
|
|
|
|
|
|
def make_png(width: int = 4, height: int = 3, value: int = 0x7F) -> bytes:
|
|
"""A minimal valid truecolour PNG, built with zlib+struct only."""
|
|
|
|
def chunk(kind: bytes, data: bytes) -> bytes:
|
|
return (
|
|
struct.pack(">I", len(data))
|
|
+ kind
|
|
+ data
|
|
+ struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
|
|
)
|
|
|
|
raw = (b"\x00" + bytes([value, value ^ 0x20, value ^ 0x40]) * width) * height
|
|
return (
|
|
b"\x89PNG\r\n\x1a\n"
|
|
+ chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0))
|
|
+ chunk(b"IDAT", zlib.compress(raw, 9))
|
|
+ chunk(b"IEND", b"")
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def tiny_png() -> bytes:
|
|
return make_png()
|
|
|
|
|
|
@pytest.fixture
|
|
def sock_path(tmp_path) -> str:
|
|
"""A short, unused AF_UNIX path inside the test's own directory."""
|
|
path = str(tmp_path / "s.sock")
|
|
if len(path) > SUN_PATH_MAX:
|
|
pytest.skip(f"tmp_path too long for an AF_UNIX socket: {len(path)} bytes")
|
|
return path
|
|
|
|
|
|
@pytest.fixture
|
|
def emit_bytes():
|
|
"""Build an argv that writes exactly `data` to stdout and exits 0."""
|
|
|
|
def build(data: bytes) -> list[str]:
|
|
return [
|
|
sys.executable,
|
|
"-c",
|
|
"import sys;sys.stdout.buffer.write(bytes.fromhex(sys.argv[1]))",
|
|
data.hex(),
|
|
]
|
|
|
|
return build
|
|
|
|
|
|
@pytest.fixture
|
|
def python_argv():
|
|
"""Build an argv running an inline python program with extra arguments."""
|
|
|
|
def build(program: str, *args: str) -> list[str]:
|
|
return [sys.executable, "-c", program, *args]
|
|
|
|
return build
|
|
|
|
|
|
class StubCapture:
|
|
"""A capture backend under the test's control.
|
|
|
|
Satisfies `hhstream.capture.CaptureBackend` structurally: `grab()` and
|
|
`size()`. Counts calls so a test can tell whether the server actually
|
|
captured, and can be told to raise so failure semantics are observable.
|
|
"""
|
|
|
|
def __init__(self, frames=None, size=(1280, 720), raise_first: int = 0):
|
|
self._frames = list(frames) if frames is not None else [make_png()]
|
|
self._size = size
|
|
self._raise_first = raise_first
|
|
self.grabs = 0
|
|
self.lock = threading.Lock()
|
|
|
|
def grab(self) -> bytes:
|
|
with self.lock:
|
|
self.grabs += 1
|
|
n = self.grabs
|
|
if n <= self._raise_first:
|
|
raise RuntimeError(f"stub capture failing on purpose (call {n})")
|
|
return self._frames[(n - 1) % len(self._frames)]
|
|
|
|
def size(self) -> tuple[int, int]:
|
|
return self._size
|
|
|
|
|
|
@pytest.fixture
|
|
def stub_capture():
|
|
return StubCapture
|
|
|
|
|
|
@pytest.fixture
|
|
def connect():
|
|
"""Connect to an AF_UNIX socket, retrying until the server has bound it."""
|
|
|
|
opened: list[socket.socket] = []
|
|
|
|
def _connect(path: str, timeout: float = 10.0, deadline: float = 10.0) -> socket.socket:
|
|
import time
|
|
|
|
end = time.monotonic() + deadline
|
|
last: Exception | None = None
|
|
while time.monotonic() < end:
|
|
try:
|
|
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
s.settimeout(timeout)
|
|
s.connect(path)
|
|
opened.append(s)
|
|
return s
|
|
except OSError as exc:
|
|
last = exc
|
|
s.close()
|
|
time.sleep(0.05)
|
|
raise AssertionError(f"never connected to {path}: {last!r}")
|
|
|
|
yield _connect
|
|
for s in opened:
|
|
try:
|
|
s.close()
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
@pytest.fixture
|
|
def run_bg():
|
|
"""Run a callable on a daemon thread and surface the exception it raised.
|
|
|
|
The server's public surface has no shutdown hook (see README.dev.md), so the
|
|
thread is a daemon and the interpreter is allowed to drop it at exit.
|
|
"""
|
|
|
|
threads: list[tuple[threading.Thread, list]] = []
|
|
|
|
def _run(fn, *args, **kwargs) -> list:
|
|
box: list = []
|
|
|
|
def target():
|
|
try:
|
|
fn(*args, **kwargs)
|
|
except BaseException as exc: # recorded, re-raised by the test
|
|
box.append(exc)
|
|
|
|
t = threading.Thread(target=target, daemon=True)
|
|
t.start()
|
|
threads.append((t, box))
|
|
return box
|
|
|
|
yield _run
|
|
|
|
for t, box in threads:
|
|
t.join(timeout=0.5)
|
|
|
|
|
|
@pytest.fixture
|
|
def socket_mode():
|
|
def _mode(path: str) -> int:
|
|
return os.stat(path).st_mode & 0o7777
|
|
|
|
return _mode
|
|
|
|
|
|
@pytest.fixture(scope="session")
|
|
def rejects():
|
|
"""`pytest.raises`, but a stub does not count as a rejection.
|
|
|
|
docs/CONTRACT.md says which inputs are invalid, not which exception type
|
|
signals it, so these tests cannot pin the type. A bare
|
|
`pytest.raises(Exception)` would then be satisfied by the unimplemented
|
|
stubs' own `NotImplementedError` -- a test that is green precisely because
|
|
nothing is written yet. This refuses that one exception explicitly.
|
|
"""
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def _rejects(*allowed: type[BaseException]):
|
|
expected = allowed or (Exception,)
|
|
try:
|
|
yield
|
|
except NotImplementedError as exc:
|
|
raise AssertionError(
|
|
"the code under test raised NotImplementedError, so it did not "
|
|
f"reject anything: {exc!r}"
|
|
) from exc
|
|
except expected:
|
|
return
|
|
except BaseException as exc:
|
|
raise AssertionError(
|
|
f"expected one of {[e.__name__ for e in expected]}, got {exc!r}"
|
|
) from exc
|
|
raise AssertionError(
|
|
f"expected one of {[e.__name__ for e in expected]}, nothing was raised"
|
|
)
|
|
|
|
return _rejects
|