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
755 lines
27 KiB
Python
755 lines
27 KiB
Python
"""The tool table: the argv each tool builds, and what it makes of the answer.
|
|
|
|
The subject is the shim and nothing else. Every test here drives a tool
|
|
through :class:`hhstream_mcp.invoke.Runner` with a recording stand-in
|
|
(:class:`mcp_fake.FakeCli`) where the CLI goes, and asserts on the argv it was
|
|
handed -- which is the only thing this layer actually decides.
|
|
|
|
Nothing in this file imports the MCP SDK: the table is standard library by
|
|
design, so an argv bug is findable without a protocol stack. The SDK wiring is
|
|
``test_mcp_server.py``, and the real CLI entry point is exercised in
|
|
``test_mcp_invoke.py``.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import signal
|
|
|
|
import mcp_fake
|
|
import pytest
|
|
from hhstreamd.protocol import ExitCode
|
|
from hhstream_mcp import invoke, tools
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _isolated(monkeypatch, tmp_path):
|
|
mcp_fake.isolate(monkeypatch, tmp_path)
|
|
|
|
|
|
@pytest.fixture
|
|
def call():
|
|
"""`call("session_touch", {"id": "s-1"})` -> (Result, [argv, ...])."""
|
|
|
|
def _call(name, arguments, **script):
|
|
fake = mcp_fake.FakeCli(**script)
|
|
result = tools.BY_NAME[name].invoke(invoke.Runner(fake), arguments)
|
|
return result, fake.calls
|
|
|
|
return _call
|
|
|
|
|
|
# ── the surface is all there ───────────────────────────────────────────────
|
|
|
|
#: Every tool `docs/CONTRACT-mcp.md` §3 freezes. Written out rather than derived
|
|
#: from the table, because a list derived from the thing it checks cannot
|
|
#: notice a missing entry.
|
|
EXPECTED = {
|
|
# frames -- capturing is an act at a moment, so these stay tools
|
|
"shot", "record", "run",
|
|
# lifecycle. The read-only verbs are resources; see MOVED_TO_RESOURCES.
|
|
"session_start", "session_touch", "session_kill", "session_gc",
|
|
"session_adopt", "session_container", "session_reconcile",
|
|
"session_stream_enable", "session_stream_disable",
|
|
# pointer
|
|
"pointer_acquire", "pointer_move", "pointer_click", "pointer_scroll",
|
|
"pointer_down", "pointer_up", "pointer_release",
|
|
# keyboard
|
|
"keyboard_type", "keyboard_key", "keyboard_down", "keyboard_up",
|
|
}
|
|
|
|
#: Verbs that are resources now and must NOT come back as tools. Named, not
|
|
#: merely absent, so re-adding one is a failure rather than a silent widening
|
|
#: of the surface mcp-v2 narrowed.
|
|
MOVED_TO_RESOURCES = {
|
|
"status",
|
|
"session_list",
|
|
"session_status",
|
|
"session_logs",
|
|
"pointer_state",
|
|
}
|
|
|
|
|
|
def test_the_acting_verbs_are_tools_and_nothing_else_is():
|
|
assert set(tools.BY_NAME) == EXPECTED
|
|
assert len(tools.TOOLS) == 23
|
|
|
|
|
|
def test_the_read_only_verbs_are_not_tools():
|
|
"""They are `hhstream://…` resources: the host's context, not the model's acts."""
|
|
|
|
assert MOVED_TO_RESOURCES.isdisjoint(set(tools.BY_NAME))
|
|
# ...and the table that says where each one went covers exactly those five,
|
|
# so a caller holding a v1 name can be told rather than just refused.
|
|
assert set(tools.MOVED_TO_RESOURCES) == MOVED_TO_RESOURCES
|
|
for uri in tools.MOVED_TO_RESOURCES.values():
|
|
assert uri.startswith("hhstream://")
|
|
|
|
|
|
def test_session_container_stayed_a_tool_because_it_writes():
|
|
"""With an id the CLI runs `container.reconcile`, so it is not a read."""
|
|
|
|
assert "session_container" in tools.BY_NAME
|
|
assert not tools.BY_NAME["session_container"].read_only
|
|
assert "write" in tools.BY_NAME["session_container"].description
|
|
|
|
|
|
def test_the_table_is_ordered_and_has_no_duplicate_names():
|
|
names = [tool.name for tool in tools.TOOLS]
|
|
assert len(names) == len(set(names))
|
|
assert isinstance(tools.TOOLS, tuple)
|
|
|
|
|
|
def test_only_the_verbs_that_read_are_marked_read_only():
|
|
"""One left, now that the rest of the reads are resources."""
|
|
|
|
read_only = {tool.name for tool in tools.TOOLS if tool.read_only}
|
|
assert read_only == {"shot"}
|
|
# `record` writes a file, so it is not read-only either.
|
|
assert not tools.BY_NAME["record"].read_only
|
|
assert tools.BY_NAME["session_kill"].destructive
|
|
# `stream_disable` is destructive too, and for a reason worth naming: it
|
|
# forgets the phrase, so anybody holding the URL loses it.
|
|
assert [t.name for t in tools.TOOLS if t.destructive] == [
|
|
"session_kill",
|
|
"session_stream_disable",
|
|
]
|
|
|
|
|
|
# ── the two rules an agent gets wrong ──────────────────────────────────────
|
|
|
|
#: The tools the CLI's own note names as NOT counting as activity. The others
|
|
#: it names are resources now, and `test_mcp_resources.py` holds those.
|
|
NON_ACTIVITY = {
|
|
"session_gc",
|
|
"session_container",
|
|
"session_reconcile",
|
|
}
|
|
|
|
GESTURES = {
|
|
"pointer_move",
|
|
"pointer_click",
|
|
"pointer_scroll",
|
|
"pointer_down",
|
|
"pointer_up",
|
|
"pointer_release",
|
|
"keyboard_type",
|
|
"keyboard_key",
|
|
"keyboard_down",
|
|
"keyboard_up",
|
|
}
|
|
|
|
#: The four families `--toolsets` selects from.
|
|
FAMILIES = ("frames", "sessions", "pointer", "keyboard")
|
|
|
|
|
|
def test_the_idle_clock_rule_is_on_every_tool_that_does_not_reset_it():
|
|
for name in NON_ACTIVITY | GESTURES | {"session_start", "session_touch", "pointer_acquire"}:
|
|
description = tools.BY_NAME[name].description
|
|
assert tools.ACTIVITY_NOTE in description, f"{name} does not carry the activity rule"
|
|
|
|
|
|
def test_the_idle_clock_rule_names_touch_as_the_only_mark_of_activity():
|
|
assert "`session_touch` is the ONLY thing" in tools.ACTIVITY_NOTE
|
|
# It has to name the *resources* now, because that is where reading moved:
|
|
# an agent told "listing does not count" cannot act on it if the thing it
|
|
# is listing with is no longer called `session_list`.
|
|
for named in ("hhstream://sessions", "session_gc", "pointer or keyboard tool"):
|
|
assert named in tools.ACTIVITY_NOTE
|
|
assert "does NOT count" in tools.ACTIVITY_NOTE
|
|
|
|
|
|
def test_the_cli_still_owns_the_rule_this_wording_restates():
|
|
"""A tripwire, not a duplication.
|
|
|
|
`tools.ACTIVITY_NOTE` and `tools.LEASE_NOTE` are the CLI's two epilogues
|
|
said in terms of tools. If the CLI's constants are renamed or stop saying
|
|
what they say, these notes have silently become this server's own opinion --
|
|
so the originals are asserted to still exist and still carry the rule.
|
|
"""
|
|
|
|
import hhstream_session
|
|
|
|
assert "ONLY" in hhstream_session.ACTIVITY_NOTE
|
|
assert "touch" in hhstream_session.ACTIVITY_NOTE
|
|
assert "no 'keyboard acquire'" in hhstream_session.KEYBOARD_LEASE_NOTE
|
|
|
|
|
|
def test_every_keyboard_tool_says_it_needs_the_pointer_lease():
|
|
for name in ("keyboard_type", "keyboard_key", "keyboard_down", "keyboard_up"):
|
|
description = tools.BY_NAME[name].description
|
|
assert tools.LEASE_NOTE in description, f"{name} does not carry the lease rule"
|
|
assert "POINTER lease" in tools.LEASE_NOTE
|
|
assert "exit 9" in tools.LEASE_NOTE
|
|
assert "`pointer_acquire`" in tools.LEASE_NOTE
|
|
assert "There is no keyboard lease" in tools.LEASE_NOTE
|
|
assert "only while it holds" in tools.LEASE_NOTE
|
|
|
|
|
|
def test_holding_a_non_modifier_is_warned_about_where_it_can_happen():
|
|
assert tools.HOLD_NOTE in tools.BY_NAME["keyboard_down"].description
|
|
assert "FLOODS THE WINDOW" in tools.HOLD_NOTE
|
|
assert "the APPLICATION does the repeating" in tools.HOLD_NOTE
|
|
|
|
|
|
def test_the_lease_is_a_required_argument_on_every_gesture_and_is_never_cached():
|
|
for name in GESTURES:
|
|
schema = tools.BY_NAME[name].schema
|
|
assert "lease" in schema["required"], f"{name} does not require a lease"
|
|
# ...and acquire is the one that hands it out, so it must not require one.
|
|
assert "lease" not in tools.BY_NAME["pointer_acquire"].schema.get("required", [])
|
|
|
|
|
|
# ── toolsets ───────────────────────────────────────────────────────────────
|
|
|
|
|
|
def test_every_tool_is_in_exactly_one_toolset():
|
|
"""Or `--toolsets` would be able to hide a tool nobody could ask for."""
|
|
|
|
assert tuple(tools.TOOLSETS) == FAMILIES
|
|
seen: list[str] = []
|
|
for family in FAMILIES:
|
|
seen.extend(tools.TOOLSETS[family])
|
|
assert len(seen) == len(set(seen)), "a tool is in two toolsets"
|
|
assert set(seen) == set(tools.BY_NAME), "a tool is in no toolset"
|
|
|
|
|
|
def test_no_toolset_named_is_every_tool():
|
|
"""The default, and what an unconfigured client gets."""
|
|
|
|
assert tools.selected(None) == tools.TOOLS
|
|
|
|
|
|
def test_a_selection_keeps_the_table_s_own_order():
|
|
"""So a listing does not reshuffle because of how the flag was written."""
|
|
|
|
chosen = [tool.name for tool in tools.selected(["keyboard", "frames"])]
|
|
assert chosen == ["shot", "record", "run", "keyboard_type", "keyboard_key",
|
|
"keyboard_down", "keyboard_up"]
|
|
|
|
|
|
def test_a_repeated_family_is_not_a_repeated_tool():
|
|
assert tools.selected(["frames", "frames"]) == tools.selected(["frames"])
|
|
|
|
|
|
def test_an_unknown_family_is_refused_and_names_the_known_ones():
|
|
"""Not skipped: a typo that served nothing would look like an empty server."""
|
|
|
|
with pytest.raises(tools.UnknownToolset) as caught:
|
|
tools.selected(["frames", "mouse"])
|
|
assert "'mouse'" in str(caught.value)
|
|
for family in FAMILIES:
|
|
assert family in str(caught.value)
|
|
|
|
|
|
def test_every_schema_refuses_an_argument_this_server_would_drop():
|
|
for tool in tools.TOOLS:
|
|
assert tool.schema["additionalProperties"] is False, tool.name
|
|
assert tool.schema["type"] == "object"
|
|
|
|
|
|
# ── the argv each tool builds ──────────────────────────────────────────────
|
|
|
|
|
|
def test_a_session_verb_is_run_with_json_and_its_id_after_a_separator(call):
|
|
_, calls = call("session_touch", {"id": "s-1"})
|
|
assert calls == [["session", "touch", "--json", "--", "s-1"]]
|
|
|
|
|
|
def test_omitted_arguments_become_no_flag_at_all(call):
|
|
"""A flag left off is the broker's own default; this layer must not supply one."""
|
|
|
|
_, calls = call("session_gc", {})
|
|
assert calls == [["session", "gc", "--json"]]
|
|
_, calls = call("session_gc", {"request_id": "r-1"})
|
|
assert calls == [["session", "gc", "--json", "--request-id=r-1"]]
|
|
_, calls = call("session_reconcile", {})
|
|
assert calls == [["session", "reconcile", "--json"]]
|
|
|
|
|
|
def test_start_passes_the_application_argv_after_one_separator(call):
|
|
_, calls = call(
|
|
"session_start",
|
|
{
|
|
"app": "chromium",
|
|
"argv": ["--new-window", "https://example.invalid"],
|
|
"idle_timeout": "5m",
|
|
"wait_ready": "30s",
|
|
"request_id": "req-7",
|
|
},
|
|
)
|
|
assert calls == [
|
|
[
|
|
"session", "start", "--json",
|
|
"--idle-timeout=5m",
|
|
"--wait-ready=30s",
|
|
"--request-id=req-7",
|
|
"--",
|
|
"chromium",
|
|
"--new-window",
|
|
"https://example.invalid",
|
|
]
|
|
]
|
|
|
|
|
|
def test_an_application_argument_that_looks_like_a_flag_is_not_eaten(call):
|
|
"""The `--` is what makes `--new-window` the application's and not the CLI's."""
|
|
|
|
_, calls = call("session_start", {"app": "foot", "argv": ["--help"]})
|
|
assert calls[0] == ["session", "start", "--json", "--", "foot", "--help"]
|
|
|
|
|
|
def test_an_ephemeral_home_is_a_switch_and_a_home_is_a_value(call):
|
|
_, calls = call("session_start", {"app": "foot", "ephemeral_home": True})
|
|
assert "--ephemeral-home" in calls[0]
|
|
_, calls = call("session_start", {"app": "foot", "home": "/tmp/h"})
|
|
assert "--home=/tmp/h" in calls[0]
|
|
|
|
|
|
def test_a_coordinate_pair_is_sent_in_the_cli_s_own_x_comma_y_form(call):
|
|
_, calls = call("pointer_move", {"id": "s-1", "lease": "L", "to": [0.25, 0.75]})
|
|
assert calls == [["session", "pointer", "move", "--json", "--lease=L", "--to=0.25,0.75", "--", "s-1"]]
|
|
|
|
|
|
def test_a_negative_delta_stays_one_token_so_argparse_cannot_read_it_as_a_flag(call):
|
|
_, calls = call("pointer_move", {"id": "s-1", "lease": "L", "by": [-0.1, 0.5]})
|
|
assert calls[0][5] == "--by=-0.1,0.5"
|
|
|
|
|
|
def test_a_coordinate_is_not_rounded_on_the_way_through(call):
|
|
"""A caller that computed a number deserves the broker's verdict on it."""
|
|
|
|
_, calls = call("pointer_move", {"id": "s-1", "lease": "L", "to": [1 / 3, 0.0]})
|
|
assert calls[0][5] == f"--to={1 / 3!r},0.0"
|
|
|
|
|
|
def test_a_negative_scroll_amount_stays_one_token(call):
|
|
_, calls = call("pointer_scroll", {"id": "s-1", "lease": "L", "amount": -3, "axis": "horizontal"})
|
|
assert calls[0] == [
|
|
"session", "pointer", "scroll", "--json",
|
|
"--lease=L", "--axis=horizontal", "--amount=-3.0", "--", "s-1",
|
|
]
|
|
|
|
|
|
def test_a_typed_string_is_one_positional_after_the_separator(call):
|
|
text = "--not-a-flag\nsecond line\twith a tab"
|
|
_, calls = call("keyboard_type", {"id": "s-1", "lease": "L", "text": text})
|
|
assert calls == [["session", "keyboard", "type", "--json", "--lease=L", "--", "s-1", text]]
|
|
|
|
|
|
def test_a_keysym_name_is_passed_through_untouched(call):
|
|
_, calls = call("keyboard_key", {"id": "s-1", "lease": "L", "name": "BackSpace"})
|
|
assert calls[0][-1] == "BackSpace"
|
|
|
|
|
|
def test_adopt_sends_the_pid_as_a_flag_because_the_cli_requires_it(call):
|
|
_, calls = call("session_adopt", {"pid": 4242, "app": "chromium"})
|
|
assert calls == [["session", "adopt", "--json", "--pid=4242", "--app=chromium"]]
|
|
|
|
|
|
def test_container_with_no_id_lists_and_with_an_id_reconciles(call):
|
|
_, calls = call("session_container", {})
|
|
assert calls == [["session", "container", "--json"]]
|
|
_, calls = call("session_container", {"id": "s-1"})
|
|
assert calls == [["session", "container", "--json", "--", "s-1"]]
|
|
|
|
|
|
# ── what each tool makes of the answer ─────────────────────────────────────
|
|
|
|
|
|
def test_a_successful_session_verb_passes_the_protocol_object_through(call):
|
|
reply = {"ok": True, "pruned": 2, "sessions": [{"id": "s-1"}]}
|
|
result, _ = call("session_gc", {}, stdout=json.dumps(reply, indent=2))
|
|
|
|
assert not result.is_error
|
|
assert result.data == reply
|
|
# The text is the CLI's own stdout: a shim that re-rendered it would be
|
|
# inventing a second format for the same facts.
|
|
assert json.loads(result.text) == reply
|
|
|
|
|
|
def test_acquire_puts_the_lease_id_where_the_next_call_will_look(call):
|
|
reply = {"ok": True, "id": "s-1", "lease_id": "lease-abc", "bookmark": {"output": "hh-s-1"}}
|
|
result, _ = call("pointer_acquire", {"id": "s-1"}, stdout=json.dumps(reply, indent=2))
|
|
|
|
assert result.data == reply
|
|
assert result.text.startswith("lease_id: lease-abc")
|
|
assert "pointer_release" in result.text
|
|
|
|
|
|
def test_start_puts_the_new_session_id_first_and_names_the_idle_clock(call):
|
|
reply = {"ok": True, "id": "s-9", "state": "running"}
|
|
result, _ = call("session_start", {"app": "foot"}, stdout=json.dumps(reply, indent=2))
|
|
|
|
assert result.text.startswith("session id: s-9")
|
|
assert "session_touch" in result.text
|
|
|
|
|
|
def test_a_refusal_is_an_error_and_never_a_success(call):
|
|
reply = {
|
|
"ok": False,
|
|
"error": "no_lease",
|
|
"reason": "no pointer lease for s-1 on this socket",
|
|
"hint": "run 'pointer acquire s-1' first",
|
|
}
|
|
result, _ = call(
|
|
"pointer_click",
|
|
{"id": "s-1", "lease": "stale"},
|
|
stderr=json.dumps(reply, indent=2),
|
|
exit_code=int(ExitCode.NO_LEASE),
|
|
)
|
|
|
|
assert result.is_error
|
|
assert result.data["ok"] is False
|
|
assert result.data["exit_code"] == int(ExitCode.NO_LEASE)
|
|
# The remedy first, then the broker's own words: an agent needs to know what
|
|
# to do before it needs to know what was said.
|
|
assert result.text.startswith("exit 9 (NO_LEASE)")
|
|
assert "pointer_acquire" in result.text
|
|
assert "error: no_lease" in result.text
|
|
assert "no pointer lease for s-1" in result.text
|
|
|
|
|
|
def test_the_contended_lease_case_names_the_holder_and_does_not_say_acquire(call):
|
|
reply = {"ok": False, "error": "pointer_busy", "reason": "held by s-other"}
|
|
result, _ = call(
|
|
"pointer_acquire",
|
|
{"id": "s-1"},
|
|
stderr=json.dumps(reply, indent=2),
|
|
exit_code=int(ExitCode.BUSY),
|
|
)
|
|
|
|
assert result.is_error
|
|
assert result.text.startswith("exit 8 (BUSY)")
|
|
assert "hhstream://pointer" in result.text
|
|
assert "s-other" in result.text
|
|
|
|
|
|
def test_a_usage_refusal_from_argparse_itself_is_still_an_error(call):
|
|
"""Exit 2 with no JSON anywhere -- argparse wrote prose to stderr."""
|
|
|
|
result, _ = call(
|
|
"pointer_click",
|
|
{"id": "s-1", "lease": "L", "button": "left"},
|
|
stderr="usage: hhstream session pointer click ...\nerror: argument --button: invalid choice\n",
|
|
exit_code=int(ExitCode.USAGE),
|
|
)
|
|
|
|
assert result.is_error
|
|
assert result.data["exit_code"] == int(ExitCode.USAGE)
|
|
assert "invalid choice" in result.text
|
|
|
|
|
|
def test_a_broker_that_is_down_is_reported_as_the_operator_s_problem(call):
|
|
result, _ = call(
|
|
"session_gc",
|
|
{},
|
|
stderr="error: cannot reach the hhstream session daemon at /run/hhstream/control.sock\n",
|
|
exit_code=int(ExitCode.DAEMON_UNREACHABLE),
|
|
)
|
|
|
|
assert result.is_error
|
|
assert "HHSTREAM_SOCKET" in result.text
|
|
assert "frame tools" in result.text
|
|
|
|
|
|
# ── the live stream ────────────────────────────────────────────────────────
|
|
|
|
|
|
def test_enabling_a_stream_puts_the_url_where_a_caller_will_look(call):
|
|
reply = {
|
|
"ok": True,
|
|
"id": "s-1",
|
|
"stream": {
|
|
"enabled": True,
|
|
"output": "hh-s-1",
|
|
"fps": 5,
|
|
"attached": True,
|
|
"url": "http://127.0.0.1:9988/amber-otter-lantern-harbor-7k2qp/",
|
|
"viewers": 0,
|
|
},
|
|
}
|
|
result, calls = call(
|
|
"session_stream_enable", {"id": "s-1"}, stdout=json.dumps(reply, indent=2)
|
|
)
|
|
|
|
assert calls == [["session", "stream", "enable", "--json", "--", "s-1"]]
|
|
# The URL on the first line: it is the whole point of the call.
|
|
assert result.text.startswith(reply["stream"]["url"])
|
|
assert result.data == reply
|
|
# ...and the one thing a caller must know about it.
|
|
assert "only thing protecting it" in result.text
|
|
|
|
|
|
def test_enabling_a_stream_passes_a_phrase_and_a_rate_through(call):
|
|
_, calls = call(
|
|
"session_stream_enable",
|
|
{"id": "s-1", "phrase": "amber-otter-lantern-harbor-7k2qp", "fps": 3},
|
|
stdout=mcp_fake.reply(ok=True, id="s-1", stream={"url": "http://x/"}),
|
|
)
|
|
assert calls == [
|
|
[
|
|
"session", "stream", "enable", "--json",
|
|
"--phrase=amber-otter-lantern-harbor-7k2qp",
|
|
"--fps=3",
|
|
"--", "s-1",
|
|
]
|
|
]
|
|
|
|
|
|
def test_an_enable_the_daemon_did_not_confirm_does_not_invent_a_url(call):
|
|
"""A printed URL that serves nothing is worse than saying there is none."""
|
|
|
|
result, _ = call(
|
|
"session_stream_enable",
|
|
{"id": "s-1"},
|
|
stdout=mcp_fake.reply(ok=True, id="s-1", stream={"attached": False}),
|
|
)
|
|
assert "did not confirm" in result.text
|
|
assert "http" not in result.text.split("\n\n")[0]
|
|
|
|
|
|
def test_a_stream_on_a_session_with_no_container_is_exit_ten(call):
|
|
"""It must never fall back to the main output -- that one carries everyone."""
|
|
|
|
result, _ = call(
|
|
"session_stream_enable",
|
|
{"id": "s-1"},
|
|
stderr=mcp_fake.reply(
|
|
ok=False,
|
|
error="stream_unavailable",
|
|
reason="session s-1 has no container output to publish",
|
|
),
|
|
exit_code=int(ExitCode.COMPOSITOR),
|
|
)
|
|
assert result.is_error
|
|
assert result.data["exit_code"] == int(ExitCode.COMPOSITOR)
|
|
assert "not lost" in result.text # the exit-10 remedy: degraded, not dead
|
|
|
|
|
|
def test_a_phrase_that_is_not_this_session_s_is_exit_eight(call):
|
|
result, _ = call(
|
|
"session_stream_enable",
|
|
{"id": "s-1", "phrase": "other-words-go-here-99999"},
|
|
stderr=mcp_fake.reply(ok=False, error="stream_busy", reason="already has a stream"),
|
|
exit_code=int(ExitCode.BUSY),
|
|
)
|
|
assert result.is_error
|
|
assert result.text.startswith("exit 8 (BUSY)")
|
|
|
|
|
|
def test_disabling_a_stream_is_marked_destructive_and_forgets_the_phrase(call):
|
|
_, calls = call(
|
|
"session_stream_disable", {"id": "s-1"}, stdout=mcp_fake.reply(ok=True, detached=True)
|
|
)
|
|
assert calls == [["session", "stream", "disable", "--json", "--", "s-1"]]
|
|
assert tools.BY_NAME["session_stream_disable"].destructive
|
|
assert "forget" in tools.BY_NAME["session_stream_disable"].description
|
|
|
|
|
|
def test_start_can_ask_for_a_stream_and_gets_its_url_back(call):
|
|
"""One call, because a stream needs the container output that start makes."""
|
|
|
|
reply = {
|
|
"ok": True,
|
|
"id": "s-9",
|
|
"stream": {"url": "http://127.0.0.1:9988/amber-otter-lantern-harbor-7k2qp/"},
|
|
}
|
|
result, calls = call(
|
|
"session_start",
|
|
{"app": "chromium", "stream": True, "stream_fps": 4},
|
|
stdout=json.dumps(reply, indent=2),
|
|
)
|
|
assert calls == [
|
|
["session", "start", "--json", "--stream", "--stream-fps=4", "--", "chromium"]
|
|
]
|
|
assert "session id: s-9" in result.text
|
|
assert reply["stream"]["url"] in result.text
|
|
|
|
|
|
def test_a_start_whose_stream_failed_says_so_although_it_succeeded(call):
|
|
"""Exit 0 with a running session; a caller must not read that as a stream."""
|
|
|
|
result, _ = call(
|
|
"session_start",
|
|
{"app": "chromium", "stream": True},
|
|
stdout=mcp_fake.reply(
|
|
ok=True, id="s-9", stream_error="session s-9 has no container output to publish"
|
|
),
|
|
)
|
|
assert not result.is_error
|
|
assert "stream: NOT enabled" in result.text
|
|
assert "session_stream_enable" in result.text
|
|
|
|
|
|
def test_a_start_that_asked_for_no_stream_says_nothing_about_one(call):
|
|
result, calls = call(
|
|
"session_start", {"app": "foot"}, stdout=mcp_fake.reply(ok=True, id="s-1")
|
|
)
|
|
assert "--stream" not in calls[0]
|
|
assert "stream" not in result.text.lower().split("\n\n")[0]
|
|
|
|
|
|
def test_the_stream_note_carries_both_facts_it_exists_for():
|
|
assert "CREDENTIAL" in tools.STREAM_NOTE
|
|
assert "only protection" in tools.STREAM_NOTE
|
|
# The exception to the activity rule has to be where the stream is.
|
|
assert "A CONNECTED VIEWER DOES" in tools.STREAM_NOTE
|
|
assert tools.STREAM_NOTE in tools.BY_NAME["session_stream_enable"].description
|
|
|
|
|
|
# ── shot and record ────────────────────────────────────────────────────────
|
|
|
|
|
|
def test_shot_captures_to_a_file_and_returns_the_bytes_with_the_geometry(call):
|
|
frame = mcp_fake.png(width=320, height=180)
|
|
result, calls = call("shot", {}, write_png=frame, stdout="/tmp/ignored.png\n")
|
|
|
|
assert len(calls) == 1
|
|
verb, out = calls[0][0], calls[0][1]
|
|
assert verb == "shot"
|
|
assert out.startswith("--out=")
|
|
# The temporary directory is gone, so the file cannot be read twice: the
|
|
# bytes are in the reply or they are nowhere.
|
|
assert result.image == frame
|
|
assert result.media_type == "image/png"
|
|
assert "320x180 image/png" in result.text
|
|
assert result.data["width"] == 320
|
|
|
|
|
|
def test_shot_of_one_output_names_it_in_the_argv_and_in_the_reply(call):
|
|
result, calls = call("shot", {"output": "hh-s-1"}, write_png=mcp_fake.png())
|
|
assert "--output=hh-s-1" in calls[0]
|
|
assert "output 'hh-s-1'" in result.text
|
|
assert result.data["output"] == "hh-s-1"
|
|
|
|
|
|
def test_shot_tells_the_truth_about_a_format_it_cannot_read(call):
|
|
result, _ = call("shot", {}, write_png=b"GIF89a-not-an-image")
|
|
|
|
assert not result.is_error
|
|
assert result.image is None
|
|
assert "does not recognise" in result.text
|
|
|
|
|
|
def test_shot_does_not_claim_an_image_when_the_cli_wrote_no_file(call):
|
|
"""Exit 0 and no artefact is still a failure; the alternative is a lie."""
|
|
|
|
result, _ = call("shot", {}, stdout="/tmp/somewhere.png\n")
|
|
|
|
assert result.is_error
|
|
assert result.data["error"] == "no_artifact"
|
|
|
|
|
|
def test_shot_passes_a_refusal_through_without_reading_a_file(call):
|
|
result, _ = call(
|
|
"shot",
|
|
{"output": "hh-gone"},
|
|
stderr="hhstream: could not capture output 'hh-gone': unknown output\n",
|
|
exit_code=1,
|
|
)
|
|
|
|
assert result.is_error
|
|
assert result.image is None
|
|
assert "unknown output" in result.text
|
|
|
|
|
|
def test_record_returns_the_path_and_the_measured_rate_not_the_video(call):
|
|
destination = "/tmp/hhstream-mcp/clip.mp4"
|
|
result, calls = call(
|
|
"record",
|
|
{"seconds": 3, "out": destination},
|
|
stdout=f"{destination} (28 frames in 3.01s -> 9 fps)\n",
|
|
)
|
|
|
|
assert calls[0] == ["record", f"--out={destination}", "--seconds=3"]
|
|
assert result.image is None
|
|
assert result.data == {
|
|
"ok": True,
|
|
"path": destination,
|
|
"frames": 28,
|
|
"seconds": 3.01,
|
|
"fps": 9,
|
|
}
|
|
assert "measured 9 fps" in result.text
|
|
|
|
|
|
def test_record_without_a_destination_generates_one_and_names_it(call):
|
|
result, calls = call("record", {}, stdout="/x (1 frames in 1.00s -> 1 fps)\n")
|
|
flag = next(a for a in calls[0] if a.startswith("--out="))
|
|
assert "hhstream-mcp" in flag
|
|
assert flag.endswith(".mp4")
|
|
assert result.data["ok"] is True
|
|
|
|
|
|
def test_record_of_one_output_passes_the_rate_target_through(call):
|
|
_, calls = call(
|
|
"record",
|
|
{"seconds": 2, "output": "hh-s-1", "fps": 4, "keep": True, "work_dir": "/tmp/w"},
|
|
stdout="/x (8 frames in 2.00s -> 4 fps)\n",
|
|
)
|
|
# The generated --out is asserted by the test above; what matters here is
|
|
# the order and form of everything after it.
|
|
assert calls[0][0] == "record"
|
|
assert calls[0][2:] == [
|
|
"--seconds=2",
|
|
"--output=hh-s-1",
|
|
"--fps=4",
|
|
"--work-dir=/tmp/w",
|
|
"--keep",
|
|
]
|
|
|
|
|
|
# ── run ────────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def test_run_reports_the_application_s_pid_and_that_it_is_unmanaged(wayland):
|
|
result = tools.BY_NAME["run"].invoke(
|
|
invoke.Runner(), {"argv": ["sleep", "30"], "settle_s": 0.3}
|
|
)
|
|
try:
|
|
assert not result.is_error
|
|
assert result.data["managed"] is False
|
|
assert result.data["pid"] > 0
|
|
assert result.data["argv"] == ["sleep", "30"]
|
|
# The tool's own words have to point at the managed alternative, or an
|
|
# agent reaches for `run` because it is the shorter name.
|
|
assert "session_start" in result.text
|
|
assert "UNMANAGED" in result.text
|
|
finally:
|
|
import contextlib
|
|
|
|
with contextlib.suppress(ProcessLookupError):
|
|
os.kill(result.data["pid"], signal.SIGTERM)
|
|
|
|
|
|
def test_run_reports_a_launch_that_failed_immediately_as_an_error(wayland):
|
|
result = tools.BY_NAME["run"].invoke(
|
|
invoke.Runner(),
|
|
{"argv": ["sh", "-c", "echo 'cannot open display' >&2; exit 1"], "settle_s": 5.0},
|
|
)
|
|
|
|
assert result.is_error
|
|
assert result.data["error"] == "run_exited"
|
|
assert "cannot open display" in result.text
|
|
assert "nothing is on" in result.text
|
|
|
|
|
|
@pytest.fixture
|
|
def wayland(workdir, monkeypatch):
|
|
"""A runtime directory the CLI's `env_for_session` accepts.
|
|
|
|
A real AF_UNIX socket, because that function checks `is_socket()`, and the
|
|
suite's short-pathed `workdir` because an AF_UNIX address is capped near
|
|
108 bytes.
|
|
"""
|
|
|
|
import socket
|
|
|
|
listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
listener.bind(str(workdir / "wayland-0"))
|
|
monkeypatch.setenv("HHSTREAM_FRAME_SOCKET", str(workdir / "stream.sock"))
|
|
yield workdir
|
|
listener.close()
|