Files
hyprland-headless-stream-pl…/tests/unit/test_protocol.py
T
HermenixandClaude Opus 5 75a05cd72f tests: checks.{unit,vm-basic,vm-hyprland} + the harness behind them
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
2026-09-28 05:25:37 +00:00

170 lines
5.2 KiB
Python

"""Framing, byte for byte, against docs/CONTRACT.md.
The contract is unusually specific about the length prefix ("plain ASCII digits;
no leading zeros, no `+`, no spaces"), so these tests assert on exact bytes
rather than on round-trips alone -- a reader and writer that agree with each
other but not with the document would pass a round-trip test.
"""
from __future__ import annotations
import io
import json
import pytest
from hhstream import protocol
# -- Hello ----------------------------------------------------------------
def test_hello_is_one_json_line():
line = protocol.hello(1280, 720, "image/png", 30)
assert isinstance(line, bytes)
assert line.endswith(b"\n")
assert line.count(b"\n") == 1, "the Hello is exactly one line"
def test_hello_fields_match_the_contract():
obj = json.loads(protocol.hello(1280, 720, "image/png", 30).decode("utf-8"))
assert obj["magic"] == "HHS1"
assert obj["width"] == 1280
assert obj["height"] == 720
assert obj["format"] == "image/png"
assert obj["fps"] == 30
def test_hello_carries_the_jpeg_format_too():
obj = json.loads(protocol.hello(640, 480, "image/jpeg", 15).decode("utf-8"))
assert obj["format"] == "image/jpeg"
def test_hello_round_trips_through_parse_hello():
obj = protocol.parse_hello(protocol.hello(1920, 1080, "image/png", 60))
assert obj["magic"] == "HHS1"
assert (obj["width"], obj["height"]) == (1920, 1080)
assert obj["fps"] == 60
def test_parse_hello_tolerates_the_trailing_newline_or_not():
line = protocol.hello(800, 600, "image/png", 24)
assert protocol.parse_hello(line) == protocol.parse_hello(line.rstrip(b"\n"))
def test_parse_hello_rejects_a_foreign_magic(rejects):
bad = json.dumps(
{"magic": "HHS0", "width": 1, "height": 1, "format": "image/png", "fps": 1}
).encode()
with rejects():
protocol.parse_hello(bad)
@pytest.mark.parametrize("missing", ["width", "height", "format", "fps"])
def test_parse_hello_rejects_a_missing_field(missing, rejects):
obj = {
"magic": "HHS1",
"width": 1280,
"height": 720,
"format": "image/png",
"fps": 30,
}
del obj[missing]
with rejects():
protocol.parse_hello(json.dumps(obj).encode())
@pytest.mark.parametrize("junk", [b"", b"not json", b"[]", b"null", b'{"magic":"HHS1"'])
def test_parse_hello_rejects_junk(junk, rejects):
with rejects():
protocol.parse_hello(junk)
# -- frames ---------------------------------------------------------------
def test_frame_prefixes_the_payload_length_in_ascii():
assert protocol.frame(b"hello") == b"5\n" + b"hello"
def test_frame_length_counts_the_payload_only():
payload = b"\x00" * 1234
framed = protocol.frame(payload)
prefix, _, body = framed.partition(b"\n")
assert prefix == b"1234"
assert int(prefix) == len(payload) == len(body)
def test_frame_length_has_no_leading_zeros_sign_or_spaces():
for n in (1, 7, 10, 99, 100, 65536):
prefix = protocol.frame(b"x" * n).split(b"\n", 1)[0]
assert prefix == str(n).encode()
assert not prefix.startswith(b"0")
assert not prefix.startswith(b"+")
assert b" " not in prefix
def test_frame_is_binary_safe():
payload = bytes(range(256)) + b"\n42\n" + b"\xff\xfe"
framed = protocol.frame(payload)
assert framed == str(len(payload)).encode() + b"\n" + payload
def test_read_frame_round_trips():
payload = bytes(range(256)) * 8
assert protocol.read_frame(io.BytesIO(protocol.frame(payload))) == payload
def test_read_frame_reads_exactly_one_frame_and_stops():
stream = io.BytesIO(protocol.frame(b"aaa") + protocol.frame(b"bbbb"))
assert protocol.read_frame(stream) == b"aaa"
assert protocol.read_frame(stream) == b"bbbb"
assert protocol.read_frame(stream) is None
def test_read_frame_returns_none_on_a_clean_eof():
assert protocol.read_frame(io.BytesIO(b"")) is None
def test_read_frame_raises_on_a_truncated_payload(rejects):
with rejects(EOFError):
protocol.read_frame(io.BytesIO(b"10\nshort"))
@pytest.mark.parametrize(
"bad",
[
b"007\n0000000", # leading zeros
b"+5\nhello", # sign
b" 5\nhello", # leading space
b"5 \nhello", # trailing space
b"abc\nhello", # not a number
b"-1\n", # negative
b"1_0\nxxxxxxxxxx", # python's int() accepts this; the contract does not
],
)
def test_read_frame_rejects_a_malformed_length_prefix(bad, rejects):
with rejects(ValueError):
protocol.read_frame(io.BytesIO(bad))
def test_read_frame_handles_a_megabyte_payload():
payload = bytes(range(256)) * 4096
assert len(payload) == 1024 * 1024
assert protocol.read_frame(io.BytesIO(protocol.frame(payload))) == payload
def test_read_hello_then_frames_is_the_contract_sequence():
wire = (
protocol.hello(1280, 720, "image/png", 30)
+ protocol.frame(b"one")
+ protocol.frame(b"two")
)
stream = io.BytesIO(wire)
hello = protocol.read_hello(stream)
assert hello["magic"] == "HHS1"
assert (hello["width"], hello["height"]) == (1280, 720)
assert protocol.read_frame(stream) == b"one"
assert protocol.read_frame(stream) == b"two"
assert protocol.read_frame(stream) is None