mirrors/hermes-agent
1
0
Fork 0
mirror of https://github.com/NousResearch/hermes-agent.git synced 2026-07-31 19:16:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

test: prune wave 2 + speed fixes — 28,106 → 19,757 test functions, suite wall 315s → 294s

Browse source 
Second, deeper pass over tools/gateway/hermes_cli plus first pass over
the trees wave 1 missed (acp, acp_adapter, skills, computer_use, docker,
dashboard, conformance, monitoring, secret_sources, hermes_state,
providers). Same rubric as wave 1 (AGENTS.md test policy); security,
alternation/caching invariants, issue-number regressions, and E2E kept.

Real test-quality fixes found and rooted out along the way:
- tests/tools/test_command_guards.py made real auxiliary-LLM HTTPS calls
  (DEFAULT_CONFIG smart-approval leaked in) — pinned approval
  mode=manual via autouse fixture: 17.4s → 0.4s.
- test_model_switch_custom_providers.py / test_user_providers_model_switch.py
  silently probed live provider catalogs (~2s/test) — stubbed
  cached_provider_model_ids/provider_model_ids/fetch_api_models.
- test_telegram_noise_filter.py: 15-platform copy-paste matrix over
  shared gateway.run logic → 3 representative platforms (55s → 3.9s).
- test_gateway_shutdown.py: stop()'s 5s interrupt-deadline loop spun on
  MagicMock agents — interrupt.side_effect now clears _running_agents
  (22s → 1.0s).
- test_gateway_inactivity_timeout.py poll-harness timings shrunk 3-5x
  (24s → 1.1s); test_mcp_stability.py backoff/SIGTERM-grace sleeps
  patched (15.4s → 2.5s); test_async_delegation.py negative-drain wait
  5s → 0.5s.
- test_telegram_init_deadline.py: loop-block margin restored to 1.0s
  with rationale comment — the watchdog-dump assertion needs the loop
  blocked well past deadline+grace under parallel load (flaked once in
  the 40-worker verification run at a 0.2s margin).

Verification: full hermetic suite via scripts/run_tests.sh —
2,438 files, 21,718 tests passed, 0 failed, 293.9s wall.
Suite totals vs original baseline: 46,820 → 19,757 test functions
(−57.8%), wall 583.5s → 293.9s (−50%), subprocess CPU 13,564s → 11,623s.
This commit is contained in:
Teknium 2026-07-29 13:39:40 -07:00
parent 6b81590c55
commit 39975613b1
No known key found for this signature in database
1172 changed files with 116 additions and 124604 deletions
Download patch file Download diff file Expand all files Collapse all files

115
tests/acp/test_approval_isolation.py
View file

@ -117,27 +117,6 @@ class TestThreadLocalApprovalCallback:
# Main thread still has its callback
assert _get_approval_callback() is cb_main
def test_sudo_password_callback_also_thread_local(self):
"""Same protection applies to the sudo password callback."""
from tools.terminal_tool import (
set_sudo_password_callback,
_get_sudo_password_callback,
)
cb_main = lambda: "main-password" # noqa: E731
set_sudo_password_callback(cb_main)
worker_saw = []
def worker():
worker_saw.append(_get_sudo_password_callback())
t = threading.Thread(target=worker)
t.start()
t.join()
assert worker_saw == [None]
assert _get_sudo_password_callback() is cb_main
def test_sudo_password_cache_does_not_leak_across_threads(self):
"""Interactive sudo cache must not bleed into another executor thread."""
@ -162,58 +141,6 @@ class TestThreadLocalApprovalCallback:
assert worker_saw == [""]
assert _get_cached_sudo_password() == "main-thread-password"
def test_sudo_password_cache_isolated_across_acp_sessions_on_same_pool_thread(self):
"""ACP's ThreadPoolExecutor reuses threads. Two ACP sessions that land
on the same reused thread must not share the interactive sudo password
cache. The fix wraps each session in contextvars.copy_context() and
binds HERMES_SESSION_KEY per session, so the cache scope key differs
across sessions even when the underlying thread is identical.
"""
import contextvars
from concurrent.futures import ThreadPoolExecutor
from gateway.session_context import (
clear_session_vars,
set_session_vars,
)
from tools.terminal_tool import (
_get_cached_sudo_password,
_reset_cached_sudo_passwords,
_set_cached_sudo_password,
)
_reset_cached_sudo_passwords()
executor = ThreadPoolExecutor(max_workers=1) # force thread reuse
runs: list[tuple[str, str, str]] = [] # (session_id, before, after)
def _simulate_acp_session(session_id: str, write_password: str) -> None:
tokens = set_session_vars(session_key=session_id)
try:
observed_before = _get_cached_sudo_password()
_set_cached_sudo_password(write_password)
observed_after = _get_cached_sudo_password()
runs.append((session_id, observed_before, observed_after))
finally:
clear_session_vars(tokens)
def _run_in_fresh_context(session_id: str, pw: str) -> str:
ctx = contextvars.copy_context()
ctx.run(_simulate_acp_session, session_id, pw)
return session_id
try:
executor.submit(_run_in_fresh_context, "acp-session-A", "alpha-secret").result()
# Same thread. Without the fix B would see "alpha-secret".
executor.submit(_run_in_fresh_context, "acp-session-B", "bravo-secret").result()
finally:
executor.shutdown(wait=True)
_reset_cached_sudo_passwords()
assert runs[0] == ("acp-session-A", "", "alpha-secret")
# Core regression guard: B on the same reused thread must see an empty
# cache, not A's password.
assert runs[1] == ("acp-session-B", "", "bravo-secret")
class TestAcpExecAskGate:
@ -266,45 +193,3 @@ class TestAcpExecAskGate:
)
assert result["approved"] is True
def test_interactive_context_var_routes_to_callback_without_env(
self, monkeypatch,
):
"""Context-local interactive flag must work without touching os.environ.
Concurrent ACP sessions run on a shared ThreadPoolExecutor, so the
interactive flag is now a contextvar instead of a process-global env
var — one session can no longer clobber another's flag mid-run
(GHSA-96vc-wcxf-jjff).
"""
monkeypatch.delenv("HERMES_INTERACTIVE", raising=False)
monkeypatch.delenv("HERMES_GATEWAY_SESSION", raising=False)
monkeypatch.delenv("HERMES_EXEC_ASK", raising=False)
monkeypatch.delenv("HERMES_YOLO_MODE", raising=False)
from tools.approval import (
check_all_command_guards,
reset_hermes_interactive_context,
set_hermes_interactive_context,
)
called_with = []
def fake_cb(command, description, *, allow_permanent=True):
called_with.append((command, description))
return "once"
tok = set_hermes_interactive_context(True)
try:
result = check_all_command_guards(
"rm -rf /tmp/test-context-interactive",
"local",
approval_callback=fake_cb,
)
finally:
reset_hermes_interactive_context(tok)
assert called_with, (
"set_hermes_interactive_context(True) should route dangerous "
"commands through the callback without HERMES_INTERACTIVE in env"
)
assert result["approved"] is True

54
tests/acp/test_auth.py
View file

@ -16,19 +16,7 @@ class TestHasProvider:
)
assert has_provider() is True
def test_has_no_provider_when_runtime_has_no_key(self, monkeypatch):
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
lambda: {"provider": "openrouter", "api_key": ""},
)
assert has_provider() is False
def test_has_no_provider_when_runtime_resolution_fails(self, monkeypatch):
def _boom():
raise RuntimeError("no provider")
monkeypatch.setattr("hermes_cli.runtime_provider.resolve_runtime_provider", _boom)
assert has_provider() is False
class TestDetectProvider:
@ -39,33 +27,9 @@ class TestDetectProvider:
)
assert detect_provider() == "openrouter"
def test_detect_anthropic(self, monkeypatch):
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
lambda: {"provider": "anthropic", "api_key": "sk-ant-test"},
)
assert detect_provider() == "anthropic"
def test_detect_none_when_no_key(self, monkeypatch):
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
lambda: {"provider": "kimi-coding", "api_key": ""},
)
assert detect_provider() is None
def test_detect_none_on_resolution_error(self, monkeypatch):
def _boom():
raise RuntimeError("broken")
monkeypatch.setattr("hermes_cli.runtime_provider.resolve_runtime_provider", _boom)
assert detect_provider() is None
def test_detect_provider_strips_and_lowercases_provider(self, monkeypatch):
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
lambda: {"provider": " OpenRouter ", "api_key": " sk-or-test "},
)
assert detect_provider() == "openrouter"
class TestBuildAuthMethods:
@ -82,21 +46,3 @@ class TestBuildAuthMethods:
assert terminal["type"] == "terminal"
assert terminal["args"] == ["--setup"]
def test_build_auth_methods_returns_terminal_setup_when_unconfigured(self, monkeypatch):
monkeypatch.setattr("acp_adapter.auth.detect_provider", lambda: None)
methods = build_auth_methods()
payloads = [method.model_dump(by_alias=True, exclude_none=True) for method in methods]
assert payloads == [
{
"args": ["--setup"],
"description": (
"Open Hermes' interactive model/provider setup in a terminal. "
"Use this when Hermes has not been configured on this machine yet."
),
"id": TERMINAL_SETUP_AUTH_METHOD_ID,
"name": "Configure Hermes provider",
"type": "terminal",
}
]

145
tests/acp/test_edit_approval.py
View file

@ -41,72 +41,10 @@ def test_acp_permission_tool_call_uses_edit_kind_and_diff_content():
assert diff.newText == "new\n"
def test_write_file_rejection_does_not_mutate_existing_file(tmp_path):
target = tmp_path / "sample.txt"
target.write_text("before\n", encoding="utf-8")
set_edit_approval_requester(lambda _proposal: False)
result = json.loads(
handle_function_call(
"write_file",
{"path": str(target), "content": "after\n"},
task_id="acp-edit-reject",
)
)
assert "error" in result
assert "Edit approval denied" in result["error"]
assert target.read_text(encoding="utf-8") == "before\n"
def test_write_file_approval_mutates_and_request_includes_diff(tmp_path):
target = tmp_path / "sample.txt"
target.write_text("before\n", encoding="utf-8")
proposals = []
def approve(proposal):
proposals.append(proposal)
return True
set_edit_approval_requester(approve)
result = json.loads(
handle_function_call(
"write_file",
{"path": str(target), "content": "after\n"},
task_id="acp-edit-approve",
)
)
assert result.get("bytes_written") == len("after\n")
assert target.read_text(encoding="utf-8") == "after\n"
assert len(proposals) == 1
proposal = proposals[0]
assert proposal.tool_name == "write_file"
assert proposal.path == str(target)
assert proposal.old_text == "before\n"
assert proposal.new_text == "after\n"
def test_write_file_new_file_request_has_empty_old_text(tmp_path):
target = tmp_path / "new.txt"
proposals = []
set_edit_approval_requester(lambda proposal: proposals.append(proposal) or True)
result = json.loads(
handle_function_call(
"write_file",
{"path": str(target), "content": "created\n"},
task_id="acp-edit-new-file",
)
)
assert result.get("bytes_written") == len("created\n")
assert target.read_text(encoding="utf-8") == "created\n"
assert proposals[0].old_text is None
assert proposals[0].new_text == "created\n"
def test_requester_exception_denies_and_does_not_mutate(tmp_path):
@ -155,93 +93,10 @@ def test_patch_replace_rejection_does_not_mutate(tmp_path):
assert target.read_text(encoding="utf-8") == "alpha\nbeta\n"
def test_patch_v4a_rejection_does_not_mutate(tmp_path):
target = tmp_path / "sample.txt"
target.write_text("alpha\nbeta\n", encoding="utf-8")
set_edit_approval_requester(lambda _proposal: False)
result = json.loads(
handle_function_call(
"patch",
{
"mode": "patch",
"patch": (
"*** Begin Patch\n"
f"*** Update File: {target}\n"
"@@\n"
" alpha\n"
"-beta\n"
"+gamma\n"
"*** End Patch\n"
),
},
task_id="acp-patch-v4a-reject",
)
)
assert "error" in result
assert "Edit approval denied" in result["error"]
assert target.read_text(encoding="utf-8") == "alpha\nbeta\n"
def test_patch_v4a_approval_request_includes_patch_targets(tmp_path):
target = tmp_path / "sample.txt"
target.write_text("alpha\nbeta\n", encoding="utf-8")
proposals = []
set_edit_approval_requester(lambda proposal: proposals.append(proposal) or False)
json.loads(
handle_function_call(
"patch",
{
"mode": "patch",
"patch": (
"*** Begin Patch\n"
f"*** Update File: {target}\n"
"@@\n"
" alpha\n"
"-beta\n"
"+gamma\n"
"*** End Patch\n"
),
},
task_id="acp-patch-v4a-proposal",
)
)
assert len(proposals) == 1
assert proposals[0].tool_name == "patch"
assert proposals[0].path == str(target)
assert str(target) in proposals[0].new_text
def test_patch_replace_approval_request_includes_full_file_diff(tmp_path):
target = tmp_path / "sample.txt"
target.write_text("alpha\nbeta\n", encoding="utf-8")
proposals = []
set_edit_approval_requester(lambda proposal: proposals.append(proposal) or True)
result = json.loads(
handle_function_call(
"patch",
{
"mode": "replace",
"path": str(target),
"old_string": "beta\n",
"new_string": "gamma\n",
},
task_id="acp-patch-approve",
)
)
assert result.get("success") is True
assert target.read_text(encoding="utf-8") == "alpha\ngamma\n"
assert proposals[0].tool_name == "patch"
assert proposals[0].old_text == "alpha\nbeta\n"
assert proposals[0].new_text == "alpha\ngamma\n"
def test_workspace_auto_approval_allows_workspace_and_tmp_but_not_sensitive(tmp_path):

109
tests/acp/test_entry.py
View file

@ -43,63 +43,12 @@ def test_main_skips_configured_mcp_discovery_when_requested(monkeypatch):
assert discovery_calls == []
@pytest.mark.parametrize("skip_value", [None, "", "0", "false"])
def test_main_discovers_configured_mcp_when_skip_is_not_enabled(monkeypatch, skip_value):
discovery_calls = []
async def fake_run_agent(agent, **kwargs):
pass
monkeypatch.setattr(entry, "_setup_logging", lambda: None)
monkeypatch.setattr(entry, "_load_env", lambda: None)
if skip_value is None:
monkeypatch.delenv("HERMES_ACP_SKIP_CONFIGURED_MCP", raising=False)
else:
monkeypatch.setenv("HERMES_ACP_SKIP_CONFIGURED_MCP", skip_value)
monkeypatch.setattr(
"tools.mcp_tool.discover_mcp_tools",
lambda: discovery_calls.append(True),
)
monkeypatch.setattr(acp, "run_agent", fake_run_agent)
entry.main([])
assert discovery_calls == [True]
def test_main_version_prints_without_starting_server(monkeypatch, capsys):
monkeypatch.setattr(entry, "_setup_logging", lambda: (_ for _ in ()).throw(AssertionError("started server")))
entry.main(["--version"])
output = capsys.readouterr().out.strip()
assert output
assert "Starting hermes-agent ACP adapter" not in output
def test_main_check_prints_ok_without_starting_server(monkeypatch, capsys):
monkeypatch.setattr(entry, "_setup_logging", lambda: (_ for _ in ()).throw(AssertionError("started server")))
entry.main(["--check"])
assert capsys.readouterr().out.strip() == "Hermes ACP check OK"
def test_main_setup_runs_model_configuration(monkeypatch):
calls = {}
def fake_hermes_main():
calls["argv"] = sys.argv[:]
monkeypatch.setattr("hermes_cli.main.main", fake_hermes_main)
# Pretend stdin is not a TTY so the follow-up browser prompt is skipped.
# That keeps this test focused on the model-setup wiring; the
# browser-prompt path has its own test below.
monkeypatch.setattr("sys.stdin.isatty", lambda: False)
entry.main(["--setup"])
assert calls["argv"][1:] == ["model"]
def test_main_setup_offers_browser_install_when_tty(monkeypatch):
@ -121,70 +70,12 @@ def test_main_setup_offers_browser_install_when_tty(monkeypatch):
assert bootstrap_calls == [False]
def test_main_setup_skips_browser_prompt_on_no(monkeypatch):
monkeypatch.setattr("hermes_cli.main.main", lambda: None)
monkeypatch.setattr("sys.stdin.isatty", lambda: True)
monkeypatch.setattr("builtins.input", lambda *_args, **_kwargs: "")
called = []
monkeypatch.setattr(
entry,
"_run_setup_browser",
lambda assume_yes=False: called.append(assume_yes) or 0,
)
entry.main(["--setup"])
assert called == []
def test_main_setup_browser_calls_ensure_dependency(monkeypatch):
"""`hermes-acp --setup-browser` routes through dep_ensure.ensure_dependency."""
calls = []
def fake_ensure(dep, interactive=True):
calls.append((dep, interactive))
return True
monkeypatch.setattr("hermes_cli.dep_ensure.ensure_dependency", fake_ensure)
entry.main(["--setup-browser"])
assert ("node", True) in calls
assert ("browser", True) in calls
def test_main_setup_browser_forwards_yes_flag(monkeypatch):
"""--yes suppresses interactive prompts in ensure_dependency."""
calls = []
def fake_ensure(dep, interactive=True):
calls.append((dep, interactive))
return True
monkeypatch.setattr("hermes_cli.dep_ensure.ensure_dependency", fake_ensure)
entry.main(["--setup-browser", "--yes"])
assert ("node", False) in calls
assert ("browser", False) in calls
def test_main_setup_browser_stops_on_node_failure(monkeypatch):
"""If node install fails, browser install is not attempted."""
calls = []
def fake_ensure(dep, interactive=True):
calls.append(dep)
return dep != "node" # node fails
monkeypatch.setattr("hermes_cli.dep_ensure.ensure_dependency", fake_ensure)
with pytest.raises(SystemExit) as excinfo:
entry.main(["--setup-browser"])
assert excinfo.value.code == 1
assert "node" in calls
assert "browser" not in calls
def test_main_setup_browser_propagates_browser_failure(monkeypatch):

167
tests/acp/test_events.py
View file

@ -68,39 +68,7 @@ class TestToolProgressCallback:
# The coroutine should be conn.session_update
assert mock_conn.session_update.called or coro is not None
def test_handles_string_args(self, mock_conn, event_loop_fixture):
"""If args is a JSON string, it should be parsed."""
tool_call_ids = {}
tool_call_meta = {}
loop = event_loop_fixture
cb = make_tool_progress_cb(mock_conn, "session-1", loop, tool_call_ids, tool_call_meta)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb("tool.started", "read_file", "Reading /etc/hosts", '{"path": "/etc/hosts"}')
assert "read_file" in tool_call_ids
def test_handles_non_dict_args(self, mock_conn, event_loop_fixture):
"""If args is not a dict, it should be wrapped."""
tool_call_ids = {}
tool_call_meta = {}
loop = event_loop_fixture
cb = make_tool_progress_cb(mock_conn, "session-1", loop, tool_call_ids, tool_call_meta)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb("tool.started", "terminal", "$ echo hi", None)
assert "terminal" in tool_call_ids
def test_duplicate_same_name_tool_calls_use_fifo_ids(self, mock_conn, event_loop_fixture):
"""Multiple same-name tool calls should be tracked independently in order."""
@ -132,32 +100,6 @@ class TestToolProgressCallback:
# ---------------------------------------------------------------------------
class TestThinkingCallback:
def test_emits_thought_chunk(self, mock_conn, event_loop_fixture):
"""Thinking callback should emit AgentThoughtChunk."""
loop = event_loop_fixture
cb = make_thinking_cb(mock_conn, "session-1", loop)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb("Analyzing the code...")
mock_rcts.assert_called_once()
def test_ignores_empty_text(self, mock_conn, event_loop_fixture):
"""Empty text should not emit any update."""
loop = event_loop_fixture
cb = make_thinking_cb(mock_conn, "session-1", loop)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
cb("")
mock_rcts.assert_not_called()
# ---------------------------------------------------------------------------
@ -184,34 +126,7 @@ class TestStepCallback:
assert "terminal" not in tool_call_ids
mock_rcts.assert_called_once()
def test_ignores_untracked_tools(self, mock_conn, event_loop_fixture):
"""Tools not in tool_call_ids should be silently ignored."""
tool_call_ids = {}
loop = event_loop_fixture
cb = make_step_cb(mock_conn, "session-1", loop, tool_call_ids, {})
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
cb(1, [{"name": "unknown_tool", "result": "ok"}])
mock_rcts.assert_not_called()
def test_handles_string_tool_info(self, mock_conn, event_loop_fixture):
"""Tool info as a string (just the name) should work."""
tool_call_ids = {"read_file": "tc-def456"}
loop = event_loop_fixture
cb = make_step_cb(mock_conn, "session-1", loop, tool_call_ids, {})
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb(2, ["read_file"])
assert "read_file" not in tool_call_ids
mock_rcts.assert_called_once()
def test_result_passed_to_build_tool_complete(self, mock_conn, event_loop_fixture):
"""Tool result from prev_tools dict is forwarded to build_tool_complete."""
@ -235,49 +150,7 @@ class TestStepCallback:
"tc-xyz789", "terminal", result='{"output": "hello"}', function_args=None, snapshot=None
)
def test_none_result_passed_through(self, mock_conn, event_loop_fixture):
"""When result is None (e.g. first iteration), None is passed through."""
from collections import deque
tool_call_ids = {"web_search": deque(["tc-aaa"])}
loop = event_loop_fixture
cb = make_step_cb(mock_conn, "session-1", loop, tool_call_ids, {})
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts, \
patch("acp_adapter.events.build_tool_complete") as mock_btc:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb(1, [{"name": "web_search", "result": None}])
mock_btc.assert_called_once_with("tc-aaa", "web_search", result=None, function_args=None, snapshot=None)
def test_step_callback_passes_arguments_and_snapshot(self, mock_conn, event_loop_fixture):
from collections import deque
tool_call_ids = {"write_file": deque(["tc-write"])}
tool_call_meta = {"tc-write": {"args": {"path": "fallback.txt"}, "snapshot": "snap"}}
loop = event_loop_fixture
cb = make_step_cb(mock_conn, "session-1", loop, tool_call_ids, tool_call_meta)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts, \
patch("acp_adapter.events.build_tool_complete") as mock_btc:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb(1, [{"name": "write_file", "result": '{"bytes_written": 23}', "arguments": {"path": "diff-test.txt"}}])
mock_btc.assert_called_once_with(
"tc-write",
"write_file",
result='{"bytes_written": 23}',
function_args={"path": "diff-test.txt"},
snapshot="snap",
)
def test_tool_progress_captures_snapshot_metadata(self, mock_conn, event_loop_fixture):
tool_call_ids = {}
@ -329,21 +202,7 @@ class TestStepCallback:
assert [entry.status for entry in plan.entries] == ["completed", "in_progress", "completed"]
assert [entry.priority for entry in plan.entries] == ["medium", "medium", "medium"]
def test_todo_plan_update_parses_json_with_trailing_hint(self):
result = '{"todos":[{"id":"ship","content":"Ship ACP plan","status":"pending"}]}\n\n[Hint: persisted]'
update = _build_plan_update_from_todo_result(result)
assert isinstance(update, AgentPlanUpdate)
assert [entry.content for entry in update.entries] == ["Ship ACP plan"]
assert [entry.status for entry in update.entries] == ["pending"]
def test_todo_plan_update_with_empty_todos_clears_plan(self):
update = _build_plan_update_from_todo_result('{"todos":[],"summary":{"total":0}}')
assert isinstance(update, AgentPlanUpdate)
assert update.session_update == "plan"
assert update.entries == []
# ---------------------------------------------------------------------------
@ -351,32 +210,6 @@ class TestStepCallback:
# ---------------------------------------------------------------------------
class TestMessageCallback:
def test_emits_agent_message_chunk(self, mock_conn, event_loop_fixture):
"""Message callback should emit AgentMessageChunk."""
loop = event_loop_fixture
cb = make_message_cb(mock_conn, "session-1", loop)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
future = MagicMock(spec=Future)
future.result.return_value = None
mock_rcts.return_value = future
cb("Here is your answer.")
mock_rcts.assert_called_once()
def test_ignores_empty_message(self, mock_conn, event_loop_fixture):
"""Empty text should not emit any update."""
loop = event_loop_fixture
cb = make_message_cb(mock_conn, "session-1", loop)
with patch("acp_adapter.events.asyncio.run_coroutine_threadsafe") as mock_rcts:
cb("")
mock_rcts.assert_not_called()
# ---------------------------------------------------------------------------

49
tests/acp/test_mcp_e2e.py
View file

@ -194,55 +194,6 @@ class TestMcpRegistrationE2E:
assert update.content[0].type == "content"
assert "Approval prompt shows the diff" in update.content[0].content.text
@pytest.mark.asyncio
async def test_prompt_tool_results_paired_by_call_id(self, acp_agent, mock_manager):
"""The ToolCallUpdate's toolCallId must match the ToolCallStart's."""
resp = await acp_agent.new_session(cwd="/tmp")
session_id = resp.session_id
state = mock_manager.get_session(session_id)
mock_conn = MagicMock(spec=acp.Client)
mock_conn.session_update = AsyncMock()
mock_conn.request_permission = AsyncMock()
acp_agent._conn = mock_conn
def mock_run(user_message, conversation_history=None, task_id=None, **kwargs):
agent = state.agent
# Fire two tool calls
if agent.tool_progress_callback:
agent.tool_progress_callback("tool.started", "read_file", "read: /etc/hosts", {"path": "/etc/hosts"})
agent.tool_progress_callback("tool.started", "web_search", "web search: test", {"query": "test"})
if agent.step_callback:
agent.step_callback(1, [
{"name": "read_file", "result": '{"content": "127.0.0.1 localhost"}'},
{"name": "web_search", "result": '{"data": {"web": []}}'},
])
return {"final_response": "Done.", "messages": []}
state.agent.run_conversation = mock_run
prompt = [TextContentBlock(type="text", text="test")]
await acp_agent.prompt(prompt=prompt, session_id=session_id)
updates = []
for call in mock_conn.session_update.call_args_list:
update_arg = call[1].get("update") or call[0][1]
updates.append(update_arg)
starts = [u for u in updates if getattr(u, "session_update", None) == "tool_call"]
completions = [u for u in updates if getattr(u, "session_update", None) == "tool_call_update"]
assert len(starts) == 2, f"Expected 2 starts, got {len(starts)}"
assert len(completions) == 2, f"Expected 2 completions, got {len(completions)}"
# Each completion's toolCallId must match a start's toolCallId
start_ids = {s.tool_call_id for s in starts}
completion_ids = {c.tool_call_id for c in completions}
assert start_ids == completion_ids, (
f"IDs must match: starts={start_ids}, completions={completion_ids}"
)
class TestMcpSanitizationE2E:

45
tests/acp/test_named_provider_catalogs.py
View file

@ -30,32 +30,6 @@ def _cfg(providers=None, custom_providers=None):
class TestNamedCustomProviderCatalogs:
def test_declared_default_model_survives_failed_discovery(self, monkeypatch):
"""Endpoints without a /models route keep their declared models."""
monkeypatch.setenv("BEDROCK_MANTLE_API_KEY", "test-key")
cfg = _cfg(
providers={
"bedrock-mantle": {
"name": "AWS Bedrock Mantle",
"base_url": MANTLE_URL,
"key_env": "BEDROCK_MANTLE_API_KEY",
"api_mode": "codex_responses",
"default_model": "openai.gpt-5.5",
}
}
)
with patch("hermes_cli.config.load_config", return_value=cfg), patch(
"hermes_cli.models.fetch_api_models", return_value=None
):
catalogs = _named_custom_provider_catalogs()
assert catalogs == [
(
"custom:bedrock-mantle",
"AWS Bedrock Mantle",
[("openai.gpt-5.5", "")],
)
]
def test_live_discovery_extends_declared_models(self, monkeypatch):
monkeypatch.setenv("SOME_KEY", "k")
@ -80,25 +54,6 @@ class TestNamedCustomProviderCatalogs:
assert slug == "custom:relay"
assert [m for m, _ in models] == ["model-a", "model-b"]
def test_declared_models_dict_included(self, monkeypatch):
monkeypatch.setenv("SOME_KEY", "k")
cfg = _cfg(
providers={
"relay": {
"name": "Relay",
"base_url": "https://relay.example/v1",
"key_env": "SOME_KEY",
"default_model": "model-a",
"models": {"model-b": {}, "model-c": {}},
}
}
)
with patch("hermes_cli.config.load_config", return_value=cfg), patch(
"hermes_cli.models.fetch_api_models", return_value=None
):
catalogs = _named_custom_provider_catalogs()
assert [m for m, _ in catalogs[0][2]] == ["model-a", "model-b", "model-c"]
def test_disabled_provider_skipped(self, monkeypatch):
monkeypatch.setenv("SOME_KEY", "k")

73
tests/acp/test_permissions.py
View file

@ -106,53 +106,9 @@ class TestApprovalBridge:
assert first_kwargs["tool_call"].tool_call_id != second_kwargs["tool_call"].tool_call_id
def test_prompt_path_keeps_session_option_when_permanent_disabled(self):
result, kwargs, _, _, _ = _invoke_callback(
AllowedOutcome(option_id="allow_session", outcome="selected"),
allow_permanent=False,
use_prompt_path=True,
)
option_ids = [option.option_id for option in kwargs["options"]]
assert result == "session"
assert option_ids == ["allow_once", "allow_session", "deny", "deny_always"]
def test_smart_deny_prompt_only_offers_once_and_deny(self):
result, kwargs, _, _, _ = _invoke_callback(
AllowedOutcome(option_id="allow_once", outcome="selected"),
allow_permanent=False,
smart_denied=True,
use_prompt_path=True,
)
assert result == "once"
assert [option.option_id for option in kwargs["options"]] == [
"allow_once", "deny",
]
def test_smart_deny_rejects_disallowed_session_outcome(self):
result, kwargs, _, _, _ = _invoke_callback(
AllowedOutcome(option_id="allow_session", outcome="selected"),
smart_denied=True,
)
assert result == "deny"
assert [option.option_id for option in kwargs["options"]] == [
"allow_once", "deny",
]
def test_reject_always_outcome_denies_without_changing_policy(self):
result, kwargs, _, _, _ = _invoke_callback(
AllowedOutcome(option_id="deny_always", outcome="selected"),
use_prompt_path=True,
)
deny_always = [option for option in kwargs["options"] if option.option_id == "deny_always"]
assert result == "deny"
assert len(deny_always) == 1
assert deny_always[0].kind == "reject_always"
def test_allow_always_maps_correctly(self):
result, _, _, _, _ = _invoke_callback(
@ -162,14 +118,6 @@ class TestApprovalBridge:
assert result == "always"
def test_denied_and_unknown_outcomes_deny(self):
denied_result, _, _, _, _ = _invoke_callback(DeniedOutcome(outcome="cancelled"))
unknown_result, _, _, _, _ = _invoke_callback(
AllowedOutcome(option_id="unexpected", outcome="selected"),
)
assert denied_result == "deny"
assert unknown_result == "deny"
def test_timeout_returns_deny_and_cancels_future(self):
loop = MagicMock(spec=asyncio.AbstractEventLoop)
@ -194,27 +142,6 @@ class TestApprovalBridge:
assert scheduled["loop"] is loop
assert future.cancel.call_count == 1
def test_none_response_returns_deny(self):
"""When request_permission resolves to None, the callback returns 'deny'."""
loop = MagicMock(spec=asyncio.AbstractEventLoop)
request_permission = AsyncMock(name="request_permission")
future = MagicMock(spec=Future)
future.result.return_value = None
scheduled = {}
def _schedule(coro, passed_loop):
scheduled["coro"] = coro
scheduled["loop"] = passed_loop
return future
with patch("agent.async_utils.asyncio.run_coroutine_threadsafe", side_effect=_schedule):
cb = make_approval_callback(request_permission, loop, session_id="s1", timeout=1.0)
result = cb("echo hi", "demo")
scheduled["coro"].close()
assert result == "deny"
# ---------------------------------------------------------------------------

19
tests/acp/test_ping_suppression.py
View file

@ -52,18 +52,8 @@ def test_filter_suppresses_benign_probe(method: str) -> None:
assert f.filter(record) is False
def test_filter_allows_real_method_not_found() -> None:
f = _BenignProbeMethodFilter()
exc = _bake_tb(RequestError.method_not_found("session/custom"))
record = _make_record("Background task failed", exc)
assert f.filter(record) is True
def test_filter_allows_non_request_error() -> None:
f = _BenignProbeMethodFilter()
exc = _bake_tb(RuntimeError("boom"))
record = _make_record("Background task failed", exc)
assert f.filter(record) is True
def test_filter_allows_different_message_even_for_ping() -> None:
@ -74,17 +64,8 @@ def test_filter_allows_different_message_even_for_ping() -> None:
assert f.filter(record) is True
def test_filter_allows_request_error_with_different_code() -> None:
f = _BenignProbeMethodFilter()
exc = _bake_tb(RequestError.invalid_params({"method": "ping"}))
record = _make_record("Background task failed", exc)
assert f.filter(record) is True
def test_filter_allows_log_without_exc_info() -> None:
f = _BenignProbeMethodFilter()
record = _make_record("Background task failed", None)
assert f.filter(record) is True
# -- End-to-end: drive a real JSON-RPC `ping` through acp.run_agent ---------

1682
tests/acp/test_server.py
View file

File diff suppressed because it is too large Load diff

436
tests/acp/test_session.py
View file

@ -37,11 +37,6 @@ class TestCreateSession:
assert state.history == []
assert state.agent is not None
def test_create_session_registers_task_cwd(self, manager, monkeypatch):
calls = []
monkeypatch.setattr("acp_adapter.session._register_task_cwd", lambda task_id, cwd: calls.append((task_id, cwd)))
state = manager.create_session(cwd="/tmp/work")
assert calls == [(state.session_id, "/tmp/work")]
def test_register_task_cwd_translates_windows_drive_for_wsl_tools(self, monkeypatch):
@ -64,18 +59,12 @@ class TestCreateSession:
"overrides": {"cwd": "/mnt/e/Projects/AI/paperclip"},
}
def test_session_ids_are_unique(self, manager):
s1 = manager.create_session()
s2 = manager.create_session()
assert s1.session_id != s2.session_id
def test_get_session(self, manager):
state = manager.create_session()
fetched = manager.get_session(state.session_id)
assert fetched is state
def test_get_nonexistent_session_returns_none(self, manager):
assert manager.get_session("does-not-exist") is None
def test_make_agent_stamps_session_cwd_for_codex_runtime(self, monkeypatch):
class FakeAgent:
@ -135,27 +124,9 @@ class TestWslCwdTranslation:
assert acp_session._translate_acp_cwd(r"E:\Projects\AI\paperclip") == "/mnt/e/Projects/AI/paperclip"
def test_translate_acp_cwd_handles_forward_slashes_when_wsl(self, monkeypatch):
monkeypatch.setattr("hermes_constants._wsl_detected", True)
assert acp_session._translate_acp_cwd("D:/work/project") == "/mnt/d/work/project"
def test_translate_acp_cwd_leaves_windows_drive_path_unchanged_off_wsl(self, monkeypatch):
monkeypatch.setattr("hermes_constants._wsl_detected", False)
assert acp_session._translate_acp_cwd(r"E:\Projects\AI\paperclip") == r"E:\Projects\AI\paperclip"
def test_translate_acp_cwd_leaves_posix_path_unchanged_on_wsl(self, monkeypatch):
monkeypatch.setattr("hermes_constants._wsl_detected", True)
assert acp_session._translate_acp_cwd("/mnt/e/Projects/AI/paperclip") == "/mnt/e/Projects/AI/paperclip"
def test_create_session_stores_translated_cwd_on_wsl(self, manager, monkeypatch):
monkeypatch.setattr("hermes_constants._wsl_detected", True)
state = manager.create_session(cwd=r"E:\Projects\AI\paperclip")
assert state.cwd == "/mnt/e/Projects/AI/paperclip"
def test_fork_session_stores_translated_cwd_on_wsl(self, manager, monkeypatch):
monkeypatch.setattr("hermes_constants._wsl_detected", True)
@ -180,32 +151,6 @@ class TestWslCwdTranslation:
# ---------------------------------------------------------------------------
class TestForkSession:
def test_fork_session_deep_copies_history(self, manager):
original = manager.create_session()
original.history.append({"role": "user", "content": "hello"})
original.history.append({"role": "assistant", "content": "hi"})
forked = manager.fork_session(original.session_id, cwd="/new")
assert forked is not None
# History should be equal in content
assert len(forked.history) == 2
assert forked.history[0]["content"] == "hello"
# But a deep copy — mutating one doesn't affect the other
forked.history.append({"role": "user", "content": "extra"})
assert len(original.history) == 2
assert len(forked.history) == 3
def test_fork_session_has_new_id(self, manager):
original = manager.create_session()
forked = manager.fork_session(original.session_id)
assert forked is not None
assert forked.session_id != original.session_id
def test_fork_nonexistent_returns_none(self, manager):
assert manager.fork_session("bogus-id") is None
# ---------------------------------------------------------------------------
@ -217,20 +162,7 @@ class TestListAndCleanup:
def test_list_sessions_empty(self, manager):
assert manager.list_sessions() == []
def test_list_sessions_returns_created(self, manager):
s1 = manager.create_session(cwd="/a")
s2 = manager.create_session(cwd="/b")
s1.history.append({"role": "user", "content": "hello from a"})
s2.history.append({"role": "user", "content": "hello from b"})
listing = manager.list_sessions()
ids = {s["session_id"] for s in listing}
assert s1.session_id in ids
assert s2.session_id in ids
assert len(listing) == 2
def test_list_sessions_hides_empty_threads(self, manager):
manager.create_session(cwd="/empty")
assert manager.list_sessions() == []
def test_save_session_preserves_existing_messages_on_encode_failure(self, manager):
"""Regression for #13675: a bad message in state.history must not
@ -260,123 +192,8 @@ class TestListAndCleanup:
assert messages[0]["content"] == "original"
assert isinstance(messages[0].get("timestamp"), (int, float))
def test_save_session_preserves_agent_archived_history(self, tmp_path):
"""Regression: ACP _persist must not destroy compression-archived rows.
When the agent owns persistence to the same SessionDB, it has already
flushed the transcript itself and used archive_and_compact() to keep
pre-compaction turns as searchable active=0/compacted=1 rows. A blind
replace_messages() here used to DELETE those archived rows (and the FTS
index entries with them) on every save — silent data loss for any ACP
conversation long enough to compress.
"""
db = SessionDB(tmp_path / "state.db")
def factory():
# Mimic a live ACP agent: it persists to *this* db and has already
# created its session row / flushed at least one turn.
return SimpleNamespace(
model="test-model",
_session_db=db,
_session_db_created=True,
)
manager = SessionManager(agent_factory=factory, db=db)
state = manager.create_session(cwd="/work")
# Simulate the agent's own persistence: it flushed the live transcript,
# then compression archived the pre-compaction turns and inserted a
# compacted summary as the new active set.
db.append_message(
session_id=state.session_id, role="user", content="archived needle"
)
db.archive_and_compact(
state.session_id, [{"role": "user", "content": "compacted summary"}]
)
# ACP's in-memory history only tracks the post-compaction (active) set.
state.history = [{"role": "user", "content": "compacted summary"}]
manager.save_session(state.session_id)
# The archived pre-compaction turn must survive and stay discoverable.
contents = [
m["content"]
for m in db.get_messages(state.session_id, include_inactive=True)
]
assert "archived needle" in contents
assert "compacted summary" in contents
hits = {r["session_id"] for r in db.search_messages("needle")}
assert state.session_id in hits
def test_save_session_still_replaces_when_agent_not_self_persisting(self, manager):
"""Agents that don't own DB persistence keep ACP as the source of truth.
The default fixture's MagicMock agent has a ``_session_db`` that is *not*
the manager's db, so the destructive replace path stays active and ACP
history overwrites cleanly (no orphaned rows from a prior save).
"""
state = manager.create_session()
db = manager._get_db()
state.history = [{"role": "user", "content": "v1"}]
manager.save_session(state.session_id)
assert [
m["content"] for m in db.get_messages_as_conversation(state.session_id)
] == ["v1"]
state.history = [{"role": "user", "content": "v2 replaced"}]
manager.save_session(state.session_id)
assert [
m["content"] for m in db.get_messages_as_conversation(state.session_id)
] == ["v2 replaced"]
def test_save_session_preserves_archived_rows_on_model_switch(self, tmp_path):
"""Regression (#50405 W1/W2): a save by a fresh, non-self-persisting
agent must not destroy compaction-archived rows.
Model switches and /restore mint a brand-new agent with
``_session_db_created=False`` (so it does NOT "own" persistence) and
then immediately call save_session. If the session had already
compacted, a blind full-history replace would DELETE the archived
active=0/compacted=1 rows — the same data loss the owned-agent guard
prevents. When archived rows exist, _persist must replace only the live
set (active_only) and leave the archived transcript intact.
"""
from types import SimpleNamespace
db = SessionDB(tmp_path / "state.db")
# Use a mock agent factory so create_session doesn't spin up a real
# AIAgent (which needs credentials and leaks provider-probe state across
# xdist workers). The factory's agent does NOT own persistence to db.
manager = SessionManager(
agent_factory=lambda: SimpleNamespace(model="m"), db=db
)
state = manager.create_session(cwd="/work")
# Session flushed a live turn, then compaction archived it.
db.append_message(
session_id=state.session_id, role="user", content="archived needle"
)
db.archive_and_compact(
state.session_id, [{"role": "user", "content": "compacted summary"}]
)
# Model switch: a fresh agent bound to THIS db but not yet self-created.
state.agent = SimpleNamespace(
model="new-model", _session_db=db, _session_db_created=False
)
state.history = [{"role": "user", "content": "compacted summary"}]
manager.save_session(state.session_id)
# Archived pre-compaction turn survives and stays discoverable.
contents = [
m["content"]
for m in db.get_messages(state.session_id, include_inactive=True)
]
assert "archived needle" in contents
assert "compacted summary" in contents
hits = {r["session_id"] for r in db.search_messages("needle")}
assert state.session_id in hits
def test_cleanup_clears_all(self, manager):
s1 = manager.create_session()
@ -403,199 +220,18 @@ class TestListAndCleanup:
class TestPersistence:
"""Verify that sessions are persisted to SessionDB and can be restored."""
def test_create_session_includes_registered_mcp_toolsets(self, tmp_path, monkeypatch):
captured = {}
def fake_resolve_runtime_provider(requested=None, **kwargs):
return {
"provider": "openrouter",
"api_mode": "chat_completions",
"base_url": "https://openrouter.example/v1",
"api_key": "***",
"command": None,
"args": [],
}
def fake_agent(**kwargs):
captured.update(kwargs)
return SimpleNamespace(model=kwargs.get("model"), enabled_toolsets=kwargs.get("enabled_toolsets"))
monkeypatch.setattr("hermes_cli.config.load_config", lambda: {
"model": {"provider": "openrouter", "default": "test-model"},
"mcp_servers": {
"olympus": {"command": "python", "enabled": True},
"exa": {"url": "https://exa.ai/mcp"},
"disabled": {"command": "python", "enabled": False},
},
})
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
fake_resolve_runtime_provider,
)
db = SessionDB(tmp_path / "state.db")
with patch("run_agent.AIAgent", side_effect=fake_agent):
manager = SessionManager(db=db)
manager.create_session(cwd="/work")
assert captured["enabled_toolsets"] == ["hermes-acp", "mcp-olympus", "mcp-exa"]
def test_create_session_writes_to_db(self, manager):
state = manager.create_session(cwd="/project")
db = manager._get_db()
assert db is not None
row = db.get_session(state.session_id)
assert row is not None
assert row["source"] == "acp"
# cwd stored in model_config JSON
mc = json.loads(row["model_config"])
assert mc["cwd"] == "/project"
def test_get_session_restores_from_db(self, manager):
"""Simulate process restart: create session, drop from memory, get again."""
state = manager.create_session(cwd="/work")
state.history.append({"role": "user", "content": "hello"})
state.history.append({"role": "assistant", "content": "hi there"})
manager.save_session(state.session_id)
sid = state.session_id
# Drop from in-memory store (simulates process restart).
with manager._lock:
del manager._sessions[sid]
# get_session should transparently restore from DB.
restored = manager.get_session(sid)
assert restored is not None
assert restored.session_id == sid
assert restored.cwd == "/work"
assert len(restored.history) == 2
assert restored.history[0]["content"] == "hello"
assert restored.history[1]["content"] == "hi there"
# Agent should have been recreated.
assert restored.agent is not None
def test_save_session_updates_db(self, manager):
state = manager.create_session()
state.history.append({"role": "user", "content": "test"})
manager.save_session(state.session_id)
db = manager._get_db()
messages = db.get_messages_as_conversation(state.session_id)
assert len(messages) == 1
assert messages[0]["content"] == "test"
def test_remove_session_deletes_from_db(self, manager):
state = manager.create_session()
db = manager._get_db()
assert db.get_session(state.session_id) is not None
manager.remove_session(state.session_id)
assert db.get_session(state.session_id) is None
def test_cleanup_removes_all_from_db(self, manager):
s1 = manager.create_session()
s2 = manager.create_session()
db = manager._get_db()
assert db.get_session(s1.session_id) is not None
assert db.get_session(s2.session_id) is not None
manager.cleanup()
assert db.get_session(s1.session_id) is None
assert db.get_session(s2.session_id) is None
def test_list_sessions_includes_db_only(self, manager):
"""Sessions only in DB (not in memory) appear in list_sessions."""
state = manager.create_session(cwd="/db-only")
state.history.append({"role": "user", "content": "database only thread"})
manager.save_session(state.session_id)
sid = state.session_id
# Drop from memory.
with manager._lock:
del manager._sessions[sid]
listing = manager.list_sessions()
ids = {s["session_id"] for s in listing}
assert sid in ids
def test_list_sessions_filters_by_cwd(self, manager):
keep = manager.create_session(cwd="/keep")
drop = manager.create_session(cwd="/drop")
keep.history.append({"role": "user", "content": "keep me"})
drop.history.append({"role": "user", "content": "drop me"})
listing = manager.list_sessions(cwd="/keep")
ids = {s["session_id"] for s in listing}
assert keep.session_id in ids
assert drop.session_id not in ids
def test_list_sessions_matches_windows_and_wsl_paths(self, manager):
state = manager.create_session(cwd="/mnt/e/Projects/AI/browser-link-3")
state.history.append({"role": "user", "content": "same project from WSL"})
listing = manager.list_sessions(cwd=r"E:\Projects\AI\browser-link-3")
ids = {s["session_id"] for s in listing}
assert state.session_id in ids
def test_list_sessions_prefers_title_then_preview(self, manager):
state = manager.create_session(cwd="/named")
state.history.append({"role": "user", "content": "Investigate broken ACP history in Zed"})
manager.save_session(state.session_id)
db = manager._get_db()
db.set_session_title(state.session_id, "Fix Zed ACP history")
listing = manager.list_sessions(cwd="/named")
assert listing[0]["title"] == "Fix Zed ACP history"
db.set_session_title(state.session_id, "")
listing = manager.list_sessions(cwd="/named")
assert listing[0]["title"].startswith("Investigate broken ACP history")
def test_list_sessions_sorted_by_most_recent_activity(self, manager):
older = manager.create_session(cwd="/ordered")
older.history.append({"role": "user", "content": "older"})
manager.save_session(older.session_id)
time.sleep(0.02)
newer = manager.create_session(cwd="/ordered")
newer.history.append({"role": "user", "content": "newer"})
manager.save_session(newer.session_id)
listing = manager.list_sessions(cwd="/ordered")
assert [item["session_id"] for item in listing[:2]] == [newer.session_id, older.session_id]
assert listing[0]["updated_at"]
assert listing[1]["updated_at"]
def test_fork_restores_source_from_db(self, manager):
"""Forking a session that is only in DB should work."""
original = manager.create_session()
original.history.append({"role": "user", "content": "context"})
manager.save_session(original.session_id)
# Drop original from memory.
with manager._lock:
del manager._sessions[original.session_id]
forked = manager.fork_session(original.session_id, cwd="/fork")
assert forked is not None
assert len(forked.history) == 1
assert forked.history[0]["content"] == "context"
assert forked.session_id != original.session_id
def test_update_cwd_restores_from_db(self, manager):
state = manager.create_session(cwd="/old")
sid = state.session_id
with manager._lock:
del manager._sessions[sid]
updated = manager.update_cwd(sid, "/new")
assert updated is not None
assert updated.cwd == "/new"
# Should also be persisted in DB.
db = manager._get_db()
row = db.get_session(sid)
mc = json.loads(row["model_config"])
assert mc["cwd"] == "/new"
def test_only_restores_acp_sessions(self, manager):
"""get_session should not restore non-ACP sessions from DB."""
@ -618,32 +254,6 @@ class TestPersistence:
session_ids = {r["session_id"] for r in results}
assert state.session_id in session_ids
def test_tool_calls_persisted(self, manager):
"""Messages with tool_calls should round-trip through the DB."""
state = manager.create_session()
state.history.append({
"role": "assistant",
"content": None,
"tool_calls": [{"id": "tc_1", "type": "function",
"function": {"name": "terminal", "arguments": "{}"}}],
})
state.history.append({
"role": "tool",
"content": "output here",
"tool_call_id": "tc_1",
"name": "terminal",
})
manager.save_session(state.session_id)
# Drop from memory, restore from DB.
with manager._lock:
del manager._sessions[state.session_id]
restored = manager.get_session(state.session_id)
assert restored is not None
assert len(restored.history) == 2
assert restored.history[0].get("tool_calls") is not None
assert restored.history[1].get("tool_call_id") == "tc_1"
def test_assistant_reasoning_fields_persisted(self, manager):
"""ACP session restore should preserve assistant reasoning context."""
@ -680,52 +290,6 @@ class TestPersistence:
],
}]
def test_restore_preserves_persisted_provider_snapshot(self, tmp_path, monkeypatch):
"""Restored ACP sessions should keep their original runtime provider."""
runtime_choice = {"provider": "anthropic"}
def fake_resolve_runtime_provider(requested=None, **kwargs):
provider = requested or runtime_choice["provider"]
return {
"provider": provider,
"api_mode": "anthropic_messages" if provider == "anthropic" else "chat_completions",
"base_url": f"https://{provider}.example/v1",
"api_key": f"{provider}-key",
"command": None,
"args": [],
}
def fake_agent(**kwargs):
return SimpleNamespace(
model=kwargs.get("model"),
provider=kwargs.get("provider"),
base_url=kwargs.get("base_url"),
api_mode=kwargs.get("api_mode"),
)
monkeypatch.setattr("hermes_cli.config.load_config", lambda: {
"model": {"provider": runtime_choice["provider"], "default": "test-model"}
})
monkeypatch.setattr(
"hermes_cli.runtime_provider.resolve_runtime_provider",
fake_resolve_runtime_provider,
)
db = SessionDB(tmp_path / "state.db")
with patch("run_agent.AIAgent", side_effect=fake_agent):
manager = SessionManager(db=db)
state = manager.create_session(cwd="/work")
manager.save_session(state.session_id)
with manager._lock:
del manager._sessions[state.session_id]
runtime_choice["provider"] = "openrouter"
restored = manager.get_session(state.session_id)
assert restored is not None
assert restored.agent.provider == "anthropic"
assert restored.agent.base_url == "https://anthropic.example/v1"
def test_acp_agents_route_human_output_to_stderr(self, tmp_path, monkeypatch):
"""ACP agents must keep stdout clean for JSON-RPC stdio transport."""

21
tests/acp/test_session_db_private_access.py
View file

@ -53,24 +53,7 @@ class TestUpdateSessionMeta:
assert stored["cwd"] == "/new/path"
assert stored["provider"] == "openai"
def test_updates_model_when_provided(self, tmp_path):
db = _tmp_db(tmp_path)
db.create_session("s2", source="acp", model="gpt-3.5")
db.update_session_meta("s2", json.dumps({"cwd": "."}), model="gpt-4o")
row = db.get_session("s2")
assert row["model"] == "gpt-4o"
def test_preserves_existing_model_when_none(self, tmp_path):
"""Passing model=None must leave the stored model unchanged (COALESCE)."""
db = _tmp_db(tmp_path)
db.create_session("s3", source="acp", model="claude-3")
db.update_session_meta("s3", json.dumps({"cwd": "."}), model=None)
row = db.get_session("s3")
assert row["model"] == "claude-3"
def test_uses_execute_write_not_private_api(self, tmp_path):
"""update_session_meta must route through _execute_write, not _conn directly."""
@ -91,10 +74,6 @@ class TestUpdateSessionMeta:
"update_session_meta must call _execute_write at least once"
)
def test_noop_on_nonexistent_session(self, tmp_path):
"""Updating a non-existent session must not raise."""
db = _tmp_db(tmp_path)
db.update_session_meta("ghost", json.dumps({"cwd": "."}), model=None)
# ---------------------------------------------------------------------------

23
tests/acp/test_session_provenance.py
View file

@ -55,17 +55,6 @@ def test_compression_split_continuation(db):
assert prov["creatorKind"] == "compression"
def test_multi_depth_chain(db):
_mk(db, "s0")
db.end_session("s0", "compression")
_mk(db, "s1", parent="s0")
db.end_session("s1", "compression")
_mk(db, "s2", parent="s1")
prov = build_session_provenance(db, "acp-1", "s2")
assert prov["rootHermesSessionId"] == "s0"
assert prov["compressionDepth"] == 2
assert prov["sessionKind"] == "continuation"
def test_non_compression_parent_is_root_not_continuation(db):
@ -79,20 +68,8 @@ def test_non_compression_parent_is_root_not_continuation(db):
assert prov["rootHermesSessionId"] == "p" # lineage root still walked
def test_no_false_rotation_when_head_unchanged(db):
_mk(db, "s")
# previous == current → no rotation reason emitted.
prov = build_session_provenance(
db, "acp-1", "s", previous_hermes_session_id="s"
)
assert "reason" not in prov
assert "creatorKind" not in prov
assert prov["previousHermesSessionId"] == "s"
def test_unknown_session_returns_none(db):
assert build_session_provenance(db, "acp-1", "does-not-exist") is None
assert session_provenance_meta(db, "acp-1", "does-not-exist") is None
def test_meta_wrapper_shape(db):

417
tests/acp/test_tools.py
View file

@ -40,26 +40,12 @@ class TestToolKindMap:
def test_tool_kind_terminal(self):
assert get_tool_kind("terminal") == "execute"
def test_tool_kind_patch(self):
assert get_tool_kind("patch") == "edit"
def test_tool_kind_write_file(self):
assert get_tool_kind("write_file") == "edit"
def test_tool_kind_web_search(self):
assert get_tool_kind("web_search") == "fetch"
def test_tool_kind_execute_code(self):
assert get_tool_kind("execute_code") == "execute"
def test_tool_kind_todo(self):
assert get_tool_kind("todo") == "other"
def test_tool_kind_skill_view(self):
assert get_tool_kind("skill_view") == "read"
def test_tool_kind_browser_navigate(self):
assert get_tool_kind("browser_navigate") == "fetch"
def test_unknown_tool_returns_other_kind(self):
assert get_tool_kind("nonexistent_tool_xyz") == "other"
@ -104,48 +90,23 @@ class TestBuildToolTitle:
title = build_tool_title("read_file", {"path": "/etc/hosts"})
assert "/etc/hosts" in title
def test_patch_title(self):
title = build_tool_title("patch", {"path": "main.py", "mode": "replace"})
assert "main.py" in title
def test_search_title(self):
title = build_tool_title("search_files", {"pattern": "TODO"})
assert "TODO" in title
def test_web_search_title(self):
title = build_tool_title("web_search", {"query": "python asyncio"})
assert "python asyncio" in title
def test_web_extract_title_unwraps_search_result_object(self):
title = build_tool_title("web_extract", {
"urls": [
{"url": "https://example.com/a", "title": "A"},
{"href": "https://example.org/b"},
]
})
assert title == "extract: https://example.com/a (+1)"
def test_web_extract_title_handles_malformed_object(self):
assert build_tool_title("web_extract", {"urls": [{"title": "missing"}]}) == "extract: ?"
def test_skill_view_title_includes_skill_name(self):
title = build_tool_title("skill_view", {"name": "github-pitfalls"})
assert title == "skill view (github-pitfalls)"
def test_skill_view_title_includes_linked_file(self):
title = build_tool_title("skill_view", {"name": "github-pitfalls", "file_path": "references/api.md"})
assert title == "skill view (github-pitfalls/references/api.md)"
def test_execute_code_title_includes_first_code_line(self):
title = build_tool_title("execute_code", {"code": "\nfrom hermes_tools import terminal\nprint('done')"})
assert title == "python: from hermes_tools import terminal"
def test_skill_manage_title_includes_action_and_target(self):
title = build_tool_title(
"skill_manage",
{"action": "patch", "name": "hermes-agent-operations", "file_path": "references/acp.md"},
)
assert title == "skill patch: hermes-agent-operations/references/acp.md"
def test_unknown_tool_uses_name(self):
title = build_tool_title("some_new_tool", {"foo": "bar"})
@ -174,17 +135,6 @@ class TestBuildToolStart:
assert "Approval prompt shows the diff" in item.content.text
assert "src/main.py" in item.content.text
def test_build_tool_start_for_write_file(self):
"""write_file start should not duplicate the edit-approval diff."""
args = {"path": "new_file.py", "content": "print('hello')"}
result = build_tool_start("tc-w1", "write_file", args)
assert isinstance(result, ToolCallStart)
assert result.kind == "edit"
assert len(result.content) >= 1
item = result.content[0]
assert isinstance(item, ContentToolCallContent)
assert "Approval prompt shows the diff" in item.content.text
assert "new_file.py" in item.content.text
def test_auto_approved_edit_start_shows_diff_content(self):
"""Auto-approved edit starts need the diff because no approval card exists."""
@ -205,57 +155,11 @@ class TestBuildToolStart:
assert item.old_text == "old\n"
assert item.new_text == "new\n"
def test_build_tool_start_for_terminal(self):
"""terminal should produce text content with the command."""
args = {"command": "ls -la /tmp"}
result = build_tool_start("tc-2", "terminal", args)
assert isinstance(result, ToolCallStart)
assert result.kind == "execute"
assert len(result.content) >= 1
content_item = result.content[0]
assert isinstance(content_item, ContentToolCallContent)
# The wrapped text block should contain the command
text = content_item.content.text
assert "ls -la /tmp" in text
def test_build_tool_start_for_read_file(self):
"""read_file start should stay compact; completion carries file contents."""
args = {"path": "/etc/hosts", "offset": 1, "limit": 50}
result = build_tool_start("tc-3", "read_file", args)
assert isinstance(result, ToolCallStart)
assert result.kind == "read"
assert result.content is None
assert result.raw_input is None
def test_build_tool_start_survives_non_string_command(self):
"""A malformed (non-string) terminal command previously raised
TypeError in build_tool_title (len(None)) and aborted the render."""
result = build_tool_start("tc-bad-cmd", "terminal", {"command": None})
assert isinstance(result, ToolCallStart)
assert result.kind == "execute" # tool identity preserved in the fallback
def test_build_tool_start_survives_non_string_path(self):
"""A non-string read_file path previously raised a ToolCallLocation
pydantic ValidationError in extract_locations and aborted the render."""
result = build_tool_start("tc-bad-path", "read_file", {"path": {"p": "x"}})
assert isinstance(result, ToolCallStart)
assert result.kind == "read"
def test_build_tool_start_survives_non_string_goal(self):
"""A non-string delegate_task goal previously raised TypeError
(len(123)) in build_tool_title and aborted the render."""
result = build_tool_start("tc-bad-goal", "delegate_task", {"goal": 123})
assert isinstance(result, ToolCallStart)
def test_build_tool_start_for_web_extract_is_compact(self):
"""web_extract start should stay compact; title identifies URLs."""
args = {"urls": ["https://example.com/docs"]}
result = build_tool_start("tc-web-start", "web_extract", args)
assert isinstance(result, ToolCallStart)
assert result.title == "extract: https://example.com/docs"
assert result.kind == "fetch"
assert result.content is None
assert result.raw_input is None
def test_build_tool_start_for_browser_navigate(self):
"""browser_navigate should emit a polished start event."""
@ -267,62 +171,11 @@ class TestBuildToolStart:
assert result.content[0].content.text == '{\n "url": "https://x.com"\n}'
assert result.raw_input is None
def test_build_tool_start_for_search(self):
"""search_files should include pattern in content."""
args = {"pattern": "TODO", "target": "content"}
result = build_tool_start("tc-4", "search_files", args)
assert isinstance(result, ToolCallStart)
assert result.kind == "search"
assert "TODO" in result.content[0].content.text
assert result.raw_input is None
def test_build_tool_start_for_todo_is_human_readable(self):
args = {"todos": [{"id": "one", "content": "Fix ACP rendering", "status": "in_progress"}]}
result = build_tool_start("tc-todo", "todo", args)
assert result.title == "todo (1 item)"
assert "Fix ACP rendering" in result.content[0].content.text
assert result.raw_input is None
def test_build_tool_start_for_skill_view_is_human_readable(self):
result = build_tool_start("tc-skill", "skill_view", {"name": "github-pitfalls"})
assert result.title == "skill view (github-pitfalls)"
assert "github-pitfalls" in result.content[0].content.text
assert result.raw_input is None
def test_build_tool_start_for_execute_code_shows_code_preview(self):
result = build_tool_start("tc-code", "execute_code", {"code": "print('hello')"})
assert result.kind == "execute"
assert result.title == "python: print('hello')"
assert "```python" in result.content[0].content.text
assert "print('hello')" in result.content[0].content.text
assert result.raw_input is None
def test_build_tool_start_for_skill_manage_patch_shows_diff(self):
result = build_tool_start(
"tc-skill-manage",
"skill_manage",
{
"action": "patch",
"name": "hermes-agent-operations",
"file_path": "references/acp.md",
"old_string": "old advice",
"new_string": "new advice",
},
)
assert result.kind == "edit"
assert result.title == "skill patch: hermes-agent-operations/references/acp.md"
assert isinstance(result.content[0], FileEditToolCallContent)
assert result.content[0].path == "skills/hermes-agent-operations/references/acp.md"
assert result.content[0].old_text == "old advice"
assert result.content[0].new_text == "new advice"
assert result.raw_input is None
def test_build_tool_start_generic_fallback(self):
"""Unknown tools should get a generic text representation."""
args = {"foo": "bar", "baz": 42}
result = build_tool_start("tc-5", "some_tool", args)
assert isinstance(result, ToolCallStart)
assert result.kind == "other"
# ---------------------------------------------------------------------------
@ -342,144 +195,23 @@ class TestBuildToolComplete:
assert "total 42" in content_item.content.text
assert result.raw_output is None
def test_build_tool_complete_for_todo_is_checklist(self):
result = build_tool_complete(
"tc-todo",
"todo",
'{"todos":[{"id":"a","content":"Inspect ACP","status":"completed"},{"id":"b","content":"Patch renderers","status":"in_progress"}],"summary":{"total":2,"pending":0,"in_progress":1,"completed":1,"cancelled":0}}',
)
text = result.content[0].content.text
assert "✅ Inspect ACP" in text
assert "- 🔄 Patch renderers" in text
assert "**Progress:** 1 completed, 1 in progress, 0 pending" in text
assert result.raw_output is None
def test_build_tool_complete_for_skill_view_summarizes_content_without_raw_json(self):
result = build_tool_complete(
"tc-skill",
"skill_view",
'{"success":true,"name":"github-pitfalls","description":"GitHub gotchas","content":"# GitHub Pitfalls\\nUse gh carefully.","path":"github/github-pitfalls/SKILL.md"}',
)
text = result.content[0].content.text
assert "**Skill loaded**" in text
assert "`github-pitfalls`" in text
assert "GitHub gotchas" in text
assert "GitHub Pitfalls" in text
assert "Use gh carefully" not in text
assert "Full skill content is available to the agent" in text
assert result.raw_output is None
def test_build_tool_complete_for_execute_code_formats_output(self):
result = build_tool_complete("tc-code", "execute_code", '{"output":"hello\\n","exit_code":0}')
text = result.content[0].content.text
assert "Exit code: 0" in text
assert "hello" in text
assert result.raw_output is None
def test_build_tool_complete_for_execute_code_shows_truncation_metadata(self):
result = build_tool_complete(
"tc-code-truncated",
"execute_code",
(
'{"output":"HEAD\\n... [OUTPUT TRUNCATED - 10 bytes omitted out of 60 total] ...\\nTAIL",'
'"exit_code":0,'
'"stdout_truncated":true,'
'"stdout_bytes_captured":50,'
'"stdout_bytes_total":60,'
'"stdout_bytes_omitted":10,'
'"warning":"execute_code stdout was truncated; the script did run."}'
),
)
text = result.content[0].content.text
assert "Exit code: 0" in text
assert "Output truncated: captured 50 of 60 bytes (10 omitted)." in text
assert "Warning:" in text
assert "the script did run" in text
assert result.raw_output is None
def test_build_tool_complete_marks_success_false_as_failed(self):
result = build_tool_complete("tc-fail", "skill_manage", '{"success": false, "error": "boom"}')
assert result.status == "failed"
def test_build_tool_complete_marks_ok_false_as_failed(self):
result = build_tool_complete("tc-fail", "some_tool", '{"ok": false, "error": "boom"}')
assert result.status == "failed"
def test_build_tool_complete_marks_exit_code_nonzero_as_failed(self):
result = build_tool_complete("tc-fail", "terminal", '{"output": "bad", "exit_code": 2}')
assert result.status == "failed"
def test_build_tool_complete_marks_returncode_nonzero_as_failed(self):
result = build_tool_complete("tc-fail", "execute_code", '{"output": "bad", "returncode": 2}')
assert result.status == "failed"
def test_build_tool_complete_keeps_plain_error_text_completed(self):
result = build_tool_complete("tc-ok", "terminal", "tests failed: 1 assertion error")
assert result.status == "completed"
def test_build_tool_complete_marks_raised_exception_prefix_as_failed(self):
"""The agent's tool executor wraps raised exceptions in a canonical
"Error executing tool '<name>': ..." prefix. That prefix is unique to
the wrapper and means the tool blew up, so it must surface as failed
in Zed regardless of whether the body parses as JSON.
"""
result = build_tool_complete(
"tc-fail-exc",
"patch",
"Error executing tool 'patch': KeyError: 'foo'",
)
assert result.status == "failed"
def test_build_tool_complete_does_not_match_error_word_alone(self):
"""Bare 'Error: ...' messages (without the unique 'Error executing
tool '<name>':' prefix) must still be reported as completed — they
legitimately appear in compiler/linter/test output.
"""
result = build_tool_complete(
"tc-ok-error-word",
"terminal",
"Error: pytest collected 0 items",
)
assert result.status == "completed"
def test_build_tool_complete_marks_structured_polished_tool_error_as_failed(self):
result = build_tool_complete("tc-fail", "read_file", '{"error": "File not found"}')
assert result.status == "failed"
def test_build_tool_complete_keeps_json_error_without_failure_flag_completed(self):
result = build_tool_complete("tc-ok", "some_tool", '{"error": "timeout while reading optional source"}')
assert result.status == "completed"
def test_build_tool_complete_for_skill_manage_summarizes_without_raw_json(self):
result = build_tool_complete(
"tc-skill-manage",
"skill_manage",
'{"success":true,"message":"Patched references/hermes-acp-zed-rendering.md in skill \'hermes-agent-operations\' (1 replacement)."}',
function_args={
"action": "patch",
"name": "hermes-agent-operations",
"file_path": "references/hermes-acp-zed-rendering.md",
},
)
text = result.content[0].content.text
assert "**✅ Skill updated**" in text
assert "`patch`" in text
assert "`hermes-agent-operations`" in text
assert "references/hermes-acp-zed-rendering.md" in text
assert "{\"success\"" not in text
assert result.raw_output is None
def test_build_tool_complete_for_read_file_formats_content(self):
result = build_tool_complete(
"tc-read",
"read_file",
'{"content":"1|hello\\n2|world","total_lines":2}',
function_args={"path":"README.md","offset":1,"limit":20},
)
text = result.content[0].content.text
assert "Read README.md" in text
assert "```\n1|hello\n2|world\n```" in text
assert result.raw_output is None
def test_build_tool_complete_for_search_files_formats_matches(self):
result = build_tool_complete(
@ -495,77 +227,11 @@ class TestBuildToolComplete:
assert "Results truncated" in text
assert result.raw_output is None
def test_build_tool_complete_for_process_list_formats_table(self):
result = build_tool_complete(
"tc-process",
"process",
'{"processes":[{"session_id":"p1","status":"running","pid":123,"command":"npm run dev"}]}',
function_args={"action":"list"},
)
text = result.content[0].content.text
assert "Processes: 1" in text
assert "`p1`" in text
assert "npm run dev" in text
assert result.raw_output is None
def test_build_tool_complete_for_delegate_task_summarizes_children(self):
result = build_tool_complete(
"tc-delegate",
"delegate_task",
'{"results":[{"task_index":0,"status":"completed","summary":"Reviewed ACP rendering.","model":"gpt-5.5","duration_seconds":3.2,"tool_trace":[{"tool":"read_file"}]}],"total_duration_seconds":3.4}',
)
text = result.content[0].content.text
assert "Delegation results: 1 task" in text
assert "Reviewed ACP rendering" in text
assert "gpt-5.5" in text
assert "Tools: read_file" in text
assert result.raw_output is None
def test_build_tool_complete_for_session_search_recent(self):
result = build_tool_complete(
"tc-session",
"session_search",
'{"success":true,"mode":"recent","results":[{"session_id":"s1","title":"ACP work","last_active":"2026-05-02","message_count":12,"preview":"Polished tool rendering."}],"count":1}',
)
text = result.content[0].content.text
assert "Recent sessions" in text
assert "ACP work" in text
assert "Polished tool rendering" in text
assert result.raw_output is None
def test_build_tool_complete_for_memory_avoids_dumping_entries(self):
result = build_tool_complete(
"tc-memory",
"memory",
'{"success":true,"target":"user","entries":["private long memory"],"usage":"1% — 19/2000 chars","entry_count":1,"message":"Entry added."}',
function_args={"action":"add","target":"user","content":"User likes concise ACP rendering."},
)
text = result.content[0].content.text
assert "Memory add saved" in text
assert "User likes concise ACP rendering" in text
assert "private long memory" not in text
assert result.raw_output is None
def test_build_tool_complete_for_web_extract_success_stays_compact(self):
result = build_tool_complete(
"tc-web-extract",
"web_extract",
'{"results":[{"url":"https://example.com","title":"Example","content":"# Intro\\nThis is extracted content."}]}',
)
assert result.content is None
assert result.raw_output is None
def test_build_tool_complete_for_web_extract_error_shows_error(self):
result = build_tool_complete(
"tc-web-extract-error",
"web_extract",
'{"results":[{"url":"https://example.com","title":"Example","error":"timeout"}]}',
)
text = result.content[0].content.text
assert "Web extract failed" in text
assert "https://example.com" in text
assert "timeout" in text
assert result.raw_output is None
def test_build_tool_complete_generically_formats_unknown_json_dict_without_raw_output(self):
result = build_tool_complete(
@ -580,95 +246,12 @@ class TestBuildToolComplete:
assert "{\"results\"" not in text
assert result.raw_output is None
def test_build_tool_complete_generically_formats_unknown_json_list_without_raw_output(self):
result = build_tool_complete(
"tc-plugin-list",
"some_plugin_tool",
'[{"name":"alpha","status":"ok"},{"name":"beta","status":"ok"}]',
)
text = result.content[0].content.text
assert "some_plugin_tool: 2 items" in text
assert "alpha" in text
assert result.raw_output is None
def test_build_tool_complete_generically_formats_nested_json_without_inline_blob(self):
result = build_tool_complete(
"tc-recall-stats",
"memory_archive_stats",
'{"observations_by_status":{"active":12,"rejected":83},"capabilities":["sqlite-fts5-archive","hash-chain-audit"],"audit":{"ok":true,"count":208,"head":"abc123"}}',
)
text = result.content[0].content.text
assert "**observations_by_status:**" in text
assert "**active:** 12" in text
assert "**rejected:** 83" in text
assert "**capabilities:** 2 items" in text
assert "sqlite-fts5-archive" in text
assert "**audit:**" in text
assert "**ok:** True" in text
assert "{\"active\"" not in text
assert "[\"sqlite" not in text
assert result.raw_output is None
def test_build_tool_complete_for_search_files_files_only_formats_file_list(self):
result = build_tool_complete(
"tc-search-files",
"search_files",
'{"total_count":36,"files":["/home/nour/.hermes/config.yaml","/home/nour/.hermes/profiles/recall-test/config.yaml"],"truncated":true}',
)
text = result.content[0].content.text
assert "File search results" in text
assert "Found 36 files; showing 2." in text
assert "/home/nour/.hermes/config.yaml" in text
assert "use offset to page" in text
assert "{\"total_count\"" not in text
assert result.raw_output is None
def test_build_tool_complete_truncates_large_output(self):
"""Very large outputs should be truncated."""
big_output = "x" * 10000
result = build_tool_complete("tc-6", "read_file", big_output)
assert isinstance(result, ToolCallProgress)
display_text = result.content[0].content.text
assert len(display_text) < 6000
assert "truncated" in display_text
def test_build_tool_complete_for_patch_summarizes_without_repeating_diff(self):
"""Completed patch calls should not duplicate the edit-approval diff."""
patch_result = (
'{"success": true, "diff": "--- a/README.md\\n+++ b/README.md\\n@@ -1 +1,2 @@\\n old line\\n+new line\\n", '
'"files_modified": ["README.md"]}'
)
result = build_tool_complete("tc-p1", "patch", patch_result)
assert isinstance(result, ToolCallProgress)
assert len(result.content) == 1
item = result.content[0]
assert isinstance(item, ContentToolCallContent)
assert "✅ patch completed" in item.content.text
assert "README.md" in item.content.text
def test_build_tool_complete_for_patch_falls_back_to_text_when_no_diff(self):
result = build_tool_complete("tc-p2", "patch", '{"success": true}')
assert isinstance(result, ToolCallProgress)
assert isinstance(result.content[0], ContentToolCallContent)
def test_build_tool_complete_for_write_file_summarizes_without_repeating_diff(self, tmp_path):
target = tmp_path / "diff-test.txt"
snapshot = type("Snapshot", (), {"paths": [target], "before": {str(target): None}})()
target.write_text("hello from hermes\n", encoding="utf-8")
result = build_tool_complete(
"tc-wf1",
"write_file",
'{"bytes_written": 18, "dirs_created": false}',
function_args={"path": str(target), "content": "hello from hermes\n"},
snapshot=snapshot,
)
assert isinstance(result, ToolCallProgress)
assert len(result.content) == 1
item = result.content[0]
assert isinstance(item, ContentToolCallContent)
assert "✅ write_file completed" in item.content.text
assert "diff-test.txt" in item.content.text
# ---------------------------------------------------------------------------

91
tests/acp_adapter/test_acp_commands.py
View file

@ -135,56 +135,10 @@ async def test_acp_steer_slash_command_injects_into_running_agent():
assert fake.runs == []
@pytest.mark.asyncio
async def test_acp_steer_after_zed_interrupt_replays_interrupted_prompt_with_guidance():
acp_agent, state, fake, _conn = make_agent_and_state()
state.interrupted_prompt_text = "write hi to a text file"
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="/steer write HELLO instead")],
)
assert response.stop_reason == "end_turn"
assert fake.steers == []
assert fake.runs == [
"write hi to a text file\n\nUser correction/guidance after interrupt: write HELLO instead"
]
assert state.interrupted_prompt_text == ""
@pytest.mark.asyncio
async def test_acp_plain_correction_redirects_running_turn():
acp_agent, state, fake, _conn = make_agent_and_state()
state.is_running = True
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="No, use Postgres instead")],
)
assert response.stop_reason == "end_turn"
assert fake.redirects == ["No, use Postgres instead"]
assert state.queued_prompts == []
assert fake.runs == []
@pytest.mark.asyncio
async def test_acp_plain_correction_after_cancel_replays_original_prompt():
acp_agent, state, fake, _conn = make_agent_and_state()
state.interrupted_prompt_text = "implement it with SQLite"
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="No, use Postgres instead")],
)
assert response.stop_reason == "end_turn"
assert fake.runs == [
"implement it with SQLite\n\n"
"User correction/guidance after interrupt: No, use Postgres instead"
]
assert state.interrupted_prompt_text == ""
@pytest.mark.asyncio
@ -209,52 +163,7 @@ async def test_acp_cancel_publishes_hard_stop_while_holding_runtime_lock():
assert state.interrupted_prompt_text == "original request"
@pytest.mark.asyncio
async def test_acp_steer_on_idle_session_runs_as_regular_prompt():
# /steer on an idle session (no running turn, nothing to salvage) should
# run the steer payload as a normal user prompt — NOT silently append it
# to state.queued_prompts. Without this, users on Zed / other ACP clients
# see their /steer turn into "queued for the next turn" when they never
# typed /queue. Matches gateway/run.py ~L4898 idle-/steer behavior.
acp_agent, state, fake, _conn = make_agent_and_state()
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="/steer summarize the README")],
)
assert response.stop_reason == "end_turn"
assert fake.steers == []
assert fake.runs == ["summarize the README"]
assert state.queued_prompts == []
@pytest.mark.asyncio
async def test_acp_queue_slash_command_adds_next_turn_without_running_now():
acp_agent, state, fake, _conn = make_agent_and_state()
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="/queue run the tests after this")],
)
assert response.stop_reason == "end_turn"
assert state.queued_prompts == ["run the tests after this"]
assert fake.runs == []
@pytest.mark.asyncio
async def test_acp_prompt_drains_queued_turns_after_current_run():
acp_agent, state, fake, conn = make_agent_and_state()
state.queued_prompts.append("then run tests")
response = await acp_agent.prompt(
session_id=state.session_id,
prompt=[TextContentBlock(type="text", text="make the change")],
)
assert response.stop_reason == "end_turn"
assert fake.runs == ["make the change", "then run tests"]
assert state.queued_prompts == []
agent_messages = [u for _sid, u in conn.updates if getattr(u, "session_update", None) == "agent_message_chunk"]
assert len(agent_messages) >= 2

76
tests/acp_adapter/test_acp_images.py
View file

@ -59,23 +59,6 @@ def test_acp_resource_link_file_is_inlined_as_text(tmp_path):
)
def test_acp_embedded_text_resource_is_inlined_as_text():
content = _content_blocks_to_openai_user_content([
EmbeddedResourceContentBlock(
type="resource",
resource=TextResourceContents(
uri="file:///workspace/todo.txt",
mimeType="text/plain",
text="first\nsecond",
),
),
])
assert content == (
"[Attached file: todo.txt]\n"
"URI: file:///workspace/todo.txt\n\n"
"first\nsecond"
)
@pytest.mark.asyncio
@ -94,66 +77,7 @@ _ONE_PX_PNG = bytes.fromhex(
)
def test_acp_resource_link_image_file_is_inlined_as_image_url(tmp_path):
attached = tmp_path / "shot.png"
attached.write_bytes(_ONE_PX_PNG)
content = _content_blocks_to_openai_user_content([
TextContentBlock(type="text", text="Look at this screenshot"),
ResourceContentBlock(
type="resource_link",
name="shot.png",
uri=attached.as_uri(),
mimeType="image/png",
),
])
assert isinstance(content, list)
# [user text, image header, image_url]
assert content[0] == {"type": "text", "text": "Look at this screenshot"}
assert content[1]["type"] == "text"
assert "[Attached image: shot.png]" in content[1]["text"]
assert content[2]["type"] == "image_url"
expected_url = "data:image/png;base64," + base64.b64encode(_ONE_PX_PNG).decode("ascii")
assert content[2]["image_url"]["url"] == expected_url
def test_acp_resource_link_image_mime_inferred_from_suffix(tmp_path):
"""No mimeType sent — should still be recognised as image by file suffix."""
attached = tmp_path / "pic.jpg"
attached.write_bytes(_ONE_PX_PNG) # content doesn't matter for the code path
content = _content_blocks_to_openai_user_content([
ResourceContentBlock(
type="resource_link",
name="pic.jpg",
uri=attached.as_uri(),
),
])
assert isinstance(content, list)
image_parts = [p for p in content if p.get("type") == "image_url"]
assert len(image_parts) == 1
assert image_parts[0]["image_url"]["url"].startswith("data:image/jpeg;base64,")
def test_acp_embedded_blob_image_is_inlined_as_image_url():
b64 = base64.b64encode(_ONE_PX_PNG).decode("ascii")
content = _content_blocks_to_openai_user_content([
EmbeddedResourceContentBlock(
type="resource",
resource=BlobResourceContents(
uri="file:///tmp/embed.png",
mimeType="image/png",
blob=b64,
),
),
])
assert isinstance(content, list)
assert content[0]["type"] == "text"
assert "[Attached image: embed.png]" in content[0]["text"]
assert content[1] == {
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{b64}"},
}

21
tests/acp_adapter/test_detect_provider_entra.py
View file

@ -63,25 +63,4 @@ class TestDetectProviderEntra:
):
assert _acp_auth.detect_provider() is None
def test_missing_provider_returns_none(self):
"""A callable api_key without a provider is still ``None`` —
we don't synthesize a provider name from the credential shape."""
from acp_adapter import auth as _acp_auth
def _fake_runtime(**_kwargs):
return {"api_key": lambda: "jwt-fresh", "provider": ""}
with patch(
"hermes_cli.runtime_provider.resolve_runtime_provider",
side_effect=_fake_runtime,
):
assert _acp_auth.detect_provider() is None
def test_resolver_exception_returns_none(self):
from acp_adapter import auth as _acp_auth
with patch(
"hermes_cli.runtime_provider.resolve_runtime_provider",
side_effect=RuntimeError("simulated"),
):
assert _acp_auth.detect_provider() is None

2
tests/agent/test_auxiliary_client.py
View file

@ -3383,6 +3383,8 @@ class TestAuxiliaryClientPoisonedCacheEviction:
), patch(
"agent.auxiliary_client._try_payment_fallback",
return_value=(None, None, ""),
), patch(
"agent.auxiliary_client._TRANSIENT_RETRY_BACKOFF_BASE", 0.0
):
with pytest.raises(ConnectionError):
call_llm(

10
tests/agent/test_compression_concurrent_fork.py
View file

@ -63,7 +63,7 @@ def _build_agent_with_db(db: SessionDB, session_id: str):
compressor = MagicMock()
def _compress_with_overlap(*_a, **_kw):
time.sleep(0.25)
time.sleep(0.15)
return [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "user", "content": "tail"},
@ -527,7 +527,7 @@ def test_post_compress_exception_stops_lock_refresher(tmp_path: Path, monkeypatc
real_try_acquire = SessionDB.try_acquire_compression_lock
def _short_ttl(self, session_id: str, holder: str, ttl_seconds: float = 300.0) -> bool:
return real_try_acquire(self, session_id, holder, ttl_seconds=0.3)
return real_try_acquire(self, session_id, holder, ttl_seconds=0.15)
monkeypatch.setattr(SessionDB, "try_acquire_compression_lock", _short_ttl)
@ -536,8 +536,8 @@ def test_post_compress_exception_stops_lock_refresher(tmp_path: Path, monkeypatc
db.create_session(parent_sid, source="discord")
agent = _build_agent_with_db(db, parent_sid)
agent._compression_lock_ttl_seconds = 0.3
agent._compression_lock_refresh_interval = 0.1
agent._compression_lock_ttl_seconds = 0.15
agent._compression_lock_refresh_interval = 0.05
agent.context_compressor._last_summary_error = "summary failed"
agent._emit_warning = lambda *_a, **_k: (_ for _ in ()).throw(RuntimeError("warn boom"))
@ -546,7 +546,7 @@ def test_post_compress_exception_stops_lock_refresher(tmp_path: Path, monkeypatc
with pytest.raises(RuntimeError, match="warn boom"):
agent._compress_context(messages, "sys", approx_tokens=120_000)
time.sleep(0.45)
time.sleep(0.25)
assert db.try_acquire_compression_lock(parent_sid, "probe", ttl_seconds=1.0) is True

22
tests/computer_use/test_cua_atexit_teardown.py
View file

@ -30,30 +30,8 @@ class TestAtexitTeardown:
cu_tool._shutdown_backend_atexit()
fake.stop.assert_called_once()
def test_shutdown_clears_the_cached_backend(self):
"""After teardown the module cache is empty, so a later call re-spawns."""
fake = MagicMock()
with patch.object(cu_tool, "_backend", fake):
cu_tool._shutdown_backend_atexit()
assert cu_tool._backend is None
def test_shutdown_is_a_noop_when_never_started(self):
"""No backend was ever created => nothing to stop, no error."""
with patch.object(cu_tool, "_backend", None):
cu_tool._shutdown_backend_atexit() # must not raise
assert cu_tool._backend is None
def test_shutdown_swallows_backend_errors(self):
"""A failing stop() must not raise out of an atexit hook.
Exceptions escaping atexit print a traceback on every exit and can
mask the real exit status.
"""
fake = MagicMock()
fake.stop.side_effect = RuntimeError("driver already dead")
with patch.object(cu_tool, "_backend", fake):
cu_tool._shutdown_backend_atexit() # must not raise
assert cu_tool._backend is None
def test_hook_is_registered_with_atexit(self):
"""Importing the tool module registers the teardown hook.

23
tests/computer_use/test_cua_cli_fallback_env.py
View file

@ -56,26 +56,3 @@ def test_cli_fallback_strips_provider_secret_from_subprocess_env(monkeypatch):
assert captured["env"].get("PATH") == "/usr/bin:/bin"
def test_cli_fallback_applies_telemetry_policy(monkeypatch):
"""The env should also go through cua_driver_child_env(), like every
other cua-driver spawn site, not just _sanitize_subprocess_env alone."""
monkeypatch.delenv("HERMES_CUA_TELEMETRY", raising=False)
monkeypatch.setattr(
"tools.computer_use.cua_backend.resolve_cua_driver_cmd",
lambda: "/resolved/cua-driver",
)
captured = {}
def fake_run(cmd, **kwargs):
captured["env"] = kwargs.get("env")
return _fake_completed_process(json.dumps({"tree_markdown": "root"}))
monkeypatch.setattr("subprocess.run", fake_run)
session = _make_session()
session._call_tool_via_cli("list_windows", {}, timeout=5.0)
# cua_driver_child_env() injects this when telemetry is disabled
# (the default) — confirms the fallback goes through the same helper
# the sanctioned spawn site uses, not an ad hoc env dict.
assert captured["env"].get("CUA_DRIVER_RS_TELEMETRY_ENABLED") == "0"

86
tests/computer_use/test_cua_no_overlay.py
View file

@ -17,55 +17,16 @@ from tools.computer_use import cua_backend
class TestNoOverlayFlag:
def test_default_linux_headless_disables(self):
"""Auto-detect: Linux without DISPLAY => overlay disabled."""
with patch("hermes_cli.config.load_config", return_value={}), \
patch.object(sys, "platform", "linux"), \
patch.dict(os.environ, {}, clear=False):
os.environ.pop("DISPLAY", None)
assert cua_backend._cua_no_overlay() is True
def test_default_linux_desktop_enables(self):
"""Auto-detect: Linux with DISPLAY => overlay enabled."""
with patch("hermes_cli.config.load_config", return_value={}), \
patch.object(sys, "platform", "linux"), \
patch.dict(os.environ, {"DISPLAY": ":0"}):
assert cua_backend._cua_no_overlay() is False
def test_default_linux_wsl2_disables(self):
"""Auto-detect: WSL2 (microsoft in /proc/version) => overlay disabled."""
fake_version = "Linux version 5.15.0 (Microsoft@Microsoft.com)"
with patch("hermes_cli.config.load_config", return_value={}), \
patch.object(sys, "platform", "linux"), \
patch.dict(os.environ, {"DISPLAY": ":0"}), \
patch("builtins.open", mock_open(read_data=fake_version)):
assert cua_backend._cua_no_overlay() is True
def test_default_macos_disables(self):
"""Auto-detect: macOS => overlay disabled (idle CPU / #47032)."""
with patch("hermes_cli.config.load_config", return_value={}), \
patch.object(sys, "platform", "darwin"):
assert cua_backend._cua_no_overlay() is True
def test_default_windows_enables(self):
"""Auto-detect: Windows => overlay enabled."""
with patch("hermes_cli.config.load_config", return_value={}), \
patch.object(sys, "platform", "win32"):
assert cua_backend._cua_no_overlay() is False
def test_explicit_true_overrides(self):
with patch("hermes_cli.config.load_config",
return_value={"computer_use": {"no_overlay": True}}):
assert cua_backend._cua_no_overlay() is True
def test_explicit_false_overrides(self):
with patch("hermes_cli.config.load_config",
return_value={"computer_use": {"no_overlay": False}}), \
patch.object(sys, "platform", "linux"), \
patch.dict(os.environ, {}, clear=False):
os.environ.pop("DISPLAY", None)
# Explicit False overrides auto-detect on headless Linux.
assert cua_backend._cua_no_overlay() is False
def test_config_load_failure_falls_through_to_auto_detect(self):
"""Unreadable config => auto-detect (macOS defaults to disabled)."""
@ -74,18 +35,7 @@ class TestNoOverlayFlag:
patch.object(sys, "platform", "darwin"):
assert cua_backend._cua_no_overlay() is True
def test_macos_explicit_false_keeps_overlay(self):
with patch("hermes_cli.config.load_config",
return_value={"computer_use": {"no_overlay": False}}), \
patch.object(sys, "platform", "darwin"):
assert cua_backend._cua_no_overlay() is False
def test_missing_section_falls_through_to_auto_detect(self):
with patch("hermes_cli.config.load_config",
return_value={"other": {}}), \
patch.object(sys, "platform", "linux"), \
patch.dict(os.environ, {"DISPLAY": ":0"}):
assert cua_backend._cua_no_overlay() is False
class TestDriverSupportsNoOverlay:
@ -96,18 +46,7 @@ class TestDriverSupportsNoOverlay:
mock_run.return_value.stderr = ""
assert cua_backend._cua_driver_supports_no_overlay("cua-driver") is True
def test_returns_false_when_help_lacks_flag(self):
fake_help = "Usage: cua-driver [OPTIONS] COMMAND\n"
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = fake_help
mock_run.return_value.stderr = ""
cua_backend._cua_driver_supports_no_overlay.cache_clear()
assert cua_backend._cua_driver_supports_no_overlay("cua-driver") is False
def test_returns_false_on_subprocess_error(self):
with patch("subprocess.run", side_effect=FileNotFoundError("no such file")):
cua_backend._cua_driver_supports_no_overlay.cache_clear()
assert cua_backend._cua_driver_supports_no_overlay("cua-driver") is False
def test_help_probe_passes_sanitized_env(self):
"""The ``--help`` subprocess must not leak provider credentials
@ -176,26 +115,6 @@ class TestMcpInvocationUsesResolvedCommand:
# command, not the input driver_cmd argument.
mock_probe.assert_called_with("/opt/relocated/cua-driver")
def test_fallback_uses_input_driver_cmd_for_support_probe(self):
"""When the manifest knows the args but NOT the command, the
input ``driver_cmd`` parameter is what gets launched and
probed.
"""
from unittest.mock import patch
from tools.computer_use.cua_backend import _resolve_mcp_invocation
manifest = '{"mcp_invocation":{"args":["mcp"]}}'
with patch("subprocess.run", new=self._fake_run(stdout=manifest)), \
patch.object(cua_backend, "_cua_no_overlay", return_value=True), \
patch.object(
cua_backend, "_cua_driver_supports_no_overlay",
return_value=True,
) as mock_probe:
cua_backend._cua_driver_supports_no_overlay.cache_clear()
cmd, args = _resolve_mcp_invocation("/my/local/cua-driver")
assert cmd == "/my/local/cua-driver"
# Fallback path: probe runs against the input driver_cmd.
mock_probe.assert_called_with("/my/local/cua-driver")
def test_probe_distinguishes_support_between_binaries(self):
"""Different binaries must produce independent support verdicts.
@ -232,11 +151,6 @@ class TestMcpArgsOverlayFlag:
result = cua_backend._mcp_args_with_overlay_flag(["mcp"])
assert result == ["mcp"]
def test_not_appended_when_driver_unsupported(self):
with patch.object(cua_backend, "_cua_no_overlay", return_value=True), \
patch.object(cua_backend, "_cua_driver_supports_no_overlay", return_value=False):
result = cua_backend._mcp_args_with_overlay_flag(["mcp"])
assert result == ["mcp"]
def test_does_not_mutate_original_list(self):
original = ["mcp"]

18
tests/computer_use/test_cua_perf_knobs.py
View file

@ -11,12 +11,6 @@ def test_max_image_dimension_default():
assert cua_backend._computer_use_max_image_dimension() == 1456
def test_max_image_dimension_zero_disables():
with patch(
"hermes_cli.config.load_config",
return_value={"computer_use": {"max_image_dimension": 0}},
):
assert cua_backend._computer_use_max_image_dimension() is None
def test_capture_after_mode_default_som():
@ -24,20 +18,8 @@ def test_capture_after_mode_default_som():
assert cu_tool._capture_after_mode() == "som"
def test_capture_after_mode_ax_override():
with patch(
"hermes_cli.config.load_config",
return_value={"computer_use": {"capture_after_mode": "ax"}},
):
assert cu_tool._capture_after_mode() == "ax"
def test_capture_after_mode_invalid_falls_back_to_som():
with patch(
"hermes_cli.config.load_config",
return_value={"computer_use": {"capture_after_mode": "bogus"}},
):
assert cu_tool._capture_after_mode() == "som"
def test_aux_vision_route_caches_per_provider_model(monkeypatch):

36
tests/computer_use/test_cua_spawn_env_sanitization.py
View file

@ -146,42 +146,6 @@ def test_permissions_run_sanitizes_env(monkeypatch):
_assert_sanitized(captured)
def test_windows_status_hides_every_reachable_subprocess(monkeypatch):
"""The Desktop status API reaches only version + doctor spawns on Windows.
The permissions grant subprocess is intentionally excluded: its public
entry point returns before spawning anywhere except macOS, where
``CREATE_NO_WINDOW`` is not applicable.
"""
from tools.computer_use import permissions
binary = r"C:\Program Files\cua-driver\cua-driver.exe"
calls = []
stdout_by_args = {
("--version",): "cua-driver 1.2.3\n",
("doctor", "--json"): json.dumps({"ok": True, "probes": []}),
}
def fake_run(cmd, **kwargs):
calls.append((cmd, kwargs))
return _fake_completed_process(stdout_by_args[tuple(cmd[1:])])
monkeypatch.setattr(permissions.sys, "platform", "win32")
monkeypatch.setattr(permissions, "windows_hide_flags", lambda: CREATE_NO_WINDOW)
monkeypatch.setattr(permissions, "_resolve_driver_cmd", lambda command: binary)
monkeypatch.setattr(permissions.subprocess, "run", fake_run)
status = permissions.computer_use_status("cua-driver")
assert status["version"] == "cua-driver 1.2.3"
assert status["ready"] is True
assert [cmd[1:] for cmd, _ in calls] == [
["--version"],
["doctor", "--json"],
]
assert calls, "Windows status must exercise at least one subprocess boundary"
for cmd, kwargs in calls:
assert kwargs.get("creationflags") == CREATE_NO_WINDOW, cmd
def test_doctor_spawn_sanitizes_env_and_hides_console_on_windows(monkeypatch):

28
tests/computer_use/test_cua_telemetry.py
View file

@ -19,29 +19,18 @@ _VAR = "CUA_DRIVER_RS_TELEMETRY_ENABLED"
class TestTelemetryDisabledFlag:
def test_default_config_disables(self):
# cua_telemetry absent / False => telemetry disabled.
with patch("hermes_cli.config.load_config", return_value={}):
assert cua_backend._cua_telemetry_disabled() is True
def test_explicit_false_disables(self):
with patch("hermes_cli.config.load_config",
return_value={"computer_use": {"cua_telemetry": False}}):
assert cua_backend._cua_telemetry_disabled() is True
def test_opt_in_true_does_not_disable(self):
with patch("hermes_cli.config.load_config",
return_value={"computer_use": {"cua_telemetry": True}}):
assert cua_backend._cua_telemetry_disabled() is False
def test_config_load_failure_fails_safe(self):
# Unreadable config => default to disabling telemetry (privacy-safe).
with patch("hermes_cli.config.load_config", side_effect=RuntimeError("boom")):
assert cua_backend._cua_telemetry_disabled() is True
def test_missing_section_disables(self):
with patch("hermes_cli.config.load_config", return_value={"other": {}}):
assert cua_backend._cua_telemetry_disabled() is True
class TestChildEnv:
@ -52,18 +41,7 @@ class TestChildEnv:
# base env is preserved
assert env["PATH"] == "/usr/bin"
def test_opt_in_leaves_var_untouched(self):
# When the user opts in, we must NOT set the var — the driver uses its
# own default. If the base env already has a value, it is preserved.
with patch.object(cua_backend, "_cua_telemetry_disabled", return_value=False):
env = cua_backend.cua_driver_child_env({"PATH": "/usr/bin"})
assert _VAR not in env
def test_opt_in_preserves_user_set_var(self):
with patch.object(cua_backend, "_cua_telemetry_disabled", return_value=False):
env = cua_backend.cua_driver_child_env({_VAR: "1", "PATH": "/usr/bin"})
# user opted in and explicitly set it — don't clobber.
assert env[_VAR] == "1"
def test_disabled_overrides_inherited_enabled(self):
# Even if the parent process had telemetry enabled, the default policy
@ -72,9 +50,3 @@ class TestChildEnv:
env = cua_backend.cua_driver_child_env({_VAR: "1"})
assert env[_VAR] == "0"
def test_defaults_to_os_environ_when_no_base(self):
with patch.object(cua_backend, "_cua_telemetry_disabled", return_value=True), \
patch.dict("os.environ", {"SOME_MARKER": "yes"}, clear=False):
env = cua_backend.cua_driver_child_env()
assert env.get("SOME_MARKER") == "yes"
assert env[_VAR] == "0"

9
tests/computer_use/test_cua_wsl_manifest_path.py
View file

@ -14,17 +14,8 @@ def test_wsl_windows_manifest_path_translates_to_drvfs():
) == "/mnt/c/Users/Fernando/AppData/Local/cua-driver/cua-driver.exe"
def test_non_windows_path_is_unchanged_in_wsl():
with patch("hermes_constants.is_wsl", return_value=True):
assert cua_backend._wsl_windows_path_to_posix(
"/usr/local/bin/cua-driver"
) == "/usr/local/bin/cua-driver"
def test_windows_manifest_path_is_unchanged_outside_wsl():
path = r"D:\Tools\cua-driver.exe"
with patch("hermes_constants.is_wsl", return_value=False):
assert cua_backend._wsl_windows_path_to_posix(path) == path
def test_resolve_mcp_invocation_normalizes_windows_manifest_command_in_wsl():

242
tests/computer_use/test_doctor.py
View file

@ -144,13 +144,6 @@ class TestDoctorExitCodes:
code = doctor.run_doctor()
assert code == 1
def test_missing_binary_exits_2(self):
from tools.computer_use import doctor
with patch("shutil.which", return_value=None), \
patch("sys.stdout", new_callable=StringIO):
code = doctor.run_doctor()
assert code == 2
def test_protocol_error_exits_2(self, capsys):
"""An empty stdout response (driver crashed during handshake) is a
@ -195,28 +188,6 @@ class TestResponseShapeParsing:
assert "darwin" in text
assert "ok" in text
def test_falls_back_to_text_content_when_structuredContent_absent(self):
"""Older cua-driver builds may emit health_report as a text content
item carrying the JSON — the doctor should still parse it."""
from tools.computer_use import doctor
proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {}},
{
"jsonrpc": "2.0", "id": 2,
"result": {
"content": [
{"type": "text", "text": json.dumps(_ok_report())},
],
},
},
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", return_value=proc), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor()
assert code == 0
assert "ok" in out.getvalue()
def test_jsonrpc_error_response_exits_2(self, capsys):
from tools.computer_use import doctor
@ -270,23 +241,6 @@ class TestArgPassthrough:
call_payload = next(json.loads(w) for w in writes if "tools/call" in w)
assert call_payload["params"]["arguments"]["skip"] == ["bundle_identity"]
def test_no_filters_sends_empty_arguments(self):
"""When neither include nor skip is given, the arguments object is
empty — not present-but-null — so the driver's default 'run every
check' branch fires."""
from tools.computer_use import doctor
proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {}},
{"jsonrpc": "2.0", "id": 2, "result": {"structuredContent": _ok_report()}},
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", return_value=proc), \
patch("sys.stdout", new_callable=StringIO):
doctor.run_doctor()
writes = [call.args[0] for call in proc.stdin.write.call_args_list]
call_payload = next(json.loads(w) for w in writes if "tools/call" in w)
assert call_payload["params"]["arguments"] == {}
# ── json output ────────────────────────────────────────────────────────────
@ -420,146 +374,9 @@ class TestHealthReportFallback:
via check_permissions / list_apps / CLI --version instead.
"""
def test_isError_unclassified_uses_fallback_overall_ok(self):
from tools.computer_use import doctor
health_proc = _fake_proc_with_responses(
{
"jsonrpc": "2.0",
"id": 1,
"result": {"serverInfo": {"name": "cua-driver", "version": "0.10.0"}},
},
{"jsonrpc": "2.0", "id": 2, "result": _unclassified_health_result()},
)
probe_proc = _fake_proc_with_responses(
{
"jsonrpc": "2.0",
"id": 1,
"result": {"serverInfo": {"name": "cua-driver", "version": "0.10.0"}},
},
{"jsonrpc": "2.0", "id": 2, "result": _perms_ok_result()},
{"jsonrpc": "2.0", "id": 3, "result": _list_apps_ok_result()},
)
procs = iter([health_proc, probe_proc])
run_mock = MagicMock(
return_value=MagicMock(returncode=0, stdout="cua-driver 0.10.0\n", stderr=""),
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", side_effect=lambda *a, **k: next(procs)), \
patch("subprocess.run", run_mock), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(color=False)
assert code == 0
text = out.getvalue()
assert "ok" in text
assert "0.10.0" in text
# Fallback path must be visible in the check list
assert "health_report_path" in text
assert "fallback composite" in text
assert "tcc_accessibility" in text
assert "binary_version" in text
def test_isError_unclassified_json_payload_has_schema_and_fallback_flag(self):
from tools.computer_use import doctor
health_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"version": "0.10.0"}}},
{"jsonrpc": "2.0", "id": 2, "result": _unclassified_health_result()},
)
probe_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"version": "0.10.0"}}},
{"jsonrpc": "2.0", "id": 2, "result": _perms_ok_result()},
{"jsonrpc": "2.0", "id": 3, "result": _list_apps_ok_result()},
)
procs = iter([health_proc, probe_proc])
run_mock = MagicMock(
return_value=MagicMock(returncode=0, stdout="cua-driver 0.10.0\n", stderr=""),
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", side_effect=lambda *a, **k: next(procs)), \
patch("subprocess.run", run_mock), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(json_output=True)
assert code == 0
parsed = json.loads(out.getvalue())
assert parsed["schema_version"] == "1"
assert parsed["overall"] == "ok"
assert parsed.get("fallback") is True
names = [c["name"] for c in parsed["checks"]]
assert "binary_version" in names
assert "tcc_accessibility" in names
assert "tcc_screen_recording" in names
assert "ax_capability" in names
assert "health_report_path" in names
# Must not be the raw denial payload
assert "exit_code" not in parsed
def test_structuredContent_exit_code_only_triggers_fallback(self):
"""Even without isError, bare {exit_code:1} is not a valid report."""
from tools.computer_use import doctor
# Some gateways might drop isError but still ship exit_code-only SC.
health_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {}},
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"isError": False,
"structuredContent": {"exit_code": 1},
"content": [{"type": "text", "text": "Permission denied"}],
},
},
)
probe_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"version": "0.10.0"}}},
{"jsonrpc": "2.0", "id": 2, "result": _perms_ok_result()},
{"jsonrpc": "2.0", "id": 3, "result": _list_apps_ok_result()},
)
procs = iter([health_proc, probe_proc])
run_mock = MagicMock(
return_value=MagicMock(returncode=0, stdout="cua-driver 0.10.0\n", stderr=""),
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", side_effect=lambda *a, **k: next(procs)), \
patch("subprocess.run", run_mock), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(json_output=True)
assert code == 0
parsed = json.loads(out.getvalue())
assert parsed["schema_version"] == "1"
assert parsed.get("fallback") is True
def test_real_schema_version_1_preferred_over_fallback(self):
"""When health_report returns a real schema_version=1 payload, use it
and never call the composite fallback path."""
from tools.computer_use import doctor
proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {}},
{"jsonrpc": "2.0", "id": 2, "result": {"structuredContent": _ok_report()}},
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", return_value=proc), \
patch.object(doctor, "_compose_fallback_report") as fallback_mock, \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(json_output=True)
assert code == 0
fallback_mock.assert_not_called()
parsed = json.loads(out.getvalue())
# Upstream health_report keys pass through unchanged; Hermes adds
# only the additive hermes_identity envelope.
for key, value in _ok_report().items():
assert parsed[key] == value
assert "hermes_identity" in parsed
assert "fallback" not in parsed
def test_extract_raises_health_report_unavailable_on_isError(self):
from tools.computer_use import doctor
@ -568,44 +385,6 @@ class TestHealthReportFallback:
doctor._extract_health_report_from_result(_unclassified_health_result())
assert "Permission denied" in str(ei.value) or "unclassified" in str(ei.value).lower() or "risk" in str(ei.value).lower()
def test_fallback_degraded_when_accessibility_denied(self):
from tools.computer_use import doctor
health_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"version": "0.10.0"}}},
{"jsonrpc": "2.0", "id": 2, "result": _unclassified_health_result()},
)
denied_perms = {
"isError": False,
"structuredContent": {
"accessibility": False,
"screen_recording": False,
},
}
probe_proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"version": "0.10.0"}}},
{"jsonrpc": "2.0", "id": 2, "result": denied_perms},
{
"jsonrpc": "2.0",
"id": 3,
"result": {"isError": True, "content": [{"type": "text", "text": "no ax"}]},
},
)
procs = iter([health_proc, probe_proc])
run_mock = MagicMock(
return_value=MagicMock(returncode=0, stdout="cua-driver 0.10.0\n", stderr=""),
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", side_effect=lambda *a, **k: next(procs)), \
patch("subprocess.run", run_mock), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(json_output=True)
assert code == 1
parsed = json.loads(out.getvalue())
assert parsed["overall"] == "degraded"
assert parsed.get("fallback") is True
# ── binary identity (CLI --version vs health_report) ───────────────────────
@ -633,27 +412,6 @@ class TestDoctorVersionIdentity:
assert "version mismatch" in text.lower()
assert "0.5.8" in text # health_report value still shown
def test_json_includes_hermes_identity(self):
from tools.computer_use import doctor
proc = _fake_proc_with_responses(
{"jsonrpc": "2.0", "id": 1, "result": {}},
{"jsonrpc": "2.0", "id": 2, "result": {"structuredContent": _ok_report()}},
)
with patch("shutil.which", return_value="/fake/cua-driver"), \
patch("subprocess.Popen", return_value=proc), \
patch.object(doctor, "_read_cli_version", return_value="cua-driver 0.12.6"), \
patch("sys.stdout", new_callable=StringIO) as out:
code = doctor.run_doctor(json_output=True)
assert code == 0
payload = json.loads(out.getvalue())
assert payload["overall"] == "ok"
assert "hermes_identity" in payload
ident = payload["hermes_identity"]
assert ident["version_mismatch"] is True
assert "0.12.6" in (ident.get("cli_version") or "")
assert ident.get("health_report_driver_version") == "0.5.8"
assert ident.get("resolved_binary")
def test_matching_versions_no_mismatch_flag(self):
from tools.computer_use import doctor

34
tests/conformance/test_vector_generator.py
View file

@ -50,15 +50,6 @@ def test_oracles_importable_and_self_free():
assert isinstance(out, str) and out, platform
def test_generation_is_deterministic(tmp_path):
a, b = tmp_path / "a", tmp_path / "b"
generate(a)
generate(b)
for platform in PLATFORMS:
va = (a / f"{platform}.json").read_text(encoding="utf-8")
vb = (b / f"{platform}.json").read_text(encoding="utf-8")
# The oracle commit is identical within one checkout; whole file must be.
assert va == vb, f"{platform} vectors are nondeterministic"
def test_vector_files_shape(tmp_path):
@ -79,33 +70,8 @@ def test_vector_files_shape(tmp_path):
assert len(ids) == len(doc["vectors"])
def test_default_expectations_per_platform(tmp_path):
"""Telegram defaults to semantic (connector speaks HTML, native speaks
MarkdownV2); every other platform defaults to parity (same dialect)."""
generate(tmp_path)
tg = json.loads((tmp_path / "telegram.json").read_text(encoding="utf-8"))
assert all(v["expect"] != "parity" for v in tg["vectors"]), (
"telegram byte-parity is impossible across dialects — semantic/divergent only"
)
for platform in ("slack", "whatsapp"):
doc = json.loads((tmp_path / f"{platform}.json").read_text(encoding="utf-8"))
parity = [v for v in doc["vectors"] if v["expect"] == "parity"]
assert len(parity) > len(doc["vectors"]) * 0.7, f"{platform} should be mostly parity"
def test_scar_vectors_exercise_the_named_bugs(tmp_path):
"""The scar corpus must actually trigger the behaviors it memorializes."""
generate(tmp_path)
tg = {v["id"]: v for v in json.loads((tmp_path / "telegram.json").read_text(encoding="utf-8"))["vectors"]}
# MarkdownV2 reserved chars actually get escaped by the oracle.
assert "\\." in tg["mdv2-reserved-chars"]["native_output"] or "\\(" in tg["mdv2-reserved-chars"]["native_output"]
assert "\\_" in tg["mdv2-underscores"]["native_output"]
sl = {v["id"]: v for v in json.loads((tmp_path / "slack.json").read_text(encoding="utf-8"))["vectors"]}
assert sl["slack-bold-conversion"]["native_output"] == "*important* word"
assert sl["slack-link-conversion"]["native_output"] == "<https://example.com|click here>"
assert "&lt;!everyone&gt;" in sl["slack-broadcast-mention"]["native_output"]
wa = {v["id"]: v for v in json.loads((tmp_path / "whatsapp.json").read_text(encoding="utf-8"))["vectors"]}
assert wa["bold"]["native_output"] == "This is *bold* text."
def test_committed_vectors_match_regeneration(tmp_path):

139
tests/dashboard/test_ws_client_host.py
View file

@ -91,41 +91,13 @@ class TestResolveClientWsHost:
_set_bound(saved_app_state, "127.0.0.1")
assert web_server._resolve_client_ws_host() == "127.0.0.1"
def test_lan_bind_preserved(self, saved_app_state, clear_ws_host_env):
"""A non-loopback, non-wildcard bind must NOT be rewritten — the
operator chose that address deliberately (e.g. bridge networking in
a sidecar topology) and rewriting it to 127.0.0.1 would break their
setup."""
_set_bound(saved_app_state, "192.168.1.5")
assert web_server._resolve_client_ws_host() == "192.168.1.5"
def test_public_dns_bind_preserved(self, saved_app_state, clear_ws_host_env):
_set_bound(saved_app_state, "fly-app.example.dev")
assert web_server._resolve_client_ws_host() == "fly-app.example.dev"
def test_explicit_env_wins_over_wildcard(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "0.0.0.0")
assert web_server._resolve_client_ws_host() == "10.0.0.7"
def test_explicit_env_wins_over_lan_bind(
self, saved_app_state, monkeypatch
):
"""Even when the bind is a routable address, the explicit override
still wins — operators may want to bypass the bind address
altogether (e.g. to dial a different sidecar replica)."""
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "192.168.1.5")
assert web_server._resolve_client_ws_host() == "10.0.0.7"
def test_explicit_env_wins_over_loopback(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "127.0.0.1")
assert web_server._resolve_client_ws_host() == "10.0.0.7"
def test_blank_env_falls_back_to_bind(
self, saved_app_state, monkeypatch
@ -137,12 +109,6 @@ class TestResolveClientWsHost:
_set_bound(saved_app_state, "0.0.0.0")
assert web_server._resolve_client_ws_host() == "127.0.0.1"
def test_no_bound_host_returns_none(
self, saved_app_state, clear_ws_host_env
):
web_server.app.state.bound_host = None
web_server.app.state.bound_port = None
assert web_server._resolve_client_ws_host() is None
def test_bind_host_unchanged_after_wildcard_resolution(
self, saved_app_state, clear_ws_host_env
@ -161,15 +127,6 @@ class TestResolveClientWsHost:
class TestGatewayWsUrlHost:
def test_wildcard_bind_dials_loopback(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "0.0.0.0", port=9119)
url = web_server._build_gateway_ws_url()
assert url is not None
# ws://127.0.0.1:9119/api/ws?token=…
assert url.startswith("ws://127.0.0.1:9119/api/ws")
assert "0.0.0.0" not in url
def test_ipv6_wildcard_bind_dials_loopback(
self, saved_app_state, clear_ws_host_env
@ -181,59 +138,11 @@ class TestGatewayWsUrlHost:
# The ``::`` must not leak into the client URL.
assert "::" not in url
def test_loopback_bind_uses_loopback(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "127.0.0.1", port=8080)
url = web_server._build_gateway_ws_url()
assert url is not None
assert url.startswith("ws://127.0.0.1:8080/api/ws")
def test_lan_bind_preserved(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "192.168.1.5", port=9120)
url = web_server._build_gateway_ws_url()
assert url is not None
assert url.startswith("ws://192.168.1.5:9120/api/ws")
def test_explicit_env_overrides_wildcard(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "0.0.0.0", port=9119)
url = web_server._build_gateway_ws_url()
assert url is not None
assert url.startswith("ws://10.0.0.7:9119/api/ws")
assert "0.0.0.0" not in url
def test_explicit_env_overrides_lan(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "192.168.1.5", port=9120)
url = web_server._build_gateway_ws_url()
assert url is not None
assert url.startswith("ws://10.0.0.7:9120/api/ws")
def test_wildcard_keeps_query_string(
self, saved_app_state, clear_ws_host_env
):
"""Regression-guard: rewriting the host must not drop the
``?token=`` or ``?internal=`` credential."""
_set_bound(saved_app_state, "0.0.0.0", port=9119)
url = web_server._build_gateway_ws_url()
assert url is not None
assert "?" in url
# Loopback / ``--insecure`` path uses the session token.
assert f"token={web_server._SESSION_TOKEN}" in url
def test_no_bound_host_returns_none(
self, saved_app_state, clear_ws_host_env
):
web_server.app.state.bound_host = None
web_server.app.state.bound_port = None
assert web_server._build_gateway_ws_url() is None
# ---------------------------------------------------------------------------
@ -242,59 +151,11 @@ class TestGatewayWsUrlHost:
class TestSidecarUrlHost:
def test_wildcard_bind_dials_loopback(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "0.0.0.0", port=9119)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://127.0.0.1:9119/api/pub")
assert "0.0.0.0" not in url
assert "channel=ch-1" in url
def test_ipv6_wildcard_bind_dials_loopback(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "::", port=9119)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://127.0.0.1:9119/api/pub")
assert "::" not in url
def test_loopback_bind_uses_loopback(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "127.0.0.1", port=8080)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://127.0.0.1:8080/api/pub")
def test_lan_bind_preserved(
self, saved_app_state, clear_ws_host_env
):
_set_bound(saved_app_state, "192.168.1.5", port=9120)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://192.168.1.5:9120/api/pub")
def test_explicit_env_overrides_wildcard(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "0.0.0.0", port=9119)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://10.0.0.7:9119/api/pub")
assert "0.0.0.0" not in url
def test_explicit_env_overrides_lan(
self, saved_app_state, monkeypatch
):
monkeypatch.setenv("HERMES_DASHBOARD_WS_HOST", "10.0.0.7")
_set_bound(saved_app_state, "192.168.1.5", port=9120)
url = web_server._build_sidecar_url("ch-1")
assert url is not None
assert url.startswith("ws://10.0.0.7:9120/api/pub")
def test_no_bound_host_returns_none(
self, saved_app_state, clear_ws_host_env

17
tests/docker/test_config_migration.py
View file

@ -50,20 +50,3 @@ def test_config_migration_runs_on_boot(
)
def test_config_migration_opt_out_env_var_respected(
built_image: str, container_name: str,
) -> None:
"""HERMES_SKIP_CONFIG_MIGRATION=1 must skip the migration."""
start_container(
built_image, container_name, "HERMES_SKIP_CONFIG_MIGRATION=1",
)
# config.yaml should still be seeded (seeding is separate from migration)
r = docker_exec_sh(
container_name,
"test -f /opt/data/config.yaml && echo EXISTS || echo MISSING",
timeout=10,
)
assert "EXISTS" in r.stdout, (
f"config.yaml should be seeded even with migration skipped: {r.stdout}"
)

99
tests/docker/test_container_restart.py
View file

@ -75,50 +75,6 @@ def restart_container(request, built_image: str):
_docker("volume", "rm", "-f", volume)
def test_running_gateway_survives_container_restart(restart_container: str) -> None:
container = restart_container
# Create the profile + start its gateway. The Phase 4 hooks
# register the s6 service slot during create and the dispatch
# path brings it up via s6-svc -u.
r = docker_exec(container, "hermes", "profile", "create", "coder")
assert r.returncode == 0, f"profile create failed: {r.stderr}"
r = docker_exec(container, "hermes", "-p", "coder", "gateway", "start", timeout=60)
assert r.returncode == 0, f"gateway start failed: {r.stderr}"
# Give the service time to actually come up under supervision.
poll_container(container, "/command/s6-svstat /run/service/gateway-coder | grep -q 'up '")
# Persist state so the reconciler will treat the slot as 'running'
# post-restart. The gateway process itself writes gateway_state.json
# via gateway/status.py — but we don't want to wait for or assert
# against the live process here; just stamp the file directly to
# exercise the reconciler's contract.
write_state = (
"import json, pathlib; "
"p = pathlib.Path('/opt/data/profiles/coder/gateway_state.json'); "
"p.write_text(json.dumps({'gateway_state': 'running', 'timestamp': 1}))"
)
docker_exec(container, "python3", "-c", write_state, timeout=10).check_returncode()
# Restart. After this, /run/service/ is empty until cont-init.d
# runs the reconciler. We need to wait long enough for the
# reconciler to write coder's entry to the boot log AND for
# s6-svscan to spin up the service supervise tree from the
# restored slot. Polling the boot log gives us the first signal.
_docker("restart", container, timeout=60).check_returncode()
log = _wait_for_reconcile_log_mention(container, "coder", deadline_s=30.0)
assert "action=started" in log
# Service slot exists.
assert wait_for_path(
container, "/run/service/gateway-coder", kind="d", deadline_s=10.0,
), "slot not recreated after restart"
# No `down` marker — we asked for auto-start.
r = docker_exec_sh(container, "test -f /run/service/gateway-coder/down")
assert r.returncode != 0, "down marker present despite prior_state=running"
def test_stopped_gateway_stays_stopped_after_restart(restart_container: str) -> None:
@ -178,58 +134,3 @@ def test_stale_gateway_pid_cleaned_up_on_restart(restart_container: str) -> None
assert r.returncode != 0, "stale processes.json survived restart"
def test_live_gateway_autostarts_after_real_restart_without_manual_state_stamp(
restart_container: str,
) -> None:
"""End-to-end guard for issue #42675.
The other tests in this module stamp gateway_state.json directly to
exercise the reconciler's READ side. This one exercises the WRITE
side: a real, live gateway is killed by the container/s6 SIGTERM that
`docker restart` sends — no manual state stamp — and must come back up
on the next boot.
Before the fix, the shutdown handler unconditionally persisted
gateway_state=stopped on that SIGTERM, so the reconciler saw 'stopped'
and registered the slot DOWN — the gateway silently stayed dark after
every container restart. The fix classifies an unmarked SIGTERM as
signal-initiated and persists 'running' instead, so auto-start works.
"""
container = restart_container
docker_exec(container, "hermes", "profile", "create", "live").check_returncode()
r = docker_exec(container, "hermes", "-p", "live", "gateway", "start", timeout=60)
assert r.returncode == 0, f"gateway start failed: {r.stderr}"
# Wait for the gateway to actually come up under supervision AND write
# its own gateway_state=running (we do NOT stamp it ourselves).
poll_container(container, "/command/s6-svstat /run/service/gateway-live | grep -q 'up '")
# Confirm the gateway persisted its own 'running' state. The gateway has
# to boot Python, discover ~50 plugins, construct GatewayRunner, and
# reach write_runtime_status("running") at run.py start() — on a loaded
# CI runner with parallel docker test containers competing for CPU, this
# can take a while.
wait_for_log(container, "/opt/data/profiles/live/gateway_state.json", '"running"', deadline_s=45, interval_s=1)
# Real restart — Docker sends SIGTERM to PID 1; s6 propagates it to the
# supervised gateway. No planned-stop marker is written (this is not an
# operator `hermes gateway stop`), so the shutdown is signal-initiated.
_docker("restart", container, timeout=60).check_returncode()
log = _wait_for_reconcile_log_mention(container, "live", deadline_s=30.0)
# The crux: the reconciler must AUTO-START it, not register it down.
assert "action=started" in log, (
f"gateway did NOT auto-start after a real restart (issue #42675 "
f"regression): {log!r}"
)
# Slot recreated, and NO down marker (we expect auto-start).
assert wait_for_path(
container, "/run/service/gateway-live", kind="d", deadline_s=10.0,
), "slot not recreated after restart"
r = docker_exec_sh(container, "test -f /run/service/gateway-live/down")
assert r.returncode != 0, (
"down marker present despite a live gateway being restarted — "
"the signal-initiated shutdown wrongly persisted 'stopped' (#42675)"
)

149
tests/docker/test_dashboard.py
View file

@ -30,163 +30,14 @@ def test_dashboard_not_running_by_default(
)
def test_dashboard_slot_reports_down_when_disabled(
built_image: str, container_name: str,
) -> None:
"""Without HERMES_DASHBOARD, s6-svstat should report the dashboard
slot as DOWN (not up-with-sleep-infinity, which would
false-positive `hermes doctor` and any other health check).
Locks the PR #30136 review item I3 fix: cont-init.d/03-dashboard-toggle
writes a `down` marker file in the live service-dir when
HERMES_DASHBOARD is unset, so the slot reflects reality.
"""
start_container(built_image, container_name, cmd="sleep 60")
# /command/ isn't on PATH for docker-exec sessions, so call by
# absolute path.
r = docker_exec(
container_name, "/command/s6-svstat", "/run/service/dashboard",
)
assert r.returncode == 0, f"s6-svstat failed: {r.stderr!r} / {r.stdout!r}"
assert "down" in r.stdout, (
f"Dashboard slot should be 'down' without HERMES_DASHBOARD; "
f"svstat reports: {r.stdout!r}"
)
def test_dashboard_slot_reports_up_when_enabled(
built_image: str, container_name: str,
) -> None:
"""Symmetry: with HERMES_DASHBOARD=1, s6-svstat reports the slot as up."""
# The default dashboard host is 0.0.0.0, which now engages the
# OAuth auth gate. Without a provider registered (no
# HERMES_DASHBOARD_OAUTH_CLIENT_ID in this test env), start_server
# would fail closed and the slot would never come up. Pin the
# explicit insecure opt-in to keep this test focused on the s6
# supervision contract, not the auth gate.
start_container(
built_image, container_name,
"HERMES_DASHBOARD=1",
"HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin",
"HERMES_DASHBOARD_BASIC_AUTH_PASSWORD=test-dashboard-pw",
cmd="sleep 120",
)
# uvicorn takes a moment to bind; poll svstat.
poll_container(container_name, "/command/s6-svstat /run/service/dashboard | grep -q 'up '")
def test_dashboard_opt_in_starts(
built_image: str, container_name: str,
) -> None:
"""With HERMES_DASHBOARD=1, a dashboard process should be visible."""
# Default bind is 0.0.0.0, which engages the auth gate. Register the
# bundled basic password provider so the gate has a provider and the
# dashboard binds (vs fail-closed). Keeps the test focused on s6
# supervision, not auth.
start_container(
built_image, container_name,
"HERMES_DASHBOARD=1",
"HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin",
"HERMES_DASHBOARD_BASIC_AUTH_PASSWORD=test-dashboard-pw",
cmd="sleep 120",
)
# Poll for the dashboard subprocess to appear — the entrypoint
# backgrounds it and bootstrap (skills sync etc.) can take a few
# seconds before the python process actually launches.
ok, _ = poll_container(
container_name, "pgrep -f 'hermes dashboard'", deadline_s=30.0,
)
assert ok, "Dashboard should be running with HERMES_DASHBOARD=1"
def test_dashboard_port_override(
built_image: str, container_name: str,
) -> None:
"""HERMES_DASHBOARD_PORT changes the dashboard's listen port."""
# Default bind is 0.0.0.0; register the basic password provider so
# the auth gate has a provider and the dashboard binds. See
# test_dashboard_slot_reports_up_when_enabled for the full rationale.
start_container(
built_image, container_name,
"HERMES_DASHBOARD=1",
"HERMES_DASHBOARD_PORT=9120",
"HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin",
"HERMES_DASHBOARD_BASIC_AUTH_PASSWORD=test-dashboard-pw",
cmd="sleep 120",
)
# The dashboard process appearing in pgrep doesn't mean it's bound
# to the port yet — uvicorn takes another second or two to come up.
# The image doesn't ship ss/netstat, so probe /proc/net/tcp directly:
# port 9120 = 0x23A0, state 0A = LISTEN.
ok, stdout = poll_container(
container_name,
"grep -E ' 0+:23A0 .* 0A ' /proc/net/tcp /proc/net/tcp6 "
"2>/dev/null",
deadline_s=60.0,
)
assert ok, f"Dashboard not listening on port 9120: stdout={stdout!r}"
def test_dashboard_restarts_after_crash(
built_image: str, container_name: str,
) -> None:
"""Phase 2 invariant: under s6 supervision, killing the dashboard
process should be recovered automatically.
Pre-s6 (tini) behavior was "stays dead" — the test wouldn't have
passed against that image. After the s6-overlay migration the
dashboard runs as a longrun s6-rc service and s6-supervise restarts
it after a ~1s backoff (the default).
"""
# Default bind is 0.0.0.0; register the basic password provider so
# the auth gate has a provider and the supervised dashboard binds.
# See test_dashboard_slot_reports_up_when_enabled for the full
# rationale.
start_container(
built_image, container_name,
"HERMES_DASHBOARD=1",
"HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin",
"HERMES_DASHBOARD_BASIC_AUTH_PASSWORD=test-dashboard-pw",
cmd="sleep 120",
)
# Wait for the first dashboard to come up.
ok, _ = poll_container(
container_name, "pgrep -f 'hermes dashboard'", deadline_s=30.0,
)
assert ok, "Dashboard never started initially"
# Grab the initial PID. s6 may briefly transition through restart
# state between our poll-success and the follow-up pgrep, so retry
# a couple of times before giving up.
first_pid: str | None = None
for _attempt in range(10):
first_pid_result = docker_exec(
container_name, "pgrep", "-f", "hermes dashboard",
)
first_pids = first_pid_result.stdout.strip().split()
if first_pids:
first_pid = first_pids[0]
break
time.sleep(0.5)
assert first_pid is not None, "Could not capture initial dashboard PID"
# Kill the dashboard. The dashboard process runs as hermes, so the
# hermes user can kill it (same UID).
docker_exec(container_name, "kill", "-9", first_pid)
# s6 backs off ~1s before restart; allow up to 15s for the new
# process to appear with a different PID.
deadline = time.monotonic() + 15.0
while time.monotonic() < deadline:
r = docker_exec(container_name, "pgrep", "-f", "hermes dashboard")
pids = r.stdout.strip().split() if r.returncode == 0 else []
if pids and pids[0] != first_pid:
return # success
time.sleep(0.5)
raise AssertionError(
f"Dashboard not restarted after kill (first_pid={first_pid})"
)
# ---------------------------------------------------------------------------

96
tests/docker/test_docker_exec_privilege_drop.py
View file

@ -146,106 +146,10 @@ def test_shim_drops_root_to_hermes_uid(sleep_container: str) -> None:
)
def test_shim_short_circuits_for_non_root_exec(sleep_container: str) -> None:
"""docker exec --user hermes already runs as 10000; shim should be a no-op.
Verified indirectly: the command must still succeed end-to-end. If the
shim incorrectly tried to drop privileges a second time (e.g. by
invoking s6-setuidgid which requires root), it would fail with
EPERM. A clean success proves the short-circuit fired.
"""
subprocess.run(
["docker", "exec", "--user", "root", sleep_container,
"rm", "-f", "/opt/data/config.yaml"],
capture_output=True, check=False,
)
r = subprocess.run(
["docker", "exec", "--user", "hermes", sleep_container,
"hermes", "config", "set", "_test.shim_short_circuit", "1"],
capture_output=True, text=True, timeout=30,
)
assert r.returncode == 0, (
f"docker exec --user hermes failed: {r.stderr!r} stdout={r.stdout!r}. "
"If the shim mis-handled the non-root path, this would fail with EPERM."
)
# File still ends up hermes:hermes — orthogonally confirms uid.
r = subprocess.run(
["docker", "exec", sleep_container,
"stat", "-c", "%U:%G", "/opt/data/config.yaml"],
capture_output=True, text=True, timeout=10,
)
assert r.stdout.strip() == "hermes:hermes"
def test_shim_opt_out_keeps_root(sleep_container: str) -> None:
"""HERMES_DOCKER_EXEC_AS_ROOT=1 should suppress the privilege drop.
Reserved for diagnostic sessions where the operator deliberately
wants root semantics. Verified by writing a file and checking its
owner.
"""
subprocess.run(
["docker", "exec", "--user", "root", sleep_container,
"rm", "-f", "/opt/data/config.yaml"],
capture_output=True, check=False,
)
r = subprocess.run(
["docker", "exec",
"-e", "HERMES_DOCKER_EXEC_AS_ROOT=1",
sleep_container,
"hermes", "config", "set", "_test.opt_out", "1"],
capture_output=True, text=True, timeout=30,
)
assert r.returncode == 0, f"opt-out invocation failed: {r.stderr}"
r = subprocess.run(
["docker", "exec", sleep_container,
"stat", "-c", "%U:%G", "/opt/data/config.yaml"],
capture_output=True, text=True, timeout=10,
)
assert r.stdout.strip() == "root:root", (
f"With HERMES_DOCKER_EXEC_AS_ROOT=1, expected root:root, "
f"got {r.stdout.strip()!r}"
)
@pytest.mark.parametrize("falsy_value", ["0", "false", "no", "", "garbage", "2"])
def test_shim_opt_out_strict_truthiness(
sleep_container: str, falsy_value: str,
) -> None:
"""Anything other than 1/true/yes (case-insensitive) does NOT opt out.
Strict truthiness so a typo (``HERMES_DOCKER_EXEC_AS_ROOT=0``) doesn't
silently keep the user as root. Mirrors the policy used by
``HERMES_GATEWAY_NO_SUPERVISE`` in #33583.
"""
subprocess.run(
["docker", "exec", "--user", "root", sleep_container,
"rm", "-f", "/opt/data/config.yaml"],
capture_output=True, check=False,
)
r = subprocess.run(
["docker", "exec",
"-e", f"HERMES_DOCKER_EXEC_AS_ROOT={falsy_value}",
sleep_container,
"hermes", "config", "set", "_test.falsy", "1"],
capture_output=True, text=True, timeout=30,
)
assert r.returncode == 0, f"falsy value {falsy_value!r} caused failure: {r.stderr}"
r = subprocess.run(
["docker", "exec", sleep_container,
"stat", "-c", "%U:%G", "/opt/data/config.yaml"],
capture_output=True, text=True, timeout=10,
)
assert r.stdout.strip() == "hermes:hermes", (
f"falsy opt-out value {falsy_value!r} unexpectedly suppressed the drop; "
f"file owner is {r.stdout.strip()!r}, expected hermes:hermes"
)
def test_main_cmd_path_unaffected(built_image: str) -> None:

116
tests/docker/test_gateway_bootstrap_state.py
View file

@ -57,65 +57,6 @@ def test_seeds_running_state_on_blank_volume(
)
def test_does_not_clobber_existing_state(
built_image: str, container_name: str,
) -> None:
"""An existing gateway_state.json must never be overwritten by the
seed, even when the bootstrap env var says running.
We use a named volume so we can pre-create the state file before
the container boots. The [ ! -f ] guard in stage2 must skip seeding
because the file already exists. We check the file immediately after
boot — before the gateway service has a chance to write its own
state — by reading it as fast as possible after container start.
"""
import json as _json
volume = f"{container_name}-vol"
subprocess.run(
["docker", "volume", "create", volume],
check=True, capture_output=True, timeout=10,
)
# Pre-create the state file via a throwaway container
existing = _json.dumps({"gateway_state": "stopped", "pid": 123})
subprocess.run(
["docker", "run", "--rm", "-v", f"{volume}:/opt/data",
"--entrypoint", "sh", built_image,
"-c", f"printf '{existing}\\n' > /opt/data/gateway_state.json"],
check=True, capture_output=True, timeout=30,
)
# Boot with the env var set — stage2 must NOT clobber the existing file
subprocess.run(
["docker", "run", "-d", "--name", container_name,
"-v", f"{volume}:/opt/data",
"-e", "HERMES_GATEWAY_BOOTSTRAP_STATE=running",
built_image, "sleep", "infinity"],
check=True, capture_output=True, timeout=60,
)
# Read the file as quickly as possible — the gateway service may
# start and write its own state, but the stage2 [ ! -f ] guard runs
# during cont-init (before any service starts), so the file must
# still be our "stopped" state at this point.
wait_for_container_ready(container_name)
r = docker_exec_sh(
container_name, "cat /opt/data/gateway_state.json", timeout=10,
)
state = _json.loads(r.stdout.strip())
assert state.get("gateway_state") == "stopped", (
f"existing state was clobbered by bootstrap seed: {state}"
)
# Cleanup
subprocess.run(
["docker", "rm", "-f", container_name],
capture_output=True, timeout=10,
)
subprocess.run(
["docker", "volume", "rm", "-f", volume],
capture_output=True, timeout=10,
)
def test_no_seed_when_env_unset(
@ -255,60 +196,3 @@ def test_does_not_seed_gateway_state_through_symlink(
pass
def test_does_not_seed_auth_json_through_symlink(
built_image: str, container_name: str,
) -> None:
"""A symlinked auth.json must not become a host write.
Same guard as gateway_state.json — the auth.json seed must also
respect path_has_symlink_component and refuse to write through
the symlink.
"""
tmp = tempfile.mkdtemp()
host_data: Path | None = None
tmp_path = Path(tmp)
try:
host_data = tmp_path / "data"
host_data.mkdir()
subprocess.run(
["docker", "run", "--rm",
"-v", f"{host_data}:/opt/data",
"--entrypoint", "sh", built_image,
"-c", "ln -s /tmp/outside-auth.json /opt/data/auth.json"],
check=True, capture_output=True, timeout=30,
)
_boot_with_bind_mount(
built_image, container_name, host_data,
'HERMES_AUTH_JSON_BOOTSTRAP={"api_key":"test"}',
)
# The symlink must still exist
r = docker_exec_sh(
container_name,
"test -L /opt/data/auth.json && echo SYMLINK || echo NOT_SYMLINK",
timeout=5,
)
assert "SYMLINK" in r.stdout, (
f"auth.json symlink was replaced by a regular file: {r.stdout}"
)
# The refusal warning goes to stdout (docker logs), not
# container-boot.log (which is written by container_boot.py).
r = subprocess.run(
["docker", "logs", container_name],
capture_output=True, text=True, timeout=10,
)
combined = r.stdout + r.stderr
assert "refusing" in combined and "auth.json" in combined, (
f"expected symlink refusal warning for auth.json in docker logs: {combined}"
)
finally:
if host_data is not None:
_cleanup_bind_mount(built_image, container_name, host_data)
try:
host_data.rmdir()
tmp_path.rmdir()
except OSError:
pass

169
tests/docker/test_gateway_run_supervised.py
View file

@ -166,114 +166,11 @@ def test_gateway_run_redirects_to_supervised(
)
def test_gateway_run_no_supervise_flag_preserves_legacy_behavior(
built_image: str, container_name: str,
) -> None:
"""``docker run <image> gateway run --no-supervise`` opts out of
the redirect and runs the gateway as the foreground CMD process
(pre-s6 semantics).
With the redirect in place, the container's CMD process would be
``sleep infinity`` and the supervised gateway would be a separate
process under ``s6-supervise gateway-default``. WITHOUT the
redirect (opt-out path), there's no supervised gateway slot at
all — the gateway IS the CMD process.
Three positive assertions confirm we took the pre-s6 path:
* The CMD process is a python ``hermes gateway run`` invocation
(not ``sleep infinity``).
* The ``gateway-default`` s6 service slot is NOT created.
* No supervision-redirect breadcrumb appears in docker logs.
"""
start_container(built_image, container_name, cmd="gateway run --no-supervise")
# Wait for the gateway to start in the foreground or the container
# to exit (no-config crash is also valid pre-s6 semantics).
# A fixed time.sleep(6) races under CI parallel docker load —
# the gateway can take well over 6s to finish Python imports.
status = _wait_for_gateway_or_exit(container_name, deadline_s=60.0)
# No redirect breadcrumb anywhere.
logs = subprocess.run(
["docker", "logs", container_name],
capture_output=True, text=True, timeout=10,
).stdout + subprocess.run(
["docker", "logs", container_name],
capture_output=True, text=True, timeout=10,
).stderr
assert "s6 supervision" not in logs, (
f"--no-supervise should have skipped the redirect; "
f"breadcrumb in logs:\n{logs}"
)
if status == "running":
# Gateway running in foreground — the CMD process should be
# the gateway itself, NOT a sleep-infinity heartbeat.
r = docker_exec_sh(
container_name,
"ps -eo pid,ppid,cmd | grep -v grep | awk '/main-wrapper.sh|rc.init top/ { wrapper_pid=$1 } "
"$3==\"sleep\" && $4==\"infinity\" && $2==wrapper_pid { c++ } END { print c+0 }'",
)
assert r.returncode == 0
redirected_sleeps = int(r.stdout.strip() or 0)
assert redirected_sleeps == 0, (
f"--no-supervise: expected NO `sleep infinity` parented to "
f"the CMD wrapper (foreground gateway should be the CMD), "
f"found {redirected_sleeps}. "
f"ps:\n{docker_exec_sh(container_name, 'ps -eo pid,ppid,cmd').stdout}"
)
# The gateway-default s6 slot exists (the cont-init.d
# reconciler creates it on every boot regardless of opt-out)
# but should NOT have its want-state set to "up" — the
# opt-out path doesn't dispatch `start` to s6.
assert not _svstat_wants_up(container_name, "gateway-default"), (
"--no-supervise: gateway-default slot has want-state up, "
"implying the redirect dispatched `start` despite the "
f"opt-out. svstat:\n{_svstat(container_name)!r}"
)
# If status == "exited" instead, the gateway exited (also valid
# pre-s6 semantics). The breadcrumb-absence check above is
# already enough to confirm the redirect didn't fire.
def test_gateway_run_no_supervise_env_var(
built_image: str, container_name: str,
) -> None:
"""Env-var opt-out works identically to the CLI flag.
Useful when users can't easily change their `docker run` args
(orchestration templates, K8s manifests) but can set env vars.
"""
start_container(
built_image, container_name,
"HERMES_GATEWAY_NO_SUPERVISE=1",
cmd="gateway run",
)
# Same as the CLI-flag test: wait for the gateway to start or
# the container to exit, instead of a blind time.sleep(6).
status = _wait_for_gateway_or_exit(container_name, deadline_s=60.0)
logs = subprocess.run(
["docker", "logs", container_name],
capture_output=True, text=True, timeout=10,
)
combined = logs.stdout + logs.stderr
assert "s6 supervision" not in combined, (
f"env-var opt-out should have skipped the redirect; "
f"breadcrumb in logs:\n{combined}"
)
# Same as the CLI-flag test: the slot exists (reconciler creates
# it) but should not have want-state up.
if status == "running":
assert not _svstat_wants_up(container_name, "gateway-default"), (
"HERMES_GATEWAY_NO_SUPERVISE=1: gateway-default has "
"want-state up, implying the redirect dispatched `start` "
f"despite the env-var opt-out. svstat:\n{_svstat(container_name)!r}"
)
def test_supervised_gateway_does_not_recurse(
@ -397,69 +294,3 @@ def test_dashboard_supervised_when_env_set(
)
def test_supervised_gateway_stdout_reaches_docker_logs(
built_image: str, container_name: str,
) -> None:
"""The supervised gateway's stdout — including the rich-console
startup banner — must reach ``docker logs``, not just the rotated
log file under ``${HERMES_HOME}/logs/gateways/<profile>/current``.
Without the ``1`` action directive in ``_render_log_run``, s6-log
swallows the gateway's stdout into the file and ``docker logs``
only sees stderr (Python ``logging`` defaults to stderr). That's
a poor user experience: the iconic "Hermes Gateway Starting…"
banner with the ⚕ symbol is the most visible "yes, your gateway
started" signal, and forcing users to ``docker exec`` + ``tail``
the log file just to see it is friction users don't expect.
With the ``1`` directive, s6-log forwards every line to its own
stdout (which propagates up through the s6-supervise pipeline to
/init's stdout = container stdout = ``docker logs``) AND also
writes a timestamped copy to the rotated file. Best of both.
We assert by looking for the literal banner glyph (``⚕``) — a
distinctive character that won't appear in stderr-routed
Python-logging output, so its presence in ``docker logs`` proves
the stdout-tee is working.
"""
start_container(built_image, container_name, cmd="gateway run")
# Poll docker logs for the banner glyph (⚕) or "Hermes Gateway
# Starting" — the gateway's rich-console startup banner. A fixed
# sleep(8) races under CI parallel docker test fan-out: the
# supervised gateway can take well over 8s to finish imports +
# config-load + banner print under load, and the assertion would
# fail not because the stdout-tee is broken but because we checked
# too early. Polling with a generous deadline is both faster on
# quick machines and flake-free on slow ones.
wait_for_docker_logs(container_name, "⚕", deadline_s=60.0)
logs = subprocess.run(
["docker", "logs", container_name],
capture_output=True, text=True, timeout=10,
)
combined = logs.stdout + logs.stderr
# The banner ⚕ symbol is the load-bearing assertion — it's unique
# to gateway startup stdout output and won't appear in stderr
# (Python logging) or s6 boot messages.
assert "⚕" in combined or "Hermes Gateway Starting" in combined, (
"Supervised gateway's stdout banner did not reach docker logs. "
"This means the `1` action directive in _render_log_run isn't "
"forwarding stdout to /init. "
f"docker logs (last 2000 chars):\n{combined[-2000:]}\n"
f"file contents:\n{docker_exec_sh(container_name, 'cat /opt/data/logs/gateways/default/current').stdout}"
)
# Cross-check: the same banner must also be in the rotated log
# file (we kept the file destination, just added stdout). The
# file version has s6-log's ISO 8601 timestamp prefix; the
# docker logs version is raw.
file_contents = docker_exec_sh(
container_name, "cat /opt/data/logs/gateways/default/current",
).stdout
assert "⚕" in file_contents or "Hermes Gateway Starting" in file_contents, (
"Banner also missing from rotated log file — the file "
"destination may have been dropped by the new s6-log script. "
f"File contents:\n{file_contents}"
)

24
tests/docker/test_home_override_scripts.py
View file

@ -14,30 +14,6 @@ import subprocess
from tests.docker.conftest import docker_exec, docker_exec_sh, start_container, restart_container
def test_main_wrapper_preserves_docker_workdir(
built_image: str, container_name: str,
) -> None:
"""The main-wrapper MUST save and restore the original working directory
so the container starts in the Docker ``-w`` directory, not /opt/data.
Regression test for #35472. We pass ``-w /tmp`` and a command that
prints its cwd; the output must be ``/tmp``, proving the wrapper
restored the cwd after its internal ``cd /opt/data``.
"""
r = subprocess.run(
["docker", "run", "--rm", "-w", "/tmp",
built_image, "sh", "-c", "pwd"],
capture_output=True, text=True, timeout=60,
)
assert r.returncode == 0, f"container failed: {r.stderr[-1000:]}"
# The stage2 hook emits boot logs (config migration, skills sync)
# to stdout before the CMD runs. The actual pwd output is the LAST
# line of stdout.
last_line = r.stdout.strip().split("\n")[-1].strip()
assert last_line == "/tmp", (
f"expected cwd /tmp, got {last_line!r} — "
f"main-wrapper did not preserve the Docker -w directory"
)
def test_dashboard_service_resets_home(

30
tests/docker/test_immutable_install.py
View file

@ -74,36 +74,6 @@ def test_hermes_disable_lazy_installs_and_dont_write_bytecode(
)
def test_install_method_stamp_is_code_scoped(
built_image: str, container_name: str,
) -> None:
"""The 'docker' install-method stamp must be baked at
/opt/hermes/.install_method (code-scoped), NOT in $HERMES_HOME."""
start_container(built_image, container_name)
# Code-scoped stamp must exist and say "docker"
r = docker_exec_sh(
container_name,
"cat /opt/hermes/.install_method",
timeout=10,
)
assert r.returncode == 0, (
f"/opt/hermes/.install_method not found: {r.stderr}"
)
assert r.stdout.strip() == "docker", (
f"expected 'docker' stamp, got: {r.stdout.strip()!r}"
)
# $HERMES_HOME must NOT have a 'docker' stamp
r = docker_exec_sh(
container_name,
"cat /opt/data/.install_method 2>/dev/null || echo NONE",
timeout=10,
)
assert r.stdout.strip() != "docker", (
"$HERMES_HOME/.install_method is stamped 'docker' - stage2 must "
"not stamp the data volume (shared with host installs)"
)
def test_stale_docker_stamp_in_home_is_healed_on_boot(

45
tests/docker/test_log_dir_seed.py
View file

@ -51,48 +51,3 @@ def test_logs_gateways_seeded_and_hermes_owned(
)
def test_logs_gateways_healed_when_parent_root_owned(
built_image: str, container_name: str,
) -> None:
"""Warm-boot stage2 must heal root-owned logs/gateways (#45258).
Mimics a poisoned volume: HERMES_HOME already hermes-owned (so the
bulk data-volume chown is skipped) while logs/gateways is root-owned.
Restartable log/run no longer root-chowns that path (symlink TOCTOU),
so stage2 must repair the parent on every boot.
"""
start_container(built_image, container_name)
poison = docker_exec_sh(
container_name,
"chown root:root /opt/data/logs/gateways && "
'home_owner=$(stat -c "%U" /opt/data); '
'gateways_owner=$(stat -c "%U" /opt/data/logs/gateways); '
'echo "home=$home_owner gateways=$gateways_owner"',
user="root",
timeout=10,
)
assert poison.returncode == 0, (poison.stdout, poison.stderr)
assert "home=hermes" in poison.stdout, poison.stdout
assert "gateways=root" in poison.stdout, poison.stdout
denied = docker_exec_sh(
container_name,
"mkdir -p /opt/data/logs/gateways/poison-probe 2>/dev/null "
"&& echo MKDIR_OK || echo MKDIR_DENIED",
timeout=10,
)
assert "MKDIR_DENIED" in denied.stdout, denied.stdout
restart_container(container_name)
healed = docker_exec_sh(
container_name,
'gateways_owner=$(stat -c "%U" /opt/data/logs/gateways); '
"mkdir -p /opt/data/logs/gateways/poison-probe && "
'echo "gateways=$gateways_owner MKDIR_OK"',
timeout=10,
)
assert healed.returncode == 0, (healed.stdout, healed.stderr)
assert "gateways=hermes" in healed.stdout, healed.stdout
assert "MKDIR_OK" in healed.stdout, healed.stdout

11
tests/docker/test_main_invocation.py
View file

@ -43,17 +43,6 @@ def test_chat_subcommand_passthrough(built_image: str) -> None:
assert "chat" in combined or "usage" in combined
def test_bare_executable_passthrough(built_image: str) -> None:
"""``docker run <image> sleep 1`` should exec ``sleep`` directly.
The entrypoint detects that ``sleep`` is on PATH and routes around the
hermes wrapper. Useful for long-lived sandbox mode and for testing.
"""
r = subprocess.run(
["docker", "run", "--rm", built_image, "sleep", "1"],
capture_output=True, text=True, timeout=30,
)
assert r.returncode == 0
def test_bash_pattern(built_image: str) -> None:

26
tests/docker/test_profile_gateway.py
View file

@ -115,29 +115,3 @@ def test_profile_create_then_gateway_start(
_wait_for_want_state(container_name, want_up=False)
def test_profile_delete_stops_gateway(
built_image: str, container_name: str,
) -> None:
"""Deleting a profile should stop its gateway and remove the s6
service slot."""
start_container(built_image, container_name, cmd="sleep 120")
_sh(container_name, f"hermes profile create {PROFILE}")
_sh(container_name, f"hermes -p {PROFILE} gateway start", timeout=60)
_wait_for_want_state(container_name, want_up=True)
r = _sh(
container_name,
f"hermes profile delete {PROFILE} --yes",
timeout=30,
)
assert r.returncode == 0, f"profile delete failed: {r.stderr}"
# Poll for slot removal instead of a fixed sleep.
deadline = time.monotonic() + 15
while time.monotonic() < deadline:
r = _sh(container_name, f"test -d /run/service/gateway-{PROFILE}")
if r.returncode != 0:
break
time.sleep(0.5)
assert r.returncode != 0, "s6 service slot still present after profile delete"

15
tests/docker/test_puid_pgid_remap.py
View file

@ -38,21 +38,6 @@ def test_puid_pgid_remaps_hermes_user(
)
def test_hermes_uid_gid_take_precedence_over_aliases(
built_image: str, container_name: str,
) -> None:
"""HERMES_UID/HERMES_GID must win over PUID/PGID when both are set."""
start_container(built_image, container_name, "HERMES_UID=2000", "HERMES_GID=2001", "PUID=1000", "PGID=1000")
r = docker_exec_sh(container_name, "id -u hermes", timeout=10)
assert r.stdout.strip() == "2000", (
f"expected hermes UID 2000 (HERMES_UID wins), got: {r.stdout.strip()}"
)
r = docker_exec_sh(container_name, "id -g hermes", timeout=10)
assert r.stdout.strip() == "2001", (
f"expected hermes GID 2001 (HERMES_GID wins), got: {r.stdout.strip()}"
)
def test_nas_low_uid_accepted(

80
tests/docker/test_s6_profile_gateway_integration.py
View file

@ -81,34 +81,6 @@ def test_s6_register_creates_service_dir_in_live_container(
assert "phase3test" in r.stdout, f"list output: {r.stdout!r}"
def test_s6_unregister_removes_service_dir_in_live_container(
built_image: str, container_name: str,
) -> None:
"""unregister_profile_gateway must stop the service, remove the
directory, and trigger s6-svscan rescan so the supervise process
is dropped."""
start_container(built_image, container_name, cmd="sleep 120")
# First register so we have something to unregister.
r = docker_exec(container_name, "python3", "-c", _REGISTER_SCRIPT, timeout=30)
assert "REGISTERED" in r.stdout
# Then unregister.
r = docker_exec(container_name, "python3", "-c", _UNREGISTER_SCRIPT, timeout=30)
assert "UNREGISTERED" in r.stdout, (
f"unregister failed: stderr={r.stderr!r} stdout={r.stdout!r}"
)
# Directory is gone.
r = docker_exec(container_name, "test", "-d", "/run/service/gateway-phase3test")
assert r.returncode != 0, "service directory still exists after unregister"
# list_profile_gateways no longer includes it.
r = docker_exec(container_name, "python3", "-c", (
"from hermes_cli.service_manager import S6ServiceManager;"
"print(S6ServiceManager().list_profile_gateways())"
))
assert "phase3test" not in r.stdout
# Shell probe: build a service-shaped staging dir under the live scandir
@ -147,55 +119,3 @@ rm -rf "$DIR" 2>/dev/null || true
"""
def test_s6_dotfile_staging_dir_is_ignored_by_svscan_rescan(
built_image: str, container_name: str,
) -> None:
"""Regression for the arm64 register-seed race.
The register path builds the slot in a sibling staging dir and then
atomically renames it to the live ``gateway-<profile>`` name. That
staging dir lives INSIDE the scandir s6-svscan watches, so its NAME
decides whether a concurrent ``s6-svscanctl -a`` rescan (fired by the
cont-init reconciler registering ``gateway-default``, or by another
register) supervises the half-built slot.
- A NON-dotted name (the old ``gateway-<p>.tmp``) IS picked up: once it
has a valid ``type``/``run``, s6-svscan spawns ``s6-supervise`` AS
ROOT, creating a root-owned ``supervise/`` — which makes the in-flight
``_seed_supervise_skeleton`` EACCES on ``mkdir supervise/event``. That
is the arm64-only flake (the native-arm runner's wider scheduling
jitter lets the rescan land inside the seed window).
- A DOT-prefixed name (the fix, ``.gateway-<p>.tmp``) is SKIPPED by
s6-svscan and never supervised, so no root-owned ``supervise/`` can
appear under the staging dir.
This proves the mechanism directly and is arch-independent (it does not
rely on hitting the narrow timing window — it forces the rescan and
checks pickup), so it guards the fix on the amd64 job too.
"""
start_container(built_image, container_name, cmd="sleep 120")
# Control: a NON-dotted service-shaped dir IS supervised by the rescan
# (root-owned supervise/). This is the pre-fix staging-name behaviour and
# confirms the probe actually exercises s6-svscan pickup.
r = docker_exec(
container_name, "sh", "-c", _SVSCAN_PICKUP_PROBE, "probe",
"gateway-raceprobe.tmp", user="root", timeout=30,
)
assert "SUPERVISED" in r.stdout and "NOT-SUPERVISED" not in r.stdout, (
"control failed: a non-dotted staging dir should be picked up by "
f"s6-svscan. stdout={r.stdout!r} stderr={r.stderr!r}"
)
# The fix: a DOT-prefixed staging dir (the name register/reconcile now
# use) must be IGNORED by the same rescan — no supervisor, no root-owned
# supervise/, so the in-flight seed can never EACCES.
r = docker_exec(
container_name, "sh", "-c", _SVSCAN_PICKUP_PROBE, "probe",
".gateway-raceprobe.tmp", user="root", timeout=30,
)
assert "NOT-SUPERVISED" in r.stdout, (
"dot-prefixed staging dir was supervised by s6-svscan — the race "
f"that EACCESes the seed is still reachable. stdout={r.stdout!r} "
f"stderr={r.stderr!r}"
)

17
tests/docker/test_stage2_browser_discovery.py
View file

@ -63,20 +63,3 @@ def test_stage2_discovers_chromium_binary(
)
def test_stage2_browser_path_accessible_to_hermes_user(
built_image: str, container_name: str,
) -> None:
"""The discovered browser binary must be accessible to the
unprivileged hermes user (UID 10000), since that's who runs
agent-browser subprocesses."""
start_container(built_image, container_name)
r = docker_exec_sh(
container_name,
'path="$(cat /run/s6/container_environment/AGENT_BROWSER_EXECUTABLE_PATH)" '
'&& test -r "$path" && test -x "$path"',
timeout=10,
)
assert r.returncode == 0, (
f"browser binary not readable+executable by hermes user: {r.stderr}"
)

25
tests/docker/test_tini_compat_shim.py
View file

@ -63,28 +63,3 @@ def test_entrypoint_is_init_not_tini(built_image: str) -> None:
)
def test_legacy_tini_g_entrypoint_does_not_boot_loop(built_image: str) -> None:
"""``docker run --entrypoint /usr/bin/tini … -g -- --help`` must work.
Exact failure from #66679: after update, NAS templates still invoke
``/usr/bin/tini -g -- …``. The old symlink turned that into
``/init -g -- …``, rc.init tried to exec ``-g``, and the container
restart-looped. The shim must strip ``-g`` / ``--`` and reach hermes.
"""
r = subprocess.run(
[
"docker", "run", "--rm",
"--entrypoint", "/usr/bin/tini",
built_image,
"-g", "--", "--help",
],
capture_output=True, text=True, timeout=120,
)
combined = r.stdout + r.stderr
assert "-g: not found" not in combined, (
f"tini -g leaked into rc.init (boot-loop regression):\n{combined[-3000:]}"
)
assert r.returncode == 0, (
f"legacy tini -g -- --help failed (exit {r.returncode}):\n"
f"stdout={r.stdout[-2000:]!r}\nstderr={r.stderr[-2000:]!r}"
)

28
tests/gateway/platforms/test_yuanbao_recall_db_only.py
View file

@ -58,31 +58,3 @@ def test_recall_branch_a1_exact_id_match_round_trips_through_db(tmp_path, monkey
assert target["content"] == "sensitive content"
def test_recall_branch_a2_content_match_when_no_platform_id(tmp_path, monkeypatch):
"""Rows that lack a platform_message_id (e.g. agent-processed @bot
messages) still match by content as a fallback."""
_pin_db(monkeypatch, tmp_path)
config = GatewayConfig()
store = SessionStore(sessions_dir=tmp_path, config=config)
sid = "test-yuanbao-recall-a2"
store._db.create_session(session_id=sid, source="yuanbao:group:G")
# No message_id on the dict — simulates an agent-processed message
# that did not carry the platform msg_id through.
store.append_to_transcript(sid, {
"role": "user",
"content": "sensitive content",
"timestamp": 1.0,
})
history = store.load_transcript(sid)
assert all("message_id" not in m for m in history)
# Branch A2: content match recovers the target.
target = next(
(m for m in history
if m.get("role") == "user" and m.get("content") == "sensitive content"),
None,
)
assert target is not None

62
tests/gateway/relay/test_auth.py
View file

@ -49,18 +49,6 @@ _CONN_SIG = "ac9509c8dae52b5590f06378260877334ff1adc4b1c96bafa4b514165fae6dc6"
# ── Self-consistency ──────────────────────────────────────────────────────
def test_token_round_trip_no_expiry():
tok = make_token("payload-123", _SECRET, 0)
assert verify_token(tok, [_SECRET]) == "payload-123"
def test_token_payload_may_contain_colons():
# verify_token must split from the right so a colon-bearing payload survives.
payload = "agent:main:discord:group:chanA"
tok = make_token(payload, _SECRET, 0)
assert verify_token(tok, [_SECRET]) == payload
def test_upgrade_token_is_make_token_of_gateway_id():
assert make_upgrade_token("gw-1", _SECRET, 0) == make_token("gw-1", _SECRET, 0)
@ -87,19 +75,6 @@ def test_token_expired_rejected():
assert verify_token(tok, [_SECRET]) == "p"
def test_token_rotation_verify_list():
# A token signed with the (old) secondary still verifies during rotation.
old, new = _SECRET, "ffeeddccbbaa99887766554433221100ffeeddccbbaa99887766554433221100"
tok_old = make_token("p", old, 0)
assert verify_token(tok_old, [new, old]) == "p" # primary=new, secondary=old
assert verify_token(tok_old, [new]) is None
def test_token_garbage_rejected():
assert verify_token("not-base64url!!!", [_SECRET]) is None
assert verify_token("", [_SECRET]) is None
def test_verify_signature_constant_time_multi_secret():
payload = "1700000000.body"
s = sign(payload, _SECRET)
@ -111,21 +86,6 @@ def test_verify_signature_constant_time_multi_secret():
# ── Delivery signature (connector -> gateway inbound) ──────────────────────
def test_delivery_signature_accepts_valid():
body = json.dumps({"type": "message", "event": {"text": "x"}})
ts = 1700000000
s = sign(f"{ts}.{body}", _SECRET)
assert verify_delivery_signature(body, str(ts), s, [_SECRET], now=ts) is True
def test_delivery_signature_tamper_rejected():
body = json.dumps({"type": "message", "event": {"text": "x"}})
ts = 1700000000
s = sign(f"{ts}.{body}", _SECRET)
# A single changed body byte breaks the HMAC.
assert verify_delivery_signature(body + " ", str(ts), s, [_SECRET], now=ts) is False
def test_delivery_signature_skew_rejected():
body = "{}"
ts = 1700000000
@ -136,18 +96,6 @@ def test_delivery_signature_skew_rejected():
assert verify_delivery_signature(body, str(ts), s, [_SECRET], now=ts + 299) is True
def test_delivery_signature_missing_headers_rejected():
assert verify_delivery_signature("{}", None, "abc", [_SECRET]) is False
assert verify_delivery_signature("{}", "1700000000", None, [_SECRET]) is False
assert verify_delivery_signature("{}", "not-an-int", "abc", [_SECRET]) is False
def test_delivery_headers_match_connector_names():
# The gateway reads exactly the header names the connector writes.
assert DELIVERY_TS_HEADER == "x-relay-timestamp"
assert DELIVERY_SIG_HEADER == "x-relay-signature"
# ── Cross-implementation conformance (frozen connector vectors) ────────────
@ -155,13 +103,3 @@ def test_python_make_token_matches_connector_byte_for_byte():
assert make_token("gw-instance-1", _SECRET, 0) == _CONN_TOKEN
def test_python_verifies_connector_token():
assert verify_token(_CONN_TOKEN, [_SECRET]) == "gw-instance-1"
def test_python_sign_matches_connector_delivery_sig():
assert sign(f"{_CONN_TS}.{_CONN_BODY}", _SECRET) == _CONN_SIG
def test_python_verifies_connector_delivery_signature():
assert verify_delivery_signature(_CONN_BODY, str(_CONN_TS), _CONN_SIG, [_SECRET], now=_CONN_TS) is True

57
tests/gateway/relay/test_channel_context_consume.py
View file

@ -34,25 +34,7 @@ def _descriptor_kwargs(**overrides):
class TestDescriptorSupportsContext:
def test_defaults_false(self):
d = CapabilityDescriptor(**_descriptor_kwargs())
assert d.supports_context is False
def test_round_trip_true(self):
d = CapabilityDescriptor(**_descriptor_kwargs(supports_context=True))
restored = CapabilityDescriptor.from_json(d.to_json())
assert restored.supports_context is True
def test_from_json_absent_defaults_false(self):
# An older connector that never sends the key -> default False.
payload = (
'{"contract_version":1,"platform":"discord","label":"Discord",'
'"max_message_length":2000,"supports_draft_streaming":false,'
'"supports_edit":true,"supports_threads":true,'
'"markdown_dialect":"discord","len_unit":"chars"}'
)
d = CapabilityDescriptor.from_json(payload)
assert d.supports_context is False
def test_from_json_ignores_unknown_keys(self):
# Forward-compat: a newer connector sending extra keys must not break.
@ -73,32 +55,6 @@ class TestRenderRelayContext:
assert _render_relay_context([]) is None
assert _render_relay_context("not a list") is None
def test_renders_author_and_text_oldest_first(self):
ctx = [
{"text": "first", "source": {"user_name": "alice"}},
{"text": "second", "source": {"user_name": "bob"}},
]
out = _render_relay_context(ctx)
assert out is not None
assert "alice: first" in out
assert "bob: second" in out
# order preserved (oldest -> newest)
assert out.index("first") < out.index("second")
def test_falls_back_to_user_id_then_bare_text(self):
ctx = [
{"text": "has id", "source": {"user_id": "u123"}},
{"text": "no author", "source": {}},
]
out = _render_relay_context(ctx)
assert "u123: has id" in out
assert "no author" in out
def test_skips_malformed_items_without_raising(self):
ctx = ["not a dict", {"no_text": True}, {"text": "", "source": {}}, 42]
# Nothing usable -> None, and definitely no exception.
assert _render_relay_context(ctx) is None
class TestEventFromWireContext:
def _wire(self, **overrides):
@ -127,17 +83,4 @@ class TestEventFromWireContext:
assert ev.channel_context is not None
assert "alice: earlier" in ev.channel_context
def test_no_context_leaves_channel_context_unset(self):
ev = _event_from_wire(self._wire())
assert ev.channel_context is None
def test_empty_context_leaves_channel_context_unset(self):
ev = _event_from_wire(self._wire(context=[]))
assert ev.channel_context is None
def test_context_does_not_alter_trigger_text(self):
# Read-only invariant: the addressed text is untouched by context.
ev = _event_from_wire(
self._wire(context=[{"text": "noise", "source": {"user_name": "x"}}])
)
assert ev.text == "@bot repeat what they said above"

58
tests/gateway/relay/test_contract_doc_conformance.py
View file

@ -124,61 +124,3 @@ def _session_source_wire_keys() -> set[str]:
return set(src.to_dict().keys())
def test_session_source_wire_keys_documented_in_contract():
"""Every wire key SessionSource.to_dict() emits is named in the contract doc.
The doc enumerates discriminators in prose + a per-platform table (§3) rather
than a strict field table, so this asserts presence-by-name: a wire key the
connector must populate but which appears nowhere in the doc is a silent gap.
"""
text = _doc_text()
# Limit to §3 (the MessageEvent / SessionSource section).
section = text.split("## 3. Inbound", 1)[-1].split("## 4.", 1)[0]
wire_keys = _session_source_wire_keys()
# Keys that are self-evidently covered by the §3 narrative/table.
# We assert each wire key appears as a backticked token or table cell.
undocumented = sorted(k for k in wire_keys if k not in section)
assert not undocumented, (
f"SessionSource wire keys absent from the §3 contract-doc section: "
f"{undocumented}. The connector normalizes events into these keys; if the "
f"doc doesn't name them the connector author can't know to populate them. "
f"Document them (prose or the discriminator table)."
)
def test_internal_only_session_fields_stay_off_the_wire():
"""Guard the inverse: fields deliberately NOT serialized must not leak.
``is_bot`` is an internal author-classification flag that today is NOT in
``to_dict()`` (so the connector's TS contract correctly omits it). If someone
adds it to the wire without updating the contract doc + connector, this flips
and forces the conversation. This documents the intentional omission.
"""
wire_keys = _session_source_wire_keys()
assert "is_bot" not in wire_keys, (
"is_bot is now serialized by SessionSource.to_dict(). If this is "
"intentional, add it to docs/relay-connector-contract.md §3 and the "
"connector's SessionSource interface, then update this guard."
)
@pytest.mark.parametrize("discriminator", ["chat_id", "chat_type", "user_id", "thread_id", "guild_id"])
def test_discord_telegram_discriminator_columns_present(discriminator):
"""§3's per-platform table headers must exist as SessionSource fields.
These five columns drive build_session_key() and are the #1 High-severity
risk surface (Discord guild_id collision). If the doc advertises a
discriminator column the dataclass can't carry, the connector has nowhere to
put it.
"""
assert discriminator in SessionSource.__dataclass_fields__, ( # type: ignore[attr-defined]
f"Contract doc §3 lists '{discriminator}' as a session discriminator, "
f"but SessionSource has no such field."
)
# And it must be reachable on the wire (chat_type is always emitted; the rest
# are conditional but still possible keys).
assert discriminator in _session_source_wire_keys(), (
f"Discriminator '{discriminator}' never appears in SessionSource.to_dict() "
f"output — the connector cannot transmit it to the gateway."
)

74
tests/gateway/relay/test_descriptor.py
View file

@ -22,11 +22,6 @@ def _telegram_descriptor(**overrides) -> CapabilityDescriptor:
return CapabilityDescriptor(**base)
def test_descriptor_roundtrips_json():
d = _telegram_descriptor()
assert CapabilityDescriptor.from_json(d.to_json()) == d
def test_descriptor_is_frozen():
d = _telegram_descriptor()
try:
@ -37,61 +32,6 @@ def test_descriptor_is_frozen():
raise AssertionError("descriptor should be immutable (frozen)")
def test_from_json_ignores_unknown_keys():
"""A newer connector may send fields this gateway doesn't know — those are
dropped, not fatal (forward-compat during the experimental phase)."""
d = _telegram_descriptor()
raw = d.to_json()[:-1] + ', "future_field": "ignored"}'
restored = CapabilityDescriptor.from_json(raw)
assert restored == d
def test_from_json_normalizes_zero_max_message_length_to_default():
"""A connector may advertise max_message_length 0 ("no limit"). from_json
must normalize it to the documented 4096 default so the receiver never
carries a degenerate chunking bound into truncate_message()."""
raw = (
'{"contract_version": 1, "platform": "x", "label": "X", '
'"max_message_length": 0, "supports_draft_streaming": false, '
'"supports_edit": false, "supports_threads": false, '
'"markdown_dialect": "plain", "len_unit": "chars"}'
)
d = CapabilityDescriptor.from_json(raw)
assert d.max_message_length == 4096
def test_from_json_normalizes_negative_max_message_length_to_default():
"""A buggy/hostile connector sending a negative bound is normalized too."""
raw = (
'{"contract_version": 1, "platform": "x", "label": "X", '
'"max_message_length": -5, "supports_draft_streaming": false, '
'"supports_edit": false, "supports_threads": false, '
'"markdown_dialect": "plain", "len_unit": "chars"}'
)
d = CapabilityDescriptor.from_json(raw)
assert d.max_message_length == 4096
def test_from_json_keeps_a_real_positive_bound():
"""A normal positive bound is passed through unchanged."""
d = CapabilityDescriptor.from_json(_telegram_descriptor(max_message_length=2000).to_json())
assert d.max_message_length == 2000
def test_from_json_fills_optional_defaults():
"""Optional fields (emoji/platform_hint/pii_safe) fall back to defaults."""
minimal = (
'{"contract_version": 1, "platform": "x", "label": "X", '
'"max_message_length": 2000, "supports_draft_streaming": false, '
'"supports_edit": false, "supports_threads": false, '
'"markdown_dialect": "plain", "len_unit": "chars"}'
)
d = CapabilityDescriptor.from_json(minimal)
assert d.pii_safe is False
assert d.platform_hint == ""
assert d.emoji == "\U0001f50c"
def test_module_is_marked_experimental():
import gateway.relay.descriptor as m
@ -100,20 +40,6 @@ def test_module_is_marked_experimental():
# ─────────────── supported_ops (op-level capability discovery, Phase 1) ───────────────
def test_supported_ops_roundtrips_json():
d = _telegram_descriptor(supported_ops=("send", "edit", "typing"))
restored = CapabilityDescriptor.from_json(d.to_json())
assert restored.supported_ops == ("send", "edit", "typing")
assert restored == d
def test_supports_op_advertised_list_is_authoritative():
d = _telegram_descriptor(supported_ops=("send", "typing", "get_chat_info"))
assert d.supports_op("send") is True
assert d.supports_op("get_chat_info") is True
# An advertised list EXCLUDES what it omits — even a legacy op.
assert d.supports_op("edit") is False
def test_supports_op_legacy_connector_assumes_legacy_set():
"""An empty supported_ops means the connector predates op discovery: the

26
tests/gateway/relay/test_descriptor_from_entry.py
View file

@ -36,29 +36,3 @@ def test_projection_carries_platform_entry_fields():
assert d.len_unit == "utf16"
def test_zero_max_length_maps_to_4096_default():
"""PlatformEntry.max_message_length == 0 means 'no limit'; the descriptor
carries a concrete bound matching the stream_consumer default."""
d = CapabilityDescriptor.from_platform_entry(_entry(max_message_length=0))
assert d.max_message_length == 4096
def test_runtime_capabilities_supplied_by_caller():
"""PlatformEntry doesn't encode draft/edit/thread/markdown behavior — those
come from the caller (the connector, reading the live adapter)."""
d = CapabilityDescriptor.from_platform_entry(
_entry(),
supports_draft_streaming=True,
supports_edit=False,
supports_threads=True,
markdown_dialect="discord",
)
assert d.supports_draft_streaming is True
assert d.supports_edit is False
assert d.supports_threads is True
assert d.markdown_dialect == "discord"
def test_projection_roundtrips_through_json():
d = CapabilityDescriptor.from_platform_entry(_entry(), len_unit="utf16")
assert CapabilityDescriptor.from_json(d.to_json()) == d

47
tests/gateway/relay/test_handoff_relay_aliasing.py
View file

@ -60,47 +60,6 @@ class TestHandoffRelayAliasing:
assert transport.adapter is relay
assert transport.is_relay is True
def test_unfronted_platform_still_fails(self):
"""Aliasing must not let relay hijack a platform it does not front."""
relay = _RelayStub({"telegram"})
cfg = _config_with({Platform.RELAY: PlatformConfig(enabled=True)})
transport = resolve_delivery_transport(
Platform.DISCORD, cfg, {Platform.RELAY: relay}
)
assert transport is None
def test_native_adapter_wins_over_relay(self):
native = object()
relay = _RelayStub({"discord"})
cfg = _config_with(
{
Platform.DISCORD: PlatformConfig(enabled=True),
Platform.RELAY: PlatformConfig(enabled=True),
}
)
transport = resolve_delivery_transport(
Platform.DISCORD, cfg, {Platform.DISCORD: native, Platform.RELAY: relay}
)
assert transport is not None
assert transport.adapter is native
assert transport.is_relay is False
@pytest.mark.asyncio
async def test_transport_send_stamps_logical_platform(self):
"""The handoff reply leg must go through send_for_platform so the
outbound frame carries the logical platform tag."""
relay = _RelayStub({"discord"})
cfg = _config_with({Platform.RELAY: PlatformConfig(enabled=True)})
transport = resolve_delivery_transport(
Platform.DISCORD, cfg, {Platform.RELAY: relay}
)
assert transport is not None
result = await transport.send(
Platform.DISCORD, "chan-1", "handed-off reply", {"thread_id": "t-9"}
)
assert result.success is True
assert relay.sent == [("discord", "chan-1", "handed-off reply", {"thread_id": "t-9"})]
class TestCliHandoffFrontedSet:
"""The CLI pre-check derives the fronted set from deploy env (no live adapter)."""
@ -115,9 +74,3 @@ class TestCliHandoffFrontedSet:
assert "telegram" in fronted
assert "slack" not in fronted
def test_unconfigured_env_yields_generic_relay_only(self, monkeypatch):
monkeypatch.delenv("GATEWAY_RELAY_PLATFORMS", raising=False)
from gateway.relay import relay_platform_identities
fronted = {p for p, _ in relay_platform_identities()}
assert fronted == {"relay"}

66
tests/gateway/relay/test_identity_token_resolver.py
View file

@ -35,20 +35,6 @@ def _clean_env(monkeypatch):
monkeypatch.setattr("gateway.run._load_gateway_config", lambda: {}, raising=False)
def test_defaults_to_nous_portal_when_no_idp_configured(monkeypatch):
called = {}
def fake_resolve():
called["yes"] = True
return "nous-portal-token"
monkeypatch.setattr(
"hermes_cli.auth.resolve_nous_access_token", fake_resolve, raising=False
)
assert relay._resolve_relay_identity_token() == "nous-portal-token"
assert called == {"yes": True}
def test_client_credentials_via_env(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_IDP_TOKEN_URL", "https://idp.test/token")
monkeypatch.setenv("GATEWAY_RELAY_IDP_CLIENT_ID", "agent-client")
@ -78,58 +64,6 @@ def test_client_credentials_via_env(monkeypatch):
assert captured["headers"]["content-type"] == "application/x-www-form-urlencoded"
def test_client_credentials_via_config_yaml(monkeypatch):
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {
"gateway": {
"idp": {
"token_url": "https://idp.test/token",
"client_id": "cfg-client",
"client_secret": "cfg-secret",
}
}
},
raising=False,
)
def fake_urlopen(req, timeout=None):
body = req.data.decode()
assert "client_id=cfg-client" in body
assert "client_secret=cfg-secret" in body
# No scope configured -> not sent.
assert "scope=" not in body
return io.BytesIO(json.dumps({"access_token": "cfg-token"}).encode())
monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
assert relay._resolve_relay_identity_token() == "cfg-token"
def test_env_token_url_takes_precedence_over_config(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_IDP_TOKEN_URL", "https://env.test/token")
monkeypatch.setenv("GATEWAY_RELAY_IDP_CLIENT_ID", "env-client")
monkeypatch.setenv("GATEWAY_RELAY_IDP_CLIENT_SECRET", "env-secret")
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"gateway": {"idp": {"token_url": "https://cfg.test/token"}}},
raising=False,
)
def fake_urlopen(req, timeout=None):
assert req.full_url == "https://env.test/token"
return io.BytesIO(json.dumps({"access_token": "t"}).encode())
monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
assert relay._resolve_relay_identity_token() == "t"
def test_raises_when_client_creds_missing(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_IDP_TOKEN_URL", "https://idp.test/token")
# No client_id / client_secret.
with pytest.raises(RuntimeError, match="client_id/client_secret missing"):
relay._resolve_relay_identity_token()
def test_raises_when_no_access_token_in_response(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_IDP_TOKEN_URL", "https://idp.test/token")
monkeypatch.setenv("GATEWAY_RELAY_IDP_CLIENT_ID", "c")

44
tests/gateway/relay/test_relay_follow_up.py
View file

@ -47,28 +47,6 @@ def wired():
return adapter, stub
@pytest.mark.asyncio
async def test_follow_up_round_trips_without_a_token(wired):
adapter, stub = wired
await adapter.connect()
stub.next_follow_up_result = {"success": True, "message_id": "fu-7"}
result = await adapter.send_follow_up(
session_key="agent:main:discord:group:chanA:userX",
kind="discord.interaction_token",
content="here is your follow-up",
)
assert result.success is True
assert result.message_id == "fu-7"
assert len(stub.follow_ups) == 1
action = stub.follow_ups[0]
assert action["op"] == "follow_up"
assert action["session_key"] == "agent:main:discord:group:chanA:userX"
assert action["kind"] == "discord.interaction_token"
assert action["content"] == "here is your follow-up"
@pytest.mark.asyncio
async def test_follow_up_wire_action_carries_no_credential(wired):
"""The action dict must carry only session refs — no credential VALUE.
@ -93,25 +71,3 @@ async def test_follow_up_wire_action_carries_no_credential(wired):
assert "credential" not in action
@pytest.mark.asyncio
async def test_follow_up_failure_surfaces_when_capability_unresolvable(wired):
"""Connector couldn't resolve (absent/expired/tenant mismatch) -> success=False."""
adapter, stub = wired
await adapter.connect()
stub.next_follow_up_result = {"success": False, "error": "capability absent or tenant mismatch"}
result = await adapter.send_follow_up(
session_key="sess-1", kind="discord.interaction_token", content="x"
)
assert result.success is False
assert result.message_id is None
assert "tenant mismatch" in (result.error or "")
@pytest.mark.asyncio
async def test_follow_up_without_transport_fails_cleanly():
adapter = RelayAdapter(PlatformConfig(), _discord_descriptor(), transport=None)
result = await adapter.send_follow_up(session_key="s", kind="k", content="c")
assert result.success is False
assert result.error == "no transport"

173
tests/gateway/relay/test_relay_going_idle.py
View file

@ -94,39 +94,6 @@ async def server():
await srv.stop()
@pytest.mark.asyncio
async def test_go_idle_awaits_ack(server):
t = WebSocketRelayTransport(server.url, "discord", "appShared")
await t.connect()
try:
await t.handshake()
acked = await t.go_idle(timeout_s=2)
assert acked is True
assert server.going_idle_count == 1
assert any(f["type"] == "going_idle" for f in server.received)
finally:
await t.disconnect()
@pytest.mark.asyncio
async def test_go_idle_returns_false_on_timeout(server):
# A server that never acks going_idle -> go_idle returns False (caller closes anyway).
async def no_ack(ws, frame):
if frame.get("type") == "hello":
await ws.send(json.dumps({"type": "descriptor", "descriptor": DESCRIPTOR}) + "\n")
# deliberately ignore going_idle
server._on_frame = no_ack # type: ignore[assignment]
t = WebSocketRelayTransport(server.url, "discord", "appShared")
await t.connect()
try:
await t.handshake()
acked = await t.go_idle(timeout_s=0.3)
assert acked is False
finally:
await t.disconnect()
@pytest.mark.asyncio
async def test_buffered_inbound_is_acked_after_handler(server):
# A buffered delivery (bufferId present) is acked AFTER the handler runs; a
@ -197,7 +164,7 @@ async def test_reconnect_redials_after_unexpected_close():
await t.connect()
await t.handshake()
# First connection is dropped server-side; the reconnect loop re-dials.
await asyncio.sleep(0.5)
await asyncio.sleep(0.2)
assert srv.connections >= 2
finally:
await t.disconnect()
@ -205,70 +172,9 @@ async def test_reconnect_redials_after_unexpected_close():
await srv._server.wait_closed()
@pytest.mark.asyncio
async def test_no_reconnect_after_deliberate_disconnect(server):
t = WebSocketRelayTransport(server.url, "discord", "appShared", reconnect=True, reconnect_backoff_s=0.05)
await t.connect()
await t.handshake()
before = server.connections
await t.disconnect()
await asyncio.sleep(0.3)
# A deliberate disconnect must NOT trigger the reconnect loop.
assert server.connections == before
@pytest.mark.asyncio
async def test_adapter_emits_going_idle_on_disconnect(server):
# The RelayAdapter emits going_idle as part of its existing disconnect (drain)
# transition, then tears down the transport.
from gateway.config import PlatformConfig
from gateway.relay.adapter import RelayAdapter
from gateway.relay.descriptor import CONTRACT_VERSION, CapabilityDescriptor
placeholder = CapabilityDescriptor(
contract_version=CONTRACT_VERSION,
platform="discord",
label="Relay",
max_message_length=4096,
supports_draft_streaming=False,
supports_edit=True,
supports_threads=False,
markdown_dialect="plain",
len_unit="chars",
)
transport = WebSocketRelayTransport(server.url, "discord", "appShared")
adapter = RelayAdapter(PlatformConfig(), placeholder, transport=transport)
await adapter.connect()
await adapter.disconnect()
assert server.going_idle_count == 1
# ── scale-to-zero go_dormant() (D12 / F14) ───────────────────────────────────
@pytest.mark.asyncio
async def test_go_dormant_emits_going_idle_and_closes_without_terminal_teardown(server):
"""go_dormant() flips the connector to buffered-only (going_idle->ack) AND
closes the socket, but does NOT set the terminal _closing flag or cancel the
reconnect supervisor — the F14 distinction from disconnect()."""
t = WebSocketRelayTransport(
server.url, "discord", "appShared", reconnect=True, reconnect_backoff_s=0.05
)
await t.connect()
await t.handshake()
try:
acked = await t.go_dormant(timeout_s=2)
assert acked is True
assert server.going_idle_count == 1
# The socket was closed (dormant), but NOT via the terminal path:
assert t._closing is False # disconnect() would set this True
assert t._dormant is True
# Not a revocation — the auth-revoked latch stays clear.
assert t.auth_revoked is False
finally:
await t.disconnect()
@pytest.mark.asyncio
async def test_go_dormant_redials_on_wake_and_drains(server):
"""After go_dormant() the reconnect supervisor stays armed, so the gateway
@ -322,51 +228,6 @@ async def test_go_dormant_redials_on_wake_and_drains(server):
await t.disconnect()
@pytest.mark.asyncio
async def test_disconnect_cancels_supervisor_but_go_dormant_does_not(server):
"""Direct contrast (F14): disconnect() is terminal (cancels supervisor, no
re-dial); go_dormant() keeps it armed. Guards against a future refactor that
routes dormancy through disconnect()."""
# disconnect(): terminal — no reconnect.
t1 = WebSocketRelayTransport(
server.url, "discord", "appShared", reconnect=True, reconnect_backoff_s=0.05
)
await t1.connect()
await t1.handshake()
after_first = server.connections
await t1.disconnect()
await asyncio.sleep(0.3)
assert server.connections == after_first # disconnect did NOT re-dial
assert t1._closing is True
# go_dormant(): armed — re-dials.
t2 = WebSocketRelayTransport(
server.url, "discord", "appShared", reconnect=True, reconnect_backoff_s=0.05
)
t2._dormant_redial_s = 0.05
await t2.connect()
await t2.handshake()
before = server.connections
try:
await t2.go_dormant(timeout_s=2)
for _ in range(50):
if server.connections > before:
break
await asyncio.sleep(0.05)
assert server.connections > before # go_dormant stayed armed and re-dialed
assert t2._closing is False
finally:
await t2.disconnect()
@pytest.mark.asyncio
async def test_go_dormant_noop_when_never_connected():
"""go_dormant() on a transport that never connected is a safe no-op (False),
not a crash."""
t = WebSocketRelayTransport("ws://127.0.0.1:1", "discord", "appShared")
assert await t.go_dormant(timeout_s=0.1) is False
@pytest.mark.asyncio
async def test_adapter_go_dormant_delegates_to_transport(server):
"""RelayAdapter.go_dormant() drives the transport's go_dormant (going_idle +
@ -401,35 +262,3 @@ async def test_adapter_go_dormant_delegates_to_transport(server):
await adapter.disconnect()
@pytest.mark.asyncio
async def test_adapter_go_dormant_noop_on_stub_transport():
"""An adapter whose transport lacks go_dormant (the stub) degrades to a safe
no-op returning False, never raising."""
from gateway.config import PlatformConfig
from gateway.relay.adapter import RelayAdapter
from gateway.relay.descriptor import CONTRACT_VERSION, CapabilityDescriptor
placeholder = CapabilityDescriptor(
contract_version=CONTRACT_VERSION,
platform="discord",
label="Relay",
max_message_length=4096,
supports_draft_streaming=False,
supports_edit=True,
supports_threads=False,
markdown_dialect="plain",
len_unit="chars",
)
class _StubTransport:
async def connect(self, *, is_reconnect: bool = False):
return True
def set_inbound_handler(self, h):
pass
async def handshake(self):
return placeholder
adapter = RelayAdapter(PlatformConfig(), placeholder, transport=_StubTransport())
assert await adapter.go_dormant() is False

157
tests/gateway/relay/test_relay_interactive.py
View file

@ -120,17 +120,6 @@ async def test_exec_approval_smart_denied_and_flag_gating():
assert ids == ["once", "session", "deny"]
@pytest.mark.asyncio
async def test_exec_approval_without_prompt_op_fails_for_text_fallback():
adapter, stub = _adapter(supported_ops=("send", "edit", "typing"))
result = await adapter.send_exec_approval("c1", "cmd", "s")
# success=False → gateway/run.py falls back to the text approval prompt
# (same contract as a failed native button send).
assert result.success is False
assert all(a["op"] != "prompt" for a in stub.sent)
assert adapter._pending_prompts == {} # nothing left pending
@pytest.mark.asyncio
async def test_slash_confirm_renders_three_options():
adapter, stub = _adapter()
@ -173,91 +162,12 @@ async def test_clarify_renders_choices_plus_other_with_positional_ids():
assert state["choices"] == ["staging — the safe one", "production"]
@pytest.mark.asyncio
async def test_clarify_open_ended_uses_base_text_path(monkeypatch):
adapter, stub = _adapter()
# No choices → base class question-only text send (no prompt op).
result = await adapter.send_clarify("c1", "What now?", None, "cl-2", "sess:1")
assert result.success is True
assert all(a["op"] != "prompt" for a in stub.sent)
@pytest.mark.asyncio
async def test_prompt_decline_degrades_clarify_to_numbered_text(monkeypatch):
adapter, stub = _adapter()
stub.next_prompt_result = {"success": False, "error": "nope"}
marked: list[str] = []
monkeypatch.setattr(
"tools.clarify_gateway.mark_awaiting_text", lambda cid: marked.append(cid)
)
result = await adapter.send_clarify(
"c1", "Which?", ["a", "b"], "cl-3", "sess:1"
)
# Falls back to the base numbered-text clarify (a plain send).
assert result.success is True
assert stub.sent[-1]["op"] == "send"
assert "1. a" in stub.sent[-1]["content"]
assert marked == ["cl-3"]
assert adapter._pending_prompts == {}
# ── the pending-prompt registry ──────────────────────────────────────────
def test_registry_mint_consume_once_and_expiry():
adapter, _stub = _adapter()
pid = adapter._mint_prompt("exec_approval", {"session_key": "s"}, timeout_s=3600)
assert adapter._pop_prompt(pid) is not None
assert adapter._pop_prompt(pid) is None # one answer wins
stale = adapter._mint_prompt("exec_approval", {"session_key": "s"}, timeout_s=-1)
assert adapter._pop_prompt(stale) is None # expired misses
# ── inbound consumption ──────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_prompt_response_resolves_exec_approval(monkeypatch):
adapter, stub = _adapter()
await adapter.send_exec_approval("c1", "cmd", "sess:9")
prompt_id = stub.sent[-1]["prompt_id"]
calls: list[tuple[str, str]] = []
monkeypatch.setattr(
"tools.approval.resolve_gateway_approval",
lambda sk, choice, **kw: calls.append((sk, choice)) or 1,
)
event = _event({"prompt_id": prompt_id, "option_id": "session"})
consumed = await adapter._consume_prompt_response(event)
assert consumed is True
assert calls == [("sess:9", "session")]
# Consumed prompts leave the registry; the ack landed as a plain send.
assert prompt_id not in adapter._pending_prompts
assert stub.sent[-1]["op"] == "send"
assert "session" in stub.sent[-1]["content"].lower()
@pytest.mark.asyncio
async def test_prompt_response_resolves_slash_confirm(monkeypatch):
adapter, stub = _adapter()
await adapter.send_slash_confirm("c1", "T", "msg", "sess:9", "cf-1")
prompt_id = stub.sent[-1]["prompt_id"]
resolved: list[tuple] = []
async def fake_resolve(session_key, confirm_id, choice, **kw):
resolved.append((session_key, confirm_id, choice))
return "done!"
monkeypatch.setattr("tools.slash_confirm.resolve", fake_resolve)
event = _event({"prompt_id": prompt_id, "option_id": "always"})
assert await adapter._consume_prompt_response(event) is True
assert resolved == [("sess:9", "cf-1", "always")]
# The handler's result text went out as a follow-up send.
sends = [a for a in stub.sent if a["op"] == "send"]
assert any("done!" in a["content"] for a in sends)
@pytest.mark.asyncio
async def test_prompt_response_resolves_clarify_choice_and_other(monkeypatch):
adapter, stub = _adapter()
@ -286,16 +196,6 @@ async def test_prompt_response_resolves_clarify_choice_and_other(monkeypatch):
assert marked == ["cl-10"]
@pytest.mark.asyncio
async def test_unknown_or_expired_prompt_falls_through():
adapter, _stub = _adapter()
event = _event({"prompt_id": "deadbeef", "option_id": "once"})
assert await adapter._consume_prompt_response(event) is False
assert await adapter._consume_prompt_response(_event(None)) is False
# Malformed shapes never consume.
assert await adapter._consume_prompt_response(_event({"prompt_id": ""})) is False
# ── Discord type-3 hp1 decode ────────────────────────────────────────────
@ -324,34 +224,6 @@ def test_discord_component_interaction_decodes_prompt_token():
assert event.message_type == MessageType.COMMAND
def test_discord_foreign_custom_id_keeps_legacy_text_shape():
adapter, _stub = _adapter()
class Forward:
platform = "discord"
method = "POST"
path = "/interactions/bot1"
body = (
b'{"type": 3, "id": "i1", "channel_id": "ch1", "guild_id": "g1",'
b' "data": {"custom_id": "someones_button"}}'
)
event = adapter._discord_interaction_to_event(Forward())
assert event is not None
assert event.prompt_response is None
assert event.text == "someones_button"
assert event.message_type == MessageType.TEXT
def test_decode_prompt_token_matches_connector_codec():
adapter, _stub = _adapter()
assert adapter._decode_prompt_token("hp1:p1:deny") == ("p1", "deny")
assert adapter._decode_prompt_token("ea:once:3") is None
assert adapter._decode_prompt_token("hp1:p1") is None
assert adapter._decode_prompt_token("hp1:bad id:x") is None
assert adapter._decode_prompt_token("") is None
# ── react ack lifecycle ──────────────────────────────────────────────────
@ -385,32 +257,3 @@ async def test_processing_lifecycle_reacts_eyes_then_check():
assert all(r["message_id"] == "m42" and r["chat_id"] == "ch1" for r in reacts)
@pytest.mark.asyncio
async def test_processing_failure_reacts_cross():
adapter, stub = _adapter()
event = _reactable_event()
await adapter.on_processing_complete(event, ProcessingOutcome.FAILURE)
emojis = [a["emoji"] for a in stub.sent if a["op"] == "react"]
assert emojis[-1] == "❌"
@pytest.mark.asyncio
async def test_react_is_op_gated_and_best_effort():
adapter, stub = _adapter(supported_ops=("send", "edit", "typing"))
event = _reactable_event()
await adapter.on_processing_start(event)
await adapter.on_processing_complete(event, ProcessingOutcome.SUCCESS)
assert all(a["op"] != "react" for a in stub.sent) # never hit the wire
# And a connector decline never raises.
adapter2, stub2 = _adapter()
stub2.next_react_result = {"success": False, "error": "nope"}
await adapter2.on_processing_start(event) # must not raise
@pytest.mark.asyncio
async def test_cancelled_outcome_removes_eyes_without_verdict():
adapter, stub = _adapter()
event = _reactable_event()
await adapter.on_processing_complete(event, ProcessingOutcome.CANCELLED)
reacts = [(a["emoji"], a.get("remove", False)) for a in stub.sent if a["op"] == "react"]
assert reacts == [("👀", True)] # eyes removed, no ✅/❌

35
tests/gateway/relay/test_relay_interrupt.py
View file

@ -52,38 +52,3 @@ async def test_interrupt_sets_only_target_session_event(adapter):
assert ev_b.is_set() is False, "sibling session must be untouched"
@pytest.mark.asyncio
async def test_interrupt_unknown_session_is_noop(adapter):
# No active session for this key — must not raise.
await adapter.on_interrupt("agent:main:discord:group:nope:userZ", chat_id="nope")
@pytest.mark.asyncio
async def test_outbound_interrupt_reaches_connector(adapter):
"""The gateway-side /stop egress: send_interrupt is carried to the connector
so it can forward down the socket owning the session_key."""
stub = adapter._transport
await stub.send_interrupt("agent:main:discord:group:chanA:userX", reason="stop")
assert stub.interrupts == [
{"session_key": "agent:main:discord:group:chanA:userX", "reason": "stop"}
]
@pytest.mark.asyncio
async def test_connect_wires_inbound_interrupt_over_ws(adapter):
"""WS-only inbound: connect() registers BOTH the inbound message handler AND
the interrupt_inbound handler on the transport, so a connector-delivered
interrupt_inbound frame (no HTTP receiver) reaches the right session."""
await adapter.connect()
stub = adapter._transport
# Both connector->gateway handlers are wired post-connect.
assert stub._inbound is not None
assert stub._interrupt_inbound is not None
key = "agent:main:discord:group:chanA:userX"
ev = asyncio.Event()
adapter._active_sessions[key] = ev
# Simulate the connector pushing an interrupt_inbound frame down the WS.
await stub.push_interrupt(key, chat_id="chanA")
assert ev.is_set() is True, "interrupt delivered over the WS must cancel the target turn"

105
tests/gateway/relay/test_relay_media.py
View file

@ -117,23 +117,6 @@ async def test_local_path_lanes_upload_first(tmp_path: Path):
assert str(f) not in str(action)
@pytest.mark.asyncio
async def test_each_override_maps_to_its_media_kind(tmp_path: Path):
adapter, stub, fake = _adapter()
f = tmp_path / "x.bin"
f.write_bytes(b"data")
await adapter.send_image_file("c", str(f))
await adapter.send_voice("c", str(f))
await adapter.send_video("c", str(f))
await adapter.send_document("c", str(f), file_name="report.pdf")
kinds = [a["media_kind"] for a in stub.sent if a["op"] == "send_media"]
assert kinds == ["image", "voice", "video", "document"]
doc_action = stub.sent[-1]
assert doc_action["filename"] == "report.pdf"
# The document upload passed the user-facing filename through.
assert fake.uploads[-1] == (str(f), "report.pdf")
@pytest.mark.asyncio
async def test_op_gating_falls_back_when_not_advertised(tmp_path: Path):
# Connector advertises only the legacy ops — send_media must never hit the wire.
@ -149,52 +132,6 @@ async def test_op_gating_falls_back_when_not_advertised(tmp_path: Path):
assert "https://x.io/a.png" in stub.sent[-1]["content"]
@pytest.mark.asyncio
async def test_legacy_empty_ops_also_gates_send_media():
# An empty supported_ops = legacy connector; send_media is NOT in LEGACY_OPS.
adapter, stub, _fake = _adapter(supported_ops=())
await adapter.send_image("chat1", "https://x.io/a.png")
assert all(a["op"] != "send_media" for a in stub.sent)
@pytest.mark.asyncio
async def test_connector_decline_degrades_to_fallback(tmp_path: Path):
adapter, stub, fake = _adapter()
stub.next_media_result = {"success": False, "error": "media too large"}
f = tmp_path / "big.mp4"
f.write_bytes(b"x")
result = await adapter.send_video("chat1", str(f), caption="cap")
# The video lane failed → base fallback notice still delivers (a send op).
assert result.success is True
assert stub.sent[-1]["op"] == "send"
assert "cap" in stub.sent[-1]["content"]
# And the local path never leaked into the fallback text.
assert str(f) not in stub.sent[-1]["content"]
@pytest.mark.asyncio
async def test_failed_upload_degrades_to_fallback(tmp_path: Path):
adapter, stub, fake = _adapter()
fake.upload_result = None # upload leg fails
f = tmp_path / "pic.png"
f.write_bytes(b"png")
result = await adapter.send_image_file("chat1", str(f))
assert result.success is True
assert all(a["op"] != "send_media" for a in stub.sent)
@pytest.mark.asyncio
async def test_scope_metadata_rides_send_media(tmp_path: Path):
"""The egress guard resolves tenants from metadata — send_media must carry
the same scope/user discriminators a plain send does."""
adapter, stub, fake = _adapter()
adapter._scope_by_chat["chat1"] = "guild9"
await adapter.send_image("chat1", "https://x.io/p.png")
action = stub.sent[-1]
assert action["op"] == "send_media"
assert (action.get("metadata") or {}).get("scope_id") == "guild9"
# ── inbound localization ─────────────────────────────────────────────────
@ -212,29 +149,6 @@ def _make_event(media_urls):
)
@pytest.mark.asyncio
async def test_inbound_rehost_urls_are_localized():
adapter, _stub, fake = _adapter()
event = _make_event(["https://conn.example/relay/media/deadbeef"])
await adapter._localize_inbound_media(event)
assert fake.downloads == ["https://conn.example/relay/media/deadbeef"]
assert event.media_urls == ["/tmp/relay_media_fake.png"]
@pytest.mark.asyncio
async def test_inbound_dead_rehost_ref_is_dropped_public_url_kept():
adapter, _stub, fake = _adapter()
fake.download_result = None # every download fails
event = _make_event(
[
"https://conn.example/relay/media/deadbeef", # dead re-host → dropped
"https://cdn.discordapp.com/attachments/a/b.png", # public → kept as URL
]
)
await adapter._localize_inbound_media(event)
assert event.media_urls == ["https://cdn.discordapp.com/attachments/a/b.png"]
@pytest.mark.asyncio
async def test_inbound_without_client_keeps_public_drops_rehost():
adapter, _stub, _fake = _adapter()
@ -253,25 +167,6 @@ async def test_inbound_without_client_keeps_public_drops_rehost():
# ── RelayMediaClient unit surface ────────────────────────────────────────
def test_media_base_url_derivation():
assert media_base_url("wss://conn.example/relay") == "https://conn.example"
assert media_base_url("ws://localhost:8080/relay") == "http://localhost:8080"
assert media_base_url("https://conn.example") == "https://conn.example"
def test_client_enabled_requires_full_credentials():
assert RelayMediaClient("https://c.example", "gw1", "sec").enabled is True
assert RelayMediaClient("https://c.example", None, "sec").enabled is False
assert RelayMediaClient("https://c.example", "gw1", None).enabled is False
assert RelayMediaClient("", "gw1", "sec").enabled is False
def test_client_recognizes_rehost_urls():
c = RelayMediaClient("https://c.example", "gw1", "sec")
assert c.is_relay_media_url("https://c.example/relay/media/abc") is True
assert c.is_relay_media_url("https://cdn.discordapp.com/a/b.png") is False
@pytest.mark.asyncio
async def test_client_upload_rejects_oversize_and_missing(tmp_path: Path):
c = RelayMediaClient("https://c.example", "gw1", "sec")

75
tests/gateway/relay/test_relay_multiplatform.py
View file

@ -39,18 +39,6 @@ def _clean_env(monkeypatch):
# ─────────────────────────── identity parsing ───────────────────────────
def test_identities_default_relay_when_unconfigured():
assert relay.relay_platform_identities() == [("relay", "")]
# The primary helper mirrors the first identity.
assert relay.relay_platform_identity() == ("relay", "")
def test_identities_single_platform(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setenv("GATEWAY_RELAY_BOT_IDS", json.dumps({"discord": {"botId": "app-1"}}))
assert relay.relay_platform_identities() == [("discord", "app-1")]
assert relay.relay_platform_identity() == ("discord", "app-1")
def test_identities_multi_platform_keyed_map(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord, telegram")
@ -72,14 +60,6 @@ def test_identities_multi_platform_keyed_map(monkeypatch):
assert relay.relay_bot_username("discord") is None
def test_identities_platform_missing_from_map_gets_empty_bot_id(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord,telegram")
monkeypatch.setenv("GATEWAY_RELAY_BOT_IDS", json.dumps({"discord": {"botId": "app-1"}}))
# telegram is listed but absent from the ids map ⇒ empty bot_id (the
# connector rejects an unprovisioned platform with a structured failure).
assert relay.relay_platform_identities() == [("discord", "app-1"), ("telegram", "")]
def test_bot_ids_malformed_json_degrades_to_empty(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setenv("GATEWAY_RELAY_BOT_IDS", "{not valid json")
@ -118,35 +98,6 @@ def test_self_provision_loops_per_platform(monkeypatch):
assert os.environ["GATEWAY_RELAY_SECRET"] == "s" * 64
def test_self_provision_partial_failure_tolerant(monkeypatch):
_arm(monkeypatch)
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord,telegram")
monkeypatch.setenv(
"GATEWAY_RELAY_BOT_IDS",
json.dumps({"discord": {"botId": "app-1"}, "telegram": {"botId": "bot-9"}}),
)
def _fake(**kwargs):
if kwargs["platform"] == "telegram":
raise RuntimeError("telegram provision boom")
return {"secret": "s" * 64, "deliveryKey": "d" * 64, "tenant": "t", "gatewayId": kwargs["gateway_id"]}
monkeypatch.setattr(relay, "_post_provision", _fake)
# discord succeeds, telegram fails ⇒ still True (at least one fronted).
assert relay.self_provision_relay() is True
def test_self_provision_all_fail_returns_false(monkeypatch):
_arm(monkeypatch)
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord,telegram")
def _fake(**kwargs):
raise RuntimeError("boom")
monkeypatch.setattr(relay, "_post_provision", _fake)
assert relay.self_provision_relay() is False
# ─────────────────────────── per-frame egress (adapter) ───────────────────────────
@pytest.mark.asyncio
@ -201,29 +152,3 @@ async def test_adapter_stamps_per_frame_platform_from_inbound(monkeypatch):
assert stub.sent_platforms[-1] == "discord"
@pytest.mark.asyncio
async def test_adapter_untagged_when_chat_platform_unknown(monkeypatch):
"""A reply to a chat we never saw inbound for carries no per-frame platform
(the connector falls back to the session default)."""
from gateway.config import Platform, PlatformConfig
from gateway.relay.adapter import RelayAdapter
from gateway.relay.descriptor import CONTRACT_VERSION, CapabilityDescriptor
from tests.gateway.relay.stub_connector import StubConnector
descriptor = CapabilityDescriptor(
contract_version=CONTRACT_VERSION,
platform="relay",
label="Relay",
max_message_length=4096,
supports_draft_streaming=False,
supports_edit=True,
supports_threads=False,
markdown_dialect="plain",
len_unit="chars",
)
stub = StubConnector(descriptor)
adapter = RelayAdapter(PlatformConfig(), descriptor, transport=stub)
await adapter.connect()
await adapter.send("never-seen", "reply")
assert stub.sent_platforms[-1] is None

176
tests/gateway/relay/test_relay_passthrough.py
View file

@ -75,12 +75,6 @@ def test_passthrough_from_wire_byte_preserves_body():
assert fwd.headers == [("content-type", "application/json")]
def test_passthrough_from_wire_tolerates_malformed_body():
"""A non-base64 body must not raise (the reader must never crash)."""
fwd = _passthrough_from_wire({"platform": "x", "bodyB64": "!!!not base64!!!"})
assert fwd.body == b""
@pytest.mark.asyncio
async def test_connect_wires_passthrough_handler_over_ws(adapter):
"""connect() registers the passthrough handler on the transport so a
@ -131,102 +125,6 @@ async def test_discord_interaction_routes_through_handle_message(adapter, monkey
assert adapter._scope_by_chat.get("chan-9") == "guild-7"
@pytest.mark.asyncio
async def test_message_component_interaction_uses_custom_id(adapter, monkeypatch):
"""A MESSAGE_COMPONENT (button) interaction surfaces its custom_id as text."""
await adapter.connect()
stub = adapter._transport
seen = []
async def fake_handle(event):
seen.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
fwd = _interaction_forward(
{
"id": "i2",
"type": 3, # MESSAGE_COMPONENT
"channel_id": "c2",
"guild_id": "g2",
"data": {"custom_id": "approve_btn"},
"member": {"user": {"id": "u2", "username": "x"}},
}
)
await stub.push_passthrough(fwd)
assert len(seen) == 1
assert seen[0].text == "approve_btn"
# Component interactions stay plain text — only APPLICATION_COMMANDs are
# normalized to slash commands.
assert seen[0].is_command() is False
@pytest.mark.asyncio
async def test_application_command_no_options_is_slash_command(adapter, monkeypatch):
"""/new with no options -> text '/new', dispatched as a COMMAND event."""
from gateway.platforms.base import MessageType
await adapter.connect()
stub = adapter._transport
seen = []
async def fake_handle(event):
seen.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
fwd = _interaction_forward(
{
"id": "i-new",
"type": 2,
"channel_id": "c3",
"guild_id": "g3",
"data": {"name": "new"},
"member": {"user": {"id": "u3", "username": "ben"}},
}
)
await stub.push_passthrough(fwd)
assert len(seen) == 1
ev = seen[0]
assert ev.text == "/new"
assert ev.message_type == MessageType.COMMAND
# Behavior contract: the dispatcher must recognize this as command 'new'.
assert ev.is_command() is True
assert ev.get_command() == "new"
assert ev.get_command_args() == ""
@pytest.mark.asyncio
async def test_application_command_scalar_options_append_values(adapter, monkeypatch):
"""Scalar options append their values space-separated: /model gpt-x."""
await adapter.connect()
stub = adapter._transport
seen = []
async def fake_handle(event):
seen.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
fwd = _interaction_forward(
{
"id": "i-model",
"type": 2,
"channel_id": "c4",
"guild_id": "g4",
"data": {
"name": "model",
"options": [{"name": "name", "type": 3, "value": "gpt-x"}],
},
"member": {"user": {"id": "u4", "username": "ben"}},
}
)
await stub.push_passthrough(fwd)
assert len(seen) == 1
ev = seen[0]
assert ev.text == "/model gpt-x"
assert ev.is_command() is True
assert ev.get_command() == "model"
assert ev.get_command_args() == "gpt-x"
@pytest.mark.asyncio
async def test_application_command_subcommand_nesting_renders_names_then_values(
adapter, monkeypatch
@ -268,77 +166,3 @@ async def test_application_command_subcommand_nesting_renders_names_then_values(
assert ev.get_command_args() == "run deploy"
@pytest.mark.asyncio
async def test_ping_interaction_produces_no_command(adapter, monkeypatch):
"""A PING (type 1) body — never normally forwarded — stays empty TEXT, not
a phantom command."""
from gateway.platforms.base import MessageType
await adapter.connect()
stub = adapter._transport
seen = []
async def fake_handle(event):
seen.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
fwd = _interaction_forward(
{
"id": "i-ping",
"type": 1, # PING
"channel_id": "c6",
"user": {"id": "u6", "username": "ben"},
}
)
await stub.push_passthrough(fwd)
assert len(seen) == 1
ev = seen[0]
assert ev.text == ""
assert ev.message_type == MessageType.TEXT
assert ev.is_command() is False
@pytest.mark.asyncio
async def test_malformed_interaction_body_does_not_raise(adapter, monkeypatch):
"""A non-JSON forward is logged and dropped — never crashes the read loop."""
await adapter.connect()
stub = adapter._transport
called = []
async def fake_handle(event):
called.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
bad = PassthroughForward(
platform="discord",
bot_id="appShared",
method="POST",
path="/x",
headers=[],
body=b"not json",
)
await stub.push_passthrough(bad) # must not raise
assert called == []
@pytest.mark.asyncio
async def test_non_discord_forward_dropped_cleanly(adapter, monkeypatch):
"""A platform with no gateway-side handler yet (e.g. twilio) is dropped, not raised."""
await adapter.connect()
stub = adapter._transport
called = []
async def fake_handle(event):
called.append(event)
monkeypatch.setattr(adapter, "handle_message", fake_handle)
fwd = PassthroughForward(
platform="twilio",
bot_id="bot1",
method="POST",
path="/webhooks/twilio/seg",
headers=[],
body=b"From=+1&Body=hi",
)
await stub.push_passthrough(fwd) # must not raise
assert called == []

95
tests/gateway/relay/test_relay_per_platform_caps.py
View file

@ -90,29 +90,6 @@ def _make_transport():
)
@pytest.mark.asyncio
async def test_transport_accumulates_descriptors_first_wins_as_default():
"""One descriptor frame per hello: the map holds each platform's, and the
scalar `_descriptor` (the handshake result / session default) stays the
FIRST one — the regression was last-writer-wins across platforms."""
t = _make_transport()
loop = asyncio.get_running_loop()
t._descriptor_ready = loop.create_future()
frame = {"type": "descriptor", "descriptor": TELEGRAM.__dict__}
await t._handle_frame(json.dumps(frame))
frame2 = {"type": "descriptor", "descriptor": DISCORD.__dict__}
await t._handle_frame(json.dumps(frame2))
# Per-platform map has both.
assert t.descriptor_for_platform("telegram").max_message_length == 4096
assert t.descriptor_for_platform("discord").max_message_length == 2000
assert t.descriptor_for_platform("slack") is None
# The session default is the FIRST (primary identity) — NOT overwritten.
assert t._descriptor.platform == "telegram"
assert (await t.handshake()).platform == "telegram"
@pytest.mark.asyncio
async def test_transport_descriptor_map_resets_on_redial(monkeypatch):
"""A re-dial starts a fresh handshake generation: stale per-platform
@ -175,78 +152,6 @@ async def test_adapter_resolves_per_chat_limits_from_inbound_platform():
assert adapter.message_len_fn_for_chat("dc-1")(surrogate) == 1
@pytest.mark.asyncio
async def test_adapter_unknown_chat_falls_back_to_scalar_descriptor():
stub = MultiDescriptorStub(TELEGRAM, DISCORD)
adapter = RelayAdapter(PlatformConfig(), TELEGRAM, transport=stub)
await adapter.connect()
# Never saw inbound for this chat — platform unknown -> scalar descriptor.
assert adapter.max_message_length_for_chat("never-seen") == 4096
@pytest.mark.asyncio
async def test_adapter_transport_without_map_falls_back_to_scalar():
"""A plain StubConnector (no descriptor_for_platform) — e.g. an older or
test transport — must keep the scalar behavior, not raise."""
stub = StubConnector(TELEGRAM)
adapter = RelayAdapter(PlatformConfig(), TELEGRAM, transport=stub)
await adapter.connect()
await _push(stub, Platform.DISCORD, "dc-1")
assert adapter.max_message_length_for_chat("dc-1") == 4096
def test_native_adapter_defaults_scalar():
"""BasePlatformAdapter's default per-chat hooks mirror the scalar surface
(native adapters are single-platform; nothing changes for them)."""
from gateway.platforms.base import BasePlatformAdapter
class _Native(BasePlatformAdapter):
MAX_MESSAGE_LENGTH = 1234
def __init__(self): # bypass Base __init__ plumbing
pass
async def connect(self, *, is_reconnect: bool = False) -> bool: # pragma: no cover
return True
async def disconnect(self) -> None: # pragma: no cover
pass
async def send(self, chat_id, content, reply_to=None, metadata=None): # pragma: no cover
raise NotImplementedError
async def get_chat_info(self, chat_id): # pragma: no cover
return {}
a = _Native()
assert a.max_message_length_for_chat("any") == 1234
assert a.message_len_fn_for_chat("any") is a.message_len_fn
# ───────────────────── stream consumer integration ─────────────────────
@pytest.mark.asyncio
async def test_stream_consumer_raw_limit_uses_per_chat_cap():
"""_raw_message_limit resolves the CHAT's platform cap on a relay adapter:
a Discord chat splits at 2000 even when the scalar descriptor says 4096.
Without the fix this returned 4096 and a 2,543-char reply reached Discord
whole -> HTTP 400."""
from gateway.stream_consumer import GatewayStreamConsumer
stub = MultiDescriptorStub(TELEGRAM, DISCORD)
stub._identities = [("telegram", "bot-9"), ("discord", "app-1")]
adapter = RelayAdapter(PlatformConfig(), TELEGRAM, transport=stub)
await adapter.connect()
await _push(stub, Platform.DISCORD, "dc-1")
await _push(stub, Platform.TELEGRAM, "tg-1")
dc = GatewayStreamConsumer.__new__(GatewayStreamConsumer)
dc.adapter = adapter
dc.chat_id = "dc-1"
assert dc._raw_message_limit() == 2000
tg = GatewayStreamConsumer.__new__(GatewayStreamConsumer)
tg.adapter = adapter
tg.chat_id = "tg-1"
assert tg._raw_message_limit() == 4096

88
tests/gateway/relay/test_relay_policy_send.py
View file

@ -51,48 +51,6 @@ def test_projection_maps_require_mention_and_free_response(monkeypatch):
}
def test_projection_allow_other_bots_from_env(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setenv("DISCORD_ALLOW_BOTS", "all")
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"discord": {"require_mention": True}},
raising=False,
)
pol = relay.relay_relevance_policy()
assert pol is not None and pol["allowOtherBots"] is True
def test_projection_comma_string_free_response(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"discord": {"free_response_channels": "c1, c2 ,c3"}},
raising=False,
)
pol = relay.relay_relevance_policy()
assert pol is not None and pol["freeResponseScopes"] == ["c1", "c2", "c3"]
def test_projection_falls_back_to_top_level_require_mention(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"require_mention": True}, # top-level, no discord: block
raising=False,
)
pol = relay.relay_relevance_policy()
assert pol is not None and pol["requireAddress"] is True
def test_projection_none_when_all_default(monkeypatch):
# No require_mention, no free-response, no allow-bots ⇒ nothing to declare
# (the connector's default — mention-gated — applies).
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setattr("gateway.run._load_gateway_config", lambda: {"discord": {}}, raising=False)
assert relay.relay_relevance_policy() is None
def test_projection_declares_explicit_require_mention_false(monkeypatch):
# An EXPLICIT `require_mention: false` is a configured (non-default) choice
# and MUST be declared: the connector's absent-row default is now
@ -113,28 +71,6 @@ def test_projection_declares_explicit_require_mention_false(monkeypatch):
}
def test_projection_declares_explicit_top_level_require_mention_false(monkeypatch):
# Same as above via the bridged top-level key.
monkeypatch.setenv("GATEWAY_RELAY_PLATFORMS", "discord")
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"require_mention": False},
raising=False,
)
pol = relay.relay_relevance_policy()
assert pol is not None and pol["requireAddress"] is False
def test_projection_none_when_platform_unresolved(monkeypatch):
# Default platform "relay" ⇒ no concrete fronted platform ⇒ nothing to project.
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"discord": {"require_mention": True}},
raising=False,
)
assert relay.relay_relevance_policy() is None
# --------------------------------------------------------------------------
# send_relay_policy() — the boot-time declaration
# --------------------------------------------------------------------------
@ -184,15 +120,6 @@ def test_send_skips_when_no_secret(monkeypatch):
assert called["n"] == 0 # never attempted without a secret to auth with
def test_send_skips_when_nothing_to_declare(monkeypatch):
_arm(monkeypatch)
monkeypatch.setattr("gateway.run._load_gateway_config", lambda: {"discord": {}}, raising=False)
called = {"n": 0}
monkeypatch.setattr(relay, "_post_policy", lambda **k: called.__setitem__("n", called["n"] + 1) or 200)
assert relay.send_relay_policy() is False
assert called["n"] == 0 # no redundant write of the default
def test_send_fail_soft_on_transport_error(monkeypatch):
_arm(monkeypatch)
monkeypatch.setattr(
@ -209,18 +136,3 @@ def test_send_fail_soft_on_transport_error(monkeypatch):
assert relay.send_relay_policy() is False
def test_send_fail_soft_on_non_200(monkeypatch):
_arm(monkeypatch)
monkeypatch.setattr(
"gateway.run._load_gateway_config",
lambda: {"discord": {"require_mention": True}},
raising=False,
)
monkeypatch.setattr(relay, "_post_policy", lambda **k: 401)
assert relay.send_relay_policy() is False
def test_send_skips_when_relay_unconfigured(monkeypatch):
# No GATEWAY_RELAY_URL ⇒ relay not configured ⇒ no-op.
monkeypatch.setattr(relay, "_post_policy", lambda **k: 200)
assert relay.send_relay_policy() is False

22
tests/gateway/relay/test_relay_registration.py
View file

@ -42,25 +42,3 @@ def test_registers_when_url_configured(monkeypatch):
assert platform_registry.is_registered("relay") is True
def test_explicit_url_arg_registers():
assert register_relay_adapter(url="wss://connector.example/relay") is True
assert platform_registry.is_registered("relay") is True
def test_force_registers_without_url():
assert register_relay_adapter(force=True) is True
assert platform_registry.is_registered("relay") is True
def test_trailing_slash_stripped(monkeypatch):
monkeypatch.setenv("GATEWAY_RELAY_URL", "wss://connector.example/relay/")
assert relay_url() == "wss://connector.example/relay"
def test_create_adapter_yields_relay_adapter():
# force=True builds a transport-less adapter (no live dial in unit tests).
register_relay_adapter(force=True)
adapter = platform_registry.create_adapter("relay", PlatformConfig())
assert isinstance(adapter, RelayAdapter)
# Placeholder descriptor until handshake negotiates the real one.
assert adapter.descriptor.platform == "relay"

77
tests/gateway/relay/test_relay_roundtrip.py
View file

@ -84,83 +84,6 @@ async def test_inbound_event_reaches_adapter(wired, monkeypatch):
assert captured[0].source.scope_id == "guildA"
@pytest.mark.asyncio
async def test_two_scopes_isolate_into_distinct_session_keys(wired):
adapter, _ = wired
ev_a = _discord_event("guildA", "chan1", "userX", "hi from A")
ev_b = _discord_event("guildB", "chan2", "userX", "hi from B")
key_a = build_session_key(ev_a.source)
key_b = build_session_key(ev_b.source)
assert key_a != key_b
# Same scope + channel + user collapses to one session.
ev_a2 = _discord_event("guildA", "chan1", "userX", "again")
assert build_session_key(ev_a2.source) == key_a
@pytest.mark.asyncio
async def test_outbound_send_round_trips(wired):
adapter, stub = wired
await adapter.connect()
stub.next_send_result = {"success": True, "message_id": "msg-42"}
result = await adapter.send("chan1", "a reply", metadata={"k": "v"})
assert result.success is True
assert result.message_id == "msg-42"
assert len(stub.sent) == 1
assert stub.sent[0]["op"] == "send"
assert stub.sent[0]["chat_id"] == "chan1"
assert stub.sent[0]["content"] == "a reply"
@pytest.mark.asyncio
async def test_get_chat_info_proxied_to_connector(wired):
adapter, stub = wired
# Phase 1: the proxy is gated on op discovery — the connector must
# advertise get_chat_info in supported_ops (a legacy descriptor falls
# back to the local echo; see test_relay_adapter.py).
adapter._apply_descriptor(
replace(_discord_descriptor(), supported_ops=("send", "edit", "typing", "get_chat_info"))
)
stub.chat_info["chan1"] = {"name": "general", "type": "group"}
info = await adapter.get_chat_info("chan1")
assert info == {"name": "general", "type": "group"}
@pytest.mark.asyncio
async def test_keep_typing_loop_emits_typing_frames_with_scope(wired):
"""E2E through the REAL base-class refresh loop: the same ``_keep_typing``
task ``_process_message_background`` spawns for every turn must produce
``op="typing"`` frames on the relay transport, carrying the tenant
discriminator captured from the inbound event (the connector's egress
guard declines undiscriminated frames). Regression: RelayAdapter inherited
the base no-op send_typing, so this loop ran all turn and emitted nothing —
no \"is typing…\" on any relay-fronted platform."""
import asyncio
adapter, stub = wired
await adapter.connect()
# Inbound captures chan1 -> guildA (scope) exactly as a real turn would.
adapter._capture_scope(_discord_event("guildA", "chan1", "userX", "hello"))
stop = asyncio.Event()
task = asyncio.create_task(
adapter._keep_typing("chan1", interval=0.05, stop_event=stop)
)
await asyncio.sleep(0.12) # >= 2 ticks
stop.set()
await asyncio.wait_for(task, timeout=1.0)
typing_frames = [f for f in stub.sent if f.get("op") == "typing"]
assert len(typing_frames) >= 2, f"expected repeated typing frames, got {stub.sent}"
for frame in typing_frames:
assert frame["chat_id"] == "chan1"
assert frame["metadata"].get("scope_id") == "guildA"
# Phase 1.5: each frame is tagged with the underlying platform for egress.
typing_platforms = [
p for f, p in zip(stub.sent, stub.sent_platforms) if f.get("op") == "typing"
]
assert all(p == "discord" for p in typing_platforms)
async def _async_capture(sink, event):
sink.append(event)
return None

54
tests/gateway/relay/test_relay_roundtrip_telegram.py
View file

@ -108,60 +108,6 @@ async def test_inbound_telegram_event_reaches_adapter(wired, monkeypatch):
assert captured[0].source.scope_id is None # Telegram has no scope
@pytest.mark.asyncio
async def test_two_telegram_chats_isolate_by_chat_id(wired):
"""No scope_id on Telegram — two distinct chats must still isolate, keyed
on chat_id alone (the Discord-scope role is played by chat_id here)."""
ev_a = _tg_group_event("chat-A", "userX", "hi A")
ev_b = _tg_group_event("chat-B", "userX", "hi B")
key_a = build_session_key(ev_a.source)
key_b = build_session_key(ev_b.source)
assert key_a != key_b
# Same chat + same user collapses to one session.
ev_a2 = _tg_group_event("chat-A", "userX", "again")
assert build_session_key(ev_a2.source) == key_a
@pytest.mark.asyncio
async def test_forum_topics_isolate_by_thread_id_within_one_chat(wired):
"""Telegram forum topics share a single chat_id and isolate by thread_id —
the Telegram analog of Discord per-scope isolation. Two topics in the same
forum must NOT collide, and (threads shared across participants by default)
a second user in the same topic shares the session."""
topic1 = _tg_group_event("forum-1", "userX", "in topic 1", thread_id="t-1")
topic2 = _tg_group_event("forum-1", "userX", "in topic 2", thread_id="t-2")
k1 = build_session_key(topic1.source)
k2 = build_session_key(topic2.source)
assert k1 != k2, "two forum topics in one chat must not share a session"
# Same chat, no topic → distinct from any topic session.
plain = _tg_group_event("forum-1", "userX", "no topic")
assert build_session_key(plain.source) not in {k1, k2}
# Threads are shared across participants by default: a different user in the
# same topic lands on the SAME session key (user_id not appended in threads).
topic1_other_user = _tg_group_event("forum-1", "userY", "me too", thread_id="t-1")
assert build_session_key(topic1_other_user.source) == k1
@pytest.mark.asyncio
async def test_telegram_dm_isolates_by_chat_id(wired):
dm_a = _tg_dm_event("dm-111", "userX", "hey")
dm_b = _tg_dm_event("dm-222", "userY", "yo")
assert build_session_key(dm_a.source) != build_session_key(dm_b.source)
assert build_session_key(dm_a.source).startswith("agent:main:telegram:dm:")
@pytest.mark.asyncio
async def test_outbound_send_round_trips_telegram(wired):
adapter, stub = wired
await adapter.connect()
stub.next_send_result = {"success": True, "message_id": "tg-77"}
result = await adapter.send("chat-100", "a reply")
assert result.success is True
assert result.message_id == "tg-77"
assert stub.sent[0]["op"] == "send"
assert stub.sent[0]["chat_id"] == "chat-100"
async def _async_capture(sink, event):
sink.append(event)
return None

49
tests/gateway/relay/test_relay_sheds_crypto.py
View file

@ -58,30 +58,6 @@ def _relay_py_files() -> list[Path]:
_CHANNEL_AUTH_FILES = {"auth.py"}
def test_relay_package_imports_no_platform_crypto():
"""No module in gateway/relay imports a platform-crypto / verification module."""
offenders: list[str] = []
for path in _relay_py_files():
tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
for node in ast.walk(tree):
mods: list[str] = []
if isinstance(node, ast.Import):
mods = [alias.name for alias in node.names]
elif isinstance(node, ast.ImportFrom):
mods = [node.module or ""]
mods += [f"{node.module or ''}.{a.name}" for a in node.names]
for mod in mods:
if any(tok in mod for tok in _FORBIDDEN_MODULE_TOKENS):
offenders.append(f"{path.name}: imports '{mod}'")
assert not offenders, (
"The relay path must re-validate NOTHING (A2: connector is the sole "
"crypto boundary). Found platform-crypto imports in the relay package:\n "
+ "\n ".join(offenders)
+ "\nMove verification to the connector edge; the gateway trusts the "
"normalized MessageEvent. See docs/relay-connector-contract.md §6."
)
def test_relay_package_calls_no_signature_verification():
"""No relay module references a PLATFORM signature/crypto-verification symbol.
@ -112,28 +88,3 @@ def test_relay_package_calls_no_signature_verification():
)
def test_channel_auth_uses_only_stdlib_crypto_not_platform_modules():
"""auth.py (channel authenticator) imports only stdlib crypto, no platform crypto.
Positive guard: the connector⇄gateway channel auth is allowed to do HMAC,
but it must do so with stdlib primitives over connector-owned secrets — it
must never reach for a platform-crypto module. This keeps the exemption
above honest (auth.py can't smuggle in platform verification).
"""
auth_py = _RELAY_PKG / "auth.py"
assert auth_py.is_file(), "gateway/relay/auth.py (channel authenticator) is missing"
tree = ast.parse(auth_py.read_text(encoding="utf-8"), filename=str(auth_py))
imported: list[str] = []
for node in ast.walk(tree):
if isinstance(node, ast.Import):
imported += [a.name for a in node.names]
elif isinstance(node, ast.ImportFrom):
imported.append(node.module or "")
# No platform-crypto module import.
assert not [m for m in imported if any(tok in m for tok in _FORBIDDEN_MODULE_TOKENS)], (
f"auth.py must not import platform crypto; imports={imported}"
)
# It does use stdlib hmac/hashlib (that's how it authenticates the channel).
assert "hmac" in imported and "hashlib" in imported, (
f"auth.py should authenticate the channel with stdlib hmac/hashlib; imports={imported}"
)

156
tests/gateway/relay/test_relay_threads.py
View file

@ -86,37 +86,6 @@ async def test_create_handoff_thread_routes_thread_create():
assert action["thread_name"] == "fix the build"
@pytest.mark.asyncio
async def test_create_handoff_thread_op_gated_and_decline_safe():
# Not advertised → None without touching the wire.
adapter, stub = _adapter(supported_ops=("send", "edit", "typing"))
assert await adapter.create_handoff_thread("chan1", "x") is None
assert stub.sent == []
# Advertised but declined (non-forum Telegram chat, missing perms) → None.
adapter2, stub2 = _adapter()
async def declined(action, *, platform=None):
stub2.sent.append(action)
return {"success": False, "error": "not a forum"}
stub2.send_outbound = declined # type: ignore[method-assign]
assert await adapter2.create_handoff_thread("chan1", "x") is None
@pytest.mark.asyncio
async def test_create_handoff_thread_falls_back_to_message_id():
# Slack shape: the connector returns the seed ts as message_id+thread_id;
# older stubs may return only message_id — either resolves.
adapter, stub = _adapter()
async def send_outbound(action, *, platform=None):
stub.sent.append(action)
return {"success": True, "message_id": "170.001"}
stub.send_outbound = send_outbound # type: ignore[method-assign]
assert await adapter.create_handoff_thread("C1", "handoff") == "170.001"
# ── rename_thread (semantic rename) ──────────────────────────────────────
@ -149,87 +118,12 @@ async def test_rename_thread_parent_chat_and_gating():
assert gated_stub.sent == []
@pytest.mark.asyncio
async def test_rename_thread_decline_returns_false():
adapter, stub = _adapter()
async def declined(action, *, platform=None):
stub.sent.append(action)
return {"success": False, "error": "guard: current name differs"}
stub.send_outbound = declined # type: ignore[method-assign]
assert await adapter.rename_thread("th1", "x", only_if_current_name="H") is False
# ── the relay semantic-rename lane (marker parity) ───────────────────────
def test_relay_source_satisfies_auto_thread_lane_field_contract():
"""The native lane check reads platform/chat_type/thread_id +
auto_thread_created + auto_thread_initial_name off the source. A relay
event carrying the connector-stamped markers must present ALL of them
through _event_from_wire — same field contract, no relay-specific case.
"""
event = _event_from_wire(
{
"text": "hi",
"message_type": "text",
"source": {
"platform": "discord",
"chat_id": "th9",
"chat_type": "thread",
"thread_id": "th9",
"user_id": "u1",
"auto_thread_created": True,
"auto_thread_initial_name": "Hermes reply",
},
}
)
src = event.source
assert src.chat_type == "thread"
assert src.thread_id == "th9"
assert src.auto_thread_created is True
assert src.auto_thread_initial_name == "Hermes reply"
# And absent markers default off (never light the lane spuriously).
plain = _event_from_wire(
{
"text": "hi",
"message_type": "text",
"source": {
"platform": "discord",
"chat_id": "c",
"chat_type": "thread",
"thread_id": "t",
},
}
)
assert plain.source.auto_thread_created is False
assert plain.source.auto_thread_initial_name is None
# ── reply_to wire parse ──────────────────────────────────────────────────
def test_event_from_wire_maps_reply_to_onto_native_fields():
event = _event_from_wire(
{
"text": "re",
"message_type": "text",
"source": {"platform": "telegram", "chat_id": "5", "chat_type": "dm"},
"reply_to_message_id": "19",
"reply_to": {
"text": "what the bot said",
"author": "hermesbot",
"is_own": True,
},
}
)
assert event.reply_to_message_id == "19"
assert event.reply_to_text == "what the bot said"
assert event.reply_to_author_name == "hermesbot"
assert event.reply_to_is_own_message is True
def test_event_from_wire_reply_to_absent_and_partial():
plain = _event_from_wire(
{
@ -256,53 +150,3 @@ def test_event_from_wire_reply_to_absent_and_partial():
# ── hello command manifest ───────────────────────────────────────────────
def test_manifest_entries_satisfy_discord_naming_rules():
manifest = build_relay_command_manifest()
assert len(manifest) > 0
assert len(manifest) <= 100 # Discord's global command cap
name_re = re.compile(r"^[a-z0-9_-]{1,32}$")
seen = set()
for entry in manifest:
assert name_re.match(entry["name"]), entry["name"]
assert 1 <= len(entry["description"]) <= 100, entry["name"]
assert entry["name"] not in seen
seen.add(entry["name"])
for opt in entry.get("options", []):
assert name_re.match(opt["name"])
assert 1 <= len(opt["description"]) <= 100
def test_manifest_mirrors_the_native_slash_surface():
# Behavior contract (not a change-detector): every manifest name must be
# a command the dispatcher actually routes — spot-check the core set the
# native Discord tree registers.
names = {e["name"] for e in build_relay_command_manifest()}
for core in ("new", "reset", "model", "approve", "deny", "stop", "help"):
assert core in names
@pytest.mark.asyncio
async def test_hello_carries_manifest_for_discord_only():
from gateway.relay.ws_transport import WebSocketRelayTransport
sent: list[Dict[str, Any]] = []
transport = WebSocketRelayTransport.__new__(WebSocketRelayTransport)
transport._identities = [("discord", "app1"), ("telegram", "tg1")]
async def fake_send(frame):
sent.append(frame)
transport._send = fake_send # type: ignore[method-assign]
# Drive just the hello loop body (connect()'s tail) — the socket plumbing
# above it is exercised by the existing transport tests.
for platform, bot_id in transport._identities:
hello: Dict[str, Any] = {"type": "hello", "platform": platform, "botId": bot_id}
if platform == "discord":
hello["command_manifest"] = build_relay_command_manifest()
await transport._send(hello)
assert sent[0]["platform"] == "discord"
assert "command_manifest" in sent[0]
assert sent[1]["platform"] == "telegram"
assert "command_manifest" not in sent[1]

14
tests/gateway/relay/test_wire_user_identity.py
View file

@ -35,13 +35,7 @@ def _wire_event(**src_overrides):
class TestUserIdentityEnrichment:
def test_display_name_preferred_over_user_name(self):
ev = _event_from_wire(_wire_event(user_display_name="Ben Display"))
assert ev.source.user_name == "Ben Display"
def test_user_name_when_no_display_name(self):
ev = _event_from_wire(_wire_event())
assert ev.source.user_name == "rawusername"
def test_handle_is_last_resort(self):
ev = _event_from_wire(
@ -49,14 +43,6 @@ class TestUserIdentityEnrichment:
)
assert ev.source.user_name == "ben#1234"
def test_all_absent_yields_none(self):
ev = _event_from_wire(_wire_event(user_name=None))
assert ev.source.user_name is None
def test_empty_display_name_falls_through(self):
"""An empty-string enrichment must not shadow a real user_name."""
ev = _event_from_wire(_wire_event(user_display_name=""))
assert ev.source.user_name == "rawusername"
def test_session_key_is_stable_across_name_shapes(self):
"""user_name is presentation-only: the same user_id keys the same

88
tests/gateway/relay/test_ws_transport.py
View file

@ -137,70 +137,6 @@ async def test_inbound_frame_reaches_handler(server):
await t.disconnect()
@pytest.mark.asyncio
async def test_outbound_round_trips_with_correlation(server):
t = WebSocketRelayTransport(server.url, "discord", "appShared")
await t.connect()
try:
await t.handshake()
result = await t.send_outbound({"op": "send", "chat_id": "chan1", "content": "hi"})
assert result["success"] is True
assert result["message_id"] == "srv-send"
finally:
await t.disconnect()
@pytest.mark.asyncio
async def test_follow_up_round_trips(server):
t = WebSocketRelayTransport(server.url, "discord", "appShared")
await t.connect()
try:
await t.handshake()
result = await t.send_follow_up(
{"op": "follow_up", "session_key": "s1", "kind": "discord.interaction_token", "content": "fu"}
)
assert result["success"] is True
assert result["message_id"] == "srv-follow_up"
# The follow_up rode an outbound frame the connector saw.
outbound = [f for f in server.received if f["type"] == "outbound"]
assert any(f["action"]["op"] == "follow_up" for f in outbound)
finally:
await t.disconnect()
@pytest.mark.asyncio
async def test_disconnect_fails_pending_waiters_cleanly(server):
t = WebSocketRelayTransport(server.url, "discord", "appShared", outbound_timeout_s=5)
await t.connect()
await t.handshake()
await t.disconnect()
# After disconnect, an outbound returns a structured failure rather than hanging.
result = await t.send_outbound({"op": "send", "chat_id": "c", "content": "x"})
assert result["success"] is False
def test_https_url_normalized_to_wss():
"""The relay URL is configured once as the http(s):// BASE (for the provision
POST), but websockets.connect needs ws(s):// and the connector mounts its WS
server at /relay. The transport must convert scheme AND ensure the /relay
path. Regression for the live staging failures 'scheme isn't ws or wss' then
'server rejected WebSocket connection: HTTP 400' (wrong path)."""
t = WebSocketRelayTransport("https://connector.example", "discord", "b")
assert t._url == "wss://connector.example/relay"
t2 = WebSocketRelayTransport("http://connector.local:8080", "discord", "b")
assert t2._url == "ws://connector.local:8080/relay"
def test_ws_dial_url_idempotent_with_scheme_and_path():
# Already ws(s):// and/or already ending in /relay -> unchanged (no double append).
t = WebSocketRelayTransport("wss://connector.example/relay", "discord", "b")
assert t._url == "wss://connector.example/relay"
t2 = WebSocketRelayTransport("https://connector.example/relay/", "discord", "b")
assert t2._url == "wss://connector.example/relay"
t3 = WebSocketRelayTransport("ws://127.0.0.1:9", "discord", "b")
assert t3._url == "ws://127.0.0.1:9/relay"
# ── Phase 7 Unit 7d-B: terminal 4401 (opt-out revocation) ────────────────────
@ -272,27 +208,3 @@ async def test_4401_after_handshake_is_terminal_no_reconnect():
await srv.stop()
@pytest.mark.asyncio
async def test_4401_before_handshake_stays_retryable():
"""A 4401 close BEFORE any successful handshake is a cold-start / not-yet-
provisioned race, NOT a revocation: it stays retryable (reconnect runs)."""
srv = _Revoking4401Server(send_descriptor_first=False)
await srv.start()
try:
t = WebSocketRelayTransport(
srv.url, "discord", "appShared",
gateway_id="gw-x", upgrade_secret="secret-x",
reconnect=True, reconnect_backoff_s=0.05,
)
await t.connect()
# No handshake ever succeeded; the 4401 must NOT latch auth_revoked.
for _ in range(50):
if t._supervisor is not None:
break
await asyncio.sleep(0.02)
assert t.auth_revoked is False
# The reconnect supervisor IS running (retrying), since this is not terminal.
assert t._supervisor is not None
finally:
await t.disconnect()
await srv.stop()

71
tests/gateway/test_13121_shutdown_inflight_transcript_flush.py
View file

@ -107,39 +107,6 @@ class TestFinalizeShutdownFlushesInflightTranscript:
# Cleanup still happens after the flush.
agent.close.assert_called_once()
def test_empty_session_messages_not_flushed(self):
"""An agent that ran no turns (empty list) triggers no flush — there
is nothing in flight to persist."""
runner = _make_runner()
agent = _FakeAgent(session_messages=[])
_finalize(runner, {"k": agent})
agent._flush_messages_to_session_db.assert_not_called()
agent.close.assert_called_once()
def test_missing_flush_method_is_tolerated(self):
"""A stub agent without the flush method (object.__new__ test stubs)
must not break shutdown — teardown still runs."""
runner = _make_runner()
agent = _FakeAgent(session_messages=[{"role": "user", "content": "x"}],
has_flush=False)
_finalize(runner, {"k": agent})
agent.close.assert_called_once()
def test_flush_exception_is_swallowed(self):
"""A raising flush must not prevent teardown — a transcript-flush
failure is best-effort, losing tool resources is worse."""
runner = _make_runner()
agent = _FakeAgent(session_messages=[{"role": "user", "content": "x"}])
agent._flush_messages_to_session_db.side_effect = RuntimeError("db locked")
_finalize(runner, {"k": agent})
agent.close.assert_called_once()
# ─────────────────────────────────────────────────────────────────────────
# E2E: real AIAgent flush → real SessionDB → real load_transcript.
@ -220,41 +187,3 @@ class TestShutdownTranscriptSurvivesResumeE2E:
# branch in _handle_message_with_agent expects to handle.
assert roles[-1] == "tool", roles
def test_graceful_agent_reflush_is_idempotent(self, tmp_path, monkeypatch):
"""An agent that already flushed via finalize_turn must not produce
duplicate rows when _finalize_shutdown_agents re-flushes."""
monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes"))
from hermes_state import SessionDB
from run_agent import AIAgent
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "sess-e2e-idem"
db.create_session(session_id=session_id, source="discord")
msgs = [
{"role": "user", "content": "what is 2+2"},
{"role": "assistant", "content": "4"},
]
agent = object.__new__(AIAgent)
agent._session_db = db
agent._session_db_created = True
agent.session_id = session_id
agent.platform = "discord"
agent._session_messages = msgs
agent._last_flushed_db_idx = 0
agent._flushed_db_message_ids = set()
agent._flushed_db_message_session_id = None
# First flush (simulating finalize_turn).
agent._flush_messages_to_session_db(msgs)
assert len(db.get_messages_as_conversation(session_id)) == 2
# Shutdown re-flush of the SAME list identity must add nothing.
from gateway.run import GatewayRunner
runner = object.__new__(GatewayRunner)
_finalize(runner, {"k": agent})
after = db.get_messages_as_conversation(session_id)
assert len(after) == 2, after

23
tests/gateway/test_25107_stale_base_url_api_mode.py
View file

@ -142,29 +142,6 @@ async def test_typed_switch_to_custom_clears_stale_base_url_and_api_mode(tmp_pat
)
@pytest.mark.asyncio
async def test_typed_switch_to_custom_persists_resolved_base_url_and_api_mode(tmp_path, monkeypatch):
"""The normal case: a custom-provider switch that DOES resolve a fresh
base_url/api_mode must persist both (api_mode was never written here
before the fix)."""
cfg_path = _setup_isolated_home(
tmp_path,
monkeypatch,
dict(_STALE_MODEL_CFG),
base_url="https://new-endpoint.example/v1",
api_mode="anthropic_messages",
)
result = await _make_runner()._handle_model_command(
_make_event("/model local-llama --provider custom --global")
)
assert result is not None
written = yaml.safe_load(cfg_path.read_text(encoding="utf-8"))
assert written["model"]["base_url"] == "https://new-endpoint.example/v1"
assert written["model"]["api_mode"] == "anthropic_messages"
# ---------------------------------------------------------------------------
# Picker-tap path (_on_model_selected)
# ---------------------------------------------------------------------------

22
tests/gateway/test_35809_auto_reset_clean_context.py
View file

@ -197,25 +197,3 @@ class TestAutoResetLoadsCleanContext:
# The old transcript is still searchable, not destroyed.
assert len(store.load_transcript(bloated_sid)) == 120
def test_clean_context_survives_gateway_restart(self, tmp_path):
"""The fresh, empty session must still be the one loaded after a
gateway restart (sessions.json + state.db round-trip)."""
store = _make_store(tmp_path)
source = _make_source()
entry = store.get_or_create_session(source)
bloated_sid = entry.session_id
store._db.create_session(
session_id=bloated_sid, source="telegram", user_id="u1"
)
store._db.replace_messages(bloated_sid, _bloat(120))
new_entry = store.reset_session(entry.session_key)
new_sid = new_entry.session_id
# Simulate restart: drop in-memory index, reload from disk.
store._loaded = False
store._entries.clear()
reloaded = store.get_or_create_session(source)
assert reloaded.session_id == new_sid
assert store.load_transcript(reloaded.session_id) == []

139
tests/gateway/test_42039_duplicate_user_message.py
View file

@ -156,33 +156,6 @@ async def test_agent_failed_early_skip_db_when_agent_has_session_db(
# ── Test 2: agent_failed_early with no _session_db → skip_db not True ─
@pytest.mark.asyncio
async def test_agent_failed_early_no_skip_db_when_no_session_db(
monkeypatch, tmp_path
):
runner = _bootstrap(monkeypatch, tmp_path)
runner._session_db = None # No agent DB → agent_persisted=False
runner._run_agent = AsyncMock(
return_value={
"failed": True,
"final_response": None,
"error": "ReadTimeout: timed out",
"messages": [],
"history_offset": 0,
"last_prompt_tokens": 0,
}
)
await runner._handle_message_with_agent(
_event(), _source(), "agent:main:telegram:group:-1001:12345", 1
)
_assert_user_call_has_skip_db(
runner.session_store.append_to_transcript.call_args_list, False
)
# ── Test 3: not-new-messages path uses skip_db=True ───────────────────
@ -215,118 +188,6 @@ async def test_not_new_messages_skip_db_when_agent_has_session_db(
# ── Post-stream MEDIA delivery keeps prior-turn deduplication ──────────
@pytest.mark.asyncio
async def test_streamed_response_receives_prior_turn_media_paths(
monkeypatch, tmp_path
):
"""An ordinary streamed reply completes the post-stream delivery branch.
The history-derived dedup set is part of that branch's contract, rather
than an optional best-effort hint: passing an undefined local crashes the
entire reply, while passing an empty set reintroduces duplicate MEDIA
attachments on later streamed responses.
"""
runner = _bootstrap(monkeypatch, tmp_path)
prior_path = "/tmp/already-delivered.png"
runner.session_store.load_transcript.return_value = [
{"role": "assistant", "content": f"MEDIA:{prior_path}"},
]
runner.adapters = {Platform.TELEGRAM: MagicMock()}
runner._deliver_media_from_response = AsyncMock()
runner._run_agent = AsyncMock(
return_value={
"final_response": "the streamed reply completed normally",
"messages": [
{"role": "assistant", "content": f"MEDIA:{prior_path}"},
{"role": "user", "content": "what is my status?"},
{"role": "assistant", "content": "the streamed reply completed normally"},
],
"tools": [],
"history_offset": 1,
"last_prompt_tokens": 0,
"already_sent": True,
"failed": False,
}
)
response = await runner._handle_message_with_agent(
_event(), _source(), "agent:main:telegram:group:-1001:12345", 1
)
assert response is None
runner._deliver_media_from_response.assert_awaited_once()
assert runner._deliver_media_from_response.await_args.kwargs[
"history_media_paths"
] == {prior_path}
# ── Test 4: normal path (new_messages found) uses skip_db=True ────────
@pytest.mark.asyncio
async def test_normal_path_skip_db_when_agent_has_session_db(
monkeypatch, tmp_path
):
runner = _bootstrap(monkeypatch, tmp_path)
# Agent succeeds with new messages
runner._run_agent = AsyncMock(
return_value={
"final_response": "Hello!",
"messages": [
{"role": "user", "content": "hi"},
{"role": "assistant", "content": "Hello!"},
],
"tools": [],
"history_offset": 0,
"last_prompt_tokens": 0,
}
)
await runner._handle_message_with_agent(
_event(), _source(), "agent:main:telegram:group:-1001:12345", 1
)
_assert_user_call_has_skip_db(
runner.session_store.append_to_transcript.call_args_list, True
)
@pytest.mark.asyncio
async def test_nonempty_rate_limit_error_is_not_persisted_as_assistant_message(
monkeypatch, tmp_path
):
runner = _bootstrap(monkeypatch, tmp_path)
error_response = "API call failed after 3 retries: 429 Too Many Requests"
runner._run_agent = AsyncMock(
return_value={
"failed": True,
"failure_reason": "rate_limit",
"completed": False,
"final_response": error_response,
"error": "429 Too Many Requests",
"messages": [
{"role": "user", "content": "hello world"},
],
"history_offset": 0,
"last_prompt_tokens": 0,
}
)
await runner._handle_message_with_agent(
_event(), _source(), "agent:main:telegram:group:-1001:12345", 1
)
persisted_entries = [
call.args[1]
for call in runner.session_store.append_to_transcript.call_args_list
if len(call.args) >= 2 and isinstance(call.args[1], dict)
]
assert any(entry.get("role") == "user" for entry in persisted_entries)
assert not any(
entry.get("role") == "assistant"
and error_response in str(entry.get("content", ""))
for entry in persisted_entries
)

6
tests/gateway/test_53175_cleanup_off_loop.py
View file

@ -166,9 +166,3 @@ async def test_cleanup_off_loop_swallows_executor_failure(caplog):
), "expected the cleanup-failure warning to be logged"
@pytest.mark.asyncio
async def test_cleanup_off_loop_none_agent_is_noop():
"""A None agent (None cache entry) is a no-op and never touches the loop."""
runner, executor = _make_runner()
await runner._cleanup_agent_resources_off_loop(None)
executor.shutdown(wait=False)

75
tests/gateway/test_64674_multiplex_primary_token_scope.py
View file

@ -49,35 +49,6 @@ class TestLoadGatewayConfigForRunner:
cfg = run_mod.load_gateway_config_for_runner()
assert cfg.multiplex_profiles is False
def test_scoped_reload_picks_up_default_profile_token(self, tmp_path, monkeypatch):
"""Token only in default profile .env, not in process os.environ."""
from gateway import run as run_mod
import hermes_constants as hc
home = tmp_path / "home"
home.mkdir()
(home / ".env").write_text(
"TELEGRAM_BOT_TOKEN=default-profile-token-123\n", encoding="utf-8"
)
(home / "config.yaml").write_text(
"gateway:\n multiplex_profiles: true\n", encoding="utf-8"
)
monkeypatch.setenv("HERMES_HOME", str(home))
# Simulate a clean process env where the token was NOT exported and
# was not bulk-loaded into os.environ (multiplex isolation path).
monkeypatch.delenv("TELEGRAM_BOT_TOKEN", raising=False)
# Point both hermes_constants and gateway.run at our temp home.
monkeypatch.setattr(hc, "get_hermes_home", lambda: home)
monkeypatch.setattr(run_mod, "get_hermes_home", lambda: home)
monkeypatch.setattr(run_mod, "_hermes_home", home)
cfg = run_mod.load_gateway_config_for_runner()
assert cfg.multiplex_profiles is True
tg = cfg.platforms.get(Platform.TELEGRAM)
assert tg is not None
assert tg.token == "default-profile-token-123"
assert tg.enabled is True
class TestPlatformHasBotCredential:
def test_telegram_empty_token_false(self):
@ -90,33 +61,6 @@ class TestPlatformHasBotCredential:
Platform.TELEGRAM, PlatformConfig(enabled=True, token=None)
) is False
def test_telegram_with_token_true(self):
from gateway.run import _platform_has_bot_credential
assert _platform_has_bot_credential(
Platform.TELEGRAM, PlatformConfig(enabled=True, token="123:abc")
) is True
def test_non_token_platform_always_true(self):
from gateway.run import _platform_has_bot_credential
# SMS / webhook-style platforms are not gated by PlatformConfig.token.
# Use a platform that exists but is outside the token set when possible.
for plat in Platform:
if plat in {
Platform.TELEGRAM,
Platform.DISCORD,
Platform.SLACK,
Platform.MATTERMOST,
Platform.MATRIX,
Platform.WEIXIN,
}:
continue
assert _platform_has_bot_credential(
plat, PlatformConfig(enabled=True, token=None)
) is True
break
class TestPrimaryStartupSkipsEmptyTokenUnderMultiplex:
@pytest.mark.asyncio
@ -174,25 +118,6 @@ class TestPrimaryStartupSkipsEmptyTokenUnderMultiplex:
assert skipped == [Platform.TELEGRAM]
assert created == []
@pytest.mark.asyncio
async def test_still_starts_when_token_present(self):
from gateway.run import _platform_has_bot_credential
cfg = GatewayConfig(multiplex_profiles=True)
cfg.platforms[Platform.TELEGRAM] = PlatformConfig(
enabled=True, token="123:abc"
)
started = []
for platform, platform_config in cfg.platforms.items():
if not platform_config.enabled:
continue
if cfg.multiplex_profiles and not _platform_has_bot_credential(
platform, platform_config
):
continue
started.append(platform)
assert started == [Platform.TELEGRAM]
class TestReconnectDropsEmptyToken:
@pytest.mark.asyncio

48
tests/gateway/test_7100_transient_failure_transcript.py
View file

@ -16,7 +16,6 @@ The gateway classifier must distinguish:
"""
def _classify(agent_result: dict, history_len: int) -> tuple[bool, bool]:
"""Replicate the gateway classifier from GatewayRunner._run_agent.
@ -51,24 +50,6 @@ class TestContextOverflowStillSkipsTranscript:
assert failed
assert ctx_overflow
def test_explicit_context_length_error_is_context_overflow(self):
agent_result = {
"failed": True,
"error": "prompt is too long: 250000 tokens > 200000 maximum",
}
failed, ctx_overflow = _classify(agent_result, history_len=10)
assert failed
assert ctx_overflow
def test_generic_400_on_large_session_is_context_overflow(self):
agent_result = {
"failed": True,
"error": "error code: 400 - {'type': 'error', 'message': 'Error'}",
}
failed, ctx_overflow = _classify(agent_result, history_len=100)
assert failed
assert ctx_overflow
class TestTransientFailureKeepsUserMessage:
"""Transient provider failures must NOT skip the transcript — doing so
@ -95,35 +76,6 @@ class TestTransientFailureKeepsUserMessage:
assert failed
assert not ctx_overflow
def test_connection_reset_is_not_context_overflow(self):
agent_result = {
"failed": True,
"error": "ConnectionError: [Errno 54] Connection reset by peer",
}
failed, ctx_overflow = _classify(agent_result, history_len=10)
assert failed
assert not ctx_overflow
def test_provider_500_is_not_context_overflow(self):
agent_result = {
"failed": True,
"error": "API call failed after 3 retries: 500 Internal Server Error",
}
failed, ctx_overflow = _classify(agent_result, history_len=10)
assert failed
assert not ctx_overflow
def test_generic_400_on_short_session_is_not_context_overflow(self):
"""A 400 on a short session is a real client error, not context
overflow — still not a reason to drop the user turn."""
agent_result = {
"failed": True,
"error": "error code: 400 - invalid model",
}
failed, ctx_overflow = _classify(agent_result, history_len=5)
assert failed
assert not ctx_overflow
class TestSuccessfulResultUnaffected:
def test_successful_result_neither_failed_nor_overflow(self):

20
tests/gateway/test_73297_memory_flush_on_reset.py
View file

@ -141,23 +141,3 @@ def test_cleanup_flushes_pending_writes_before_shutdown(monkeypatch):
)
def test_cleanup_calls_flush_pending_before_shutdown_memory_provider():
"""Structural contract: the gateway cleanup drains the memory manager
BEFORE shutting the provider down (ordering matters — shutdown's drain is
the unreliable one the fix works around)."""
agent = MagicMock()
agent._session_messages = [{"role": "user", "content": "hi"}]
agent._memory_manager = MagicMock()
# Track call order across both objects via a parent mock.
parent = MagicMock()
parent.attach_mock(agent._memory_manager.flush_pending, "flush_pending")
parent.attach_mock(agent.shutdown_memory_provider, "shutdown_memory_provider")
GatewayRunner._cleanup_agent_resources(object(), agent)
agent._memory_manager.flush_pending.assert_called_once_with(timeout=10)
parent.assert_has_calls(
[call.flush_pending(timeout=10), call.shutdown_memory_provider([{"role": "user", "content": "hi"}])],
any_order=False,
)

171
tests/gateway/test_active_session_text_merge.py
View file

@ -132,29 +132,6 @@ async def test_rapid_text_followups_accumulate_instead_of_replacing():
assert not adapter._active_sessions[session_key].is_set()
@pytest.mark.asyncio
async def test_debounce_buffers_rapid_text_then_flushes_to_pending():
adapter = _make_adapter()
adapter._busy_text_debounce_seconds = 0.05
first = _make_event("part one")
session_key = build_session_key(first.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(_make_event("part two"))
assert session_key in adapter._text_debounce
assert _debounced_event(adapter, session_key).text == "part two"
assert session_key not in adapter._pending_messages
await adapter.handle_message(_make_event("part three"))
assert _debounced_event(adapter, session_key).text == "part two\npart three"
await asyncio.sleep(0.15)
assert session_key not in adapter._text_debounce
assert adapter._pending_messages[session_key].text == "part two\npart three"
@pytest.mark.asyncio
async def test_debounce_resets_timer_on_new_arrival():
adapter = _make_adapter()
@ -187,90 +164,6 @@ async def test_debounce_resets_timer_on_new_arrival():
assert adapter._pending_messages[session_key].text == "one\ntwo\nthree"
@pytest.mark.asyncio
async def test_active_drain_force_flushes_debounce_before_release():
adapter = _make_adapter()
adapter._busy_text_debounce_seconds = 1.0
processed: list[str] = []
async def _handler(event):
processed.append(event.text)
if event.text == "current":
await adapter.handle_message(_make_event("follow up"))
return None
adapter._message_handler = _handler
current = _make_event("current")
session_key = build_session_key(current.source)
task = asyncio.create_task(adapter._process_message_background(current, session_key))
adapter._session_tasks[session_key] = task
await asyncio.wait_for(task, timeout=1.0)
for _ in range(20):
if processed == ["current", "follow up"] and session_key not in adapter._active_sessions:
break
await asyncio.sleep(0.05)
assert processed == ["current", "follow up"]
assert session_key not in adapter._text_debounce
assert session_key not in adapter._pending_messages
assert session_key not in adapter._active_sessions
@pytest.mark.asyncio
async def test_force_flush_cancels_timer_without_duplicate_processing():
adapter = _make_adapter()
adapter._busy_text_debounce_seconds = 0.2
event = _make_event("queued once")
session_key = build_session_key(event.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(event)
timer_task = adapter._text_debounce[session_key].task
flushed = await adapter._flush_text_debounce_now(session_key)
assert flushed is True
assert session_key not in adapter._text_debounce
assert adapter._pending_messages[session_key].text == "queued once"
await asyncio.sleep(0.3)
assert timer_task is not None
assert timer_task.cancelled() or timer_task.done()
assert adapter._pending_messages[session_key].text == "queued once"
@pytest.mark.asyncio
async def test_text_debounce_does_not_merge_different_senders():
adapter = _make_adapter()
adapter._busy_text_debounce_seconds = 1.0
first = _make_event(
"from alice",
chat_type="group",
user_id="alice",
user_name="Alice",
thread_id="topic-1",
)
second = _make_event(
"from bob",
chat_type="group",
user_id="bob",
user_name="Bob",
thread_id="topic-1",
)
session_key = build_session_key(first.source)
assert session_key == build_session_key(second.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(first)
await adapter.handle_message(second)
assert adapter._pending_messages[session_key].text == "from alice"
assert _debounced_event(adapter, session_key).text == "from bob"
@pytest.mark.asyncio
async def test_control_and_clarify_messages_bypass_text_debounce():
adapter = _make_adapter()
@ -299,59 +192,6 @@ async def test_control_and_clarify_messages_bypass_text_debounce():
assert session_key not in adapter._pending_messages
@pytest.mark.asyncio
async def test_debounce_skipped_when_busy_text_mode_not_queue():
adapter = _make_adapter()
adapter._busy_text_mode = ""
event = _make_event("direct merge")
session_key = build_session_key(event.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(event)
assert adapter._pending_messages[session_key].text == "direct merge"
assert session_key not in adapter._text_debounce
def test_debounce_respects_env_var_override(monkeypatch):
monkeypatch.setenv("HERMES_GATEWAY_BUSY_TEXT_DEBOUNCE_SECONDS", "2.5")
adapter = _make_initialized_adapter()
assert adapter._busy_text_debounce_seconds == 2.5
@pytest.mark.asyncio
async def test_debounce_cleanup_in_cancel_background_tasks():
adapter = _make_adapter()
adapter._busy_text_debounce_seconds = 1.0
event = _make_event("cleanup test")
session_key = build_session_key(event.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(event)
assert session_key in adapter._text_debounce
await adapter.cancel_background_tasks()
assert session_key not in adapter._text_debounce
@pytest.mark.asyncio
async def test_single_followup_is_stored_as_is():
adapter = _make_adapter()
adapter._busy_text_mode = ""
first = _make_event("only one")
session_key = build_session_key(first.source)
adapter._active_sessions[session_key] = asyncio.Event()
await adapter.handle_message(first)
pending = adapter._pending_messages[session_key]
assert pending is first
assert pending.text == "only one"
assert not adapter._active_sessions[session_key].is_set()
def test_adapter_defaults_to_interrupt_mode(monkeypatch):
monkeypatch.delenv("HERMES_GATEWAY_BUSY_TEXT_MODE", raising=False)
adapter = _make_initialized_adapter()
@ -359,20 +199,9 @@ def test_adapter_defaults_to_interrupt_mode(monkeypatch):
assert not adapter._is_queue_text_debounce_candidate(_make_event("hello"))
def test_adapter_is_queue_text_debounce_candidate_when_queue_set():
# _make_adapter() pins _busy_text_mode="queue" to exercise debounce.
adapter = _make_adapter()
assert adapter._is_queue_text_debounce_candidate(_make_event("hello world"))
def test_command_messages_bypass_debounce_even_in_queue_mode():
adapter = _make_adapter()
assert not adapter._is_queue_text_debounce_candidate(_make_event(""))
assert not adapter._is_queue_text_debounce_candidate(_make_event("/stop"))
def test_busy_text_mode_respects_env_var_override(monkeypatch):
monkeypatch.setenv("HERMES_GATEWAY_BUSY_TEXT_MODE", "interrupt")
adapter = _make_initialized_adapter()
assert adapter._busy_text_mode == "interrupt"
assert not adapter._is_queue_text_debounce_candidate(_make_event("test"))

12
tests/gateway/test_adapter_connect_is_reconnect_contract.py
View file

@ -106,18 +106,6 @@ def _connect_accepts_is_reconnect(cls: ast.ClassDef) -> bool:
ADAPTER_FILES = _iter_adapter_files()
def test_adapter_discovery_finds_platforms():
"""Sanity: the discovery walker actually found a meaningful set of
adapters. If this drops to a trivial number, the glob broke and the
contract test below is silently passing on nothing.
"""
assert len(ADAPTER_FILES) >= 20, (
f"Expected to discover >=20 platform adapter files under "
f"{[str(p) for p in ADAPTER_ROOTS]}, found {len(ADAPTER_FILES)}. "
f"The discovery glob is likely broken."
)
@pytest.mark.parametrize(
"adapter_file",
ADAPTER_FILES,

33
tests/gateway/test_agents_command_delegations.py
View file

@ -44,34 +44,6 @@ class _Event:
source = None
@pytest.mark.asyncio
async def test_agents_command_lists_background_delegation_with_activity():
gate = threading.Event()
base_ts = time.time() - 8.0
res = ad.dispatch_async_delegation(
goal="research the delegation stall monitor",
context=None, toolsets=None, role="leaf", model="m",
session_key="agent:main:test:dm:1", max_async_children=1,
runner=lambda: {} if gate.wait(timeout=10) else {},
progress_fn=lambda: (((2, "web_search", base_ts),), True),
)
assert res["status"] == "dispatched"
try:
runner = _make_runner()
out = await runner._handle_agents_command(_Event())
finally:
gate.set()
assert res["delegation_id"] in out
assert "running" in out
assert "research the delegation stall monitor" in out
# Live per-child activity sampled from progress_fn.
assert "2 api calls" in out
assert "web_search" in out
@pytest.mark.asyncio
async def test_agents_command_marks_stalling_delegation(monkeypatch):
monkeypatch.setattr(ad, "_STALE_CHECK_INTERVAL", 0.03)
@ -112,8 +84,3 @@ async def test_agents_command_marks_stalling_delegation(monkeypatch):
assert "no progress" in out
@pytest.mark.asyncio
async def test_agents_command_no_delegations_keeps_none_message():
runner = _make_runner()
out = await runner._handle_agents_command(_Event())
assert "No active agents" in out

16
tests/gateway/test_aiohttp_body_caps.py
View file

@ -18,19 +18,3 @@ def test_bluebubbles_app_sets_client_max_size():
assert "client_max_size=_WEBHOOK_MAX_BODY_BYTES" in src
def test_teams_app_sets_client_max_size():
import plugins.platforms.teams.adapter as teams
assert teams._MAX_BODY_BYTES > 0
src = inspect.getsource(teams.TeamsAdapter.connect)
assert "client_max_size=_MAX_BODY_BYTES" in src
def test_proxy_app_sets_client_max_size():
import hermes_cli.proxy.server as proxy_server
# Mirrors api_server's MAX_REQUEST_BYTES: chat payloads can be large,
# but the cap must exist so chunked bodies stay bounded.
assert proxy_server.MAX_REQUEST_BYTES >= 1_048_576
src = inspect.getsource(proxy_server.create_app)
assert "client_max_size=MAX_REQUEST_BYTES" in src

145
tests/gateway/test_allowed_channels_widening.py
View file

@ -82,24 +82,6 @@ class TestTelegramAllowedChats:
adapter = _make_telegram_adapter(allowed_chats=[-100, -200])
assert adapter._telegram_allowed_chats() == {"-100", "-200"}
def test_csv_form(self):
adapter = _make_telegram_adapter(allowed_chats="-100, -200")
assert adapter._telegram_allowed_chats() == {"-100", "-200"}
def test_env_var_fallback(self, monkeypatch):
monkeypatch.setenv("TELEGRAM_ALLOWED_CHATS", "-100,-200")
adapter = _make_telegram_adapter() # no extra → falls back to env
assert adapter._telegram_allowed_chats() == {"-100", "-200"}
def test_blocks_non_whitelisted_group(self):
adapter = _make_telegram_adapter(allowed_chats=["-100"])
assert adapter._should_process_message(_tg_group_message(-999)) is False
def test_permits_whitelisted_group(self):
adapter = _make_telegram_adapter(
allowed_chats=["-100"], require_mention=False,
)
assert adapter._should_process_message(_tg_group_message(-100)) is True
def test_mention_cannot_bypass_whitelist(self):
"""@mention in a non-allowed chat is still ignored."""
@ -110,10 +92,6 @@ class TestTelegramAllowedChats:
)]
assert adapter._should_process_message(msg) is False
def test_dms_unaffected(self):
"""DMs bypass the allowed_chats whitelist entirely."""
adapter = _make_telegram_adapter(allowed_chats=["-100"])
assert adapter._should_process_message(_tg_dm_message()) is True
def test_config_bridge(self, monkeypatch, tmp_path):
"""slack-style config.yaml → env var bridge works."""
@ -137,24 +115,6 @@ class TestTelegramAllowedChats:
import os as _os
assert _os.environ["TELEGRAM_ALLOWED_CHATS"] == "-100,-200"
def test_config_bridge_env_takes_precedence(self, monkeypatch, tmp_path):
from gateway.config import load_gateway_config
hermes_home = tmp_path / ".hermes"
hermes_home.mkdir()
(hermes_home / "config.yaml").write_text(
"telegram:\n"
" allowed_chats: -100\n",
encoding="utf-8",
)
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
monkeypatch.setenv("TELEGRAM_ALLOWED_CHATS", "-999")
load_gateway_config()
import os as _os
assert _os.environ["TELEGRAM_ALLOWED_CHATS"] == "-999"
# ---------------------------------------------------------------------------
# DingTalk
@ -187,49 +147,6 @@ class TestDingTalkAllowedChats:
adapter = _make_dingtalk_adapter(allowed_chats=["cidABC", "cidDEF"])
assert adapter._dingtalk_allowed_chats() == {"cidABC", "cidDEF"}
def test_csv_form(self):
adapter = _make_dingtalk_adapter(allowed_chats="cidABC, cidDEF")
assert adapter._dingtalk_allowed_chats() == {"cidABC", "cidDEF"}
def test_env_var_fallback(self, monkeypatch):
monkeypatch.setenv("DINGTALK_ALLOWED_CHATS", "cidABC,cidDEF")
adapter = _make_dingtalk_adapter()
assert adapter._dingtalk_allowed_chats() == {"cidABC", "cidDEF"}
def test_blocks_non_whitelisted_group(self):
adapter = _make_dingtalk_adapter(allowed_chats=["cidABC"])
assert adapter._should_process_message(
message=None, text="hello", is_group=True, chat_id="cidXYZ",
) is False
def test_dm_unaffected(self):
"""DMs (is_group=False) bypass the whitelist."""
adapter = _make_dingtalk_adapter(allowed_chats=["cidABC"])
assert adapter._should_process_message(
message=None, text="hello", is_group=False, chat_id="cidXYZ",
) is True
def test_config_bridge(self, monkeypatch, tmp_path):
from gateway.config import load_gateway_config
hermes_home = tmp_path / ".hermes"
hermes_home.mkdir()
(hermes_home / "config.yaml").write_text(
"dingtalk:\n"
" allowed_chats:\n"
" - cidABC\n"
" - cidDEF\n",
encoding="utf-8",
)
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
monkeypatch.setenv("DINGTALK_ALLOWED_CHATS", "__sentinel__")
monkeypatch.delenv("DINGTALK_ALLOWED_CHATS")
load_gateway_config()
import os as _os
assert _os.environ["DINGTALK_ALLOWED_CHATS"] == "cidABC,cidDEF"
# ---------------------------------------------------------------------------
# Mattermost (env-var only — no config.yaml bridge)
@ -260,25 +177,6 @@ class TestMattermostAllowedChannels:
def test_empty_config_is_no_restriction(self):
assert self._would_process("chan123", allowed_cfg=None, allowed_env="") is True
def test_config_list_blocks_non_whitelisted_channel(self):
assert self._would_process(
"chanXYZ", allowed_cfg=["chanABC", "chanDEF"],
) is False
def test_config_list_permits_whitelisted_channel(self):
assert self._would_process(
"chanABC", allowed_cfg=["chanABC", "chanDEF"],
) is True
def test_env_var_fallback_when_no_config(self):
assert self._would_process(
"chanXYZ", allowed_cfg=None, allowed_env="chanABC,chanDEF",
) is False
def test_dm_unaffected(self):
assert self._would_process(
"chanXYZ", channel_type="D", allowed_cfg=["chanABC"],
) is True
def test_config_bridge(self, monkeypatch, tmp_path):
from gateway.config import load_gateway_config
@ -321,47 +219,4 @@ class TestMatrixAllowedRooms:
allowed = {r.strip() for r in raw.split(",") if r.strip()}
assert allowed == set()
def test_env_var_parsed_to_set(self, monkeypatch):
monkeypatch.setenv("MATRIX_ALLOWED_ROOMS", "!room1:srv,!room2:srv")
import os as _os
raw = _os.environ["MATRIX_ALLOWED_ROOMS"]
allowed = {r.strip() for r in raw.split(",") if r.strip()}
assert allowed == {"!room1:srv", "!room2:srv"}
def test_block_logic(self):
"""Replicates the matrix.py gate: if allowed non-empty and room not in it, drop."""
allowed = {"!allowed:srv"}
# Non-allowed room in group (is_dm=False) → blocked
def would_process(room_id, is_dm):
if is_dm:
return True
if allowed and room_id not in allowed:
return False
return True
assert would_process("!blocked:srv", is_dm=False) is False
assert would_process("!allowed:srv", is_dm=False) is True
# DM always allowed
assert would_process("!blocked:srv", is_dm=True) is True
def test_config_bridge(self, monkeypatch, tmp_path):
from gateway.config import load_gateway_config
hermes_home = tmp_path / ".hermes"
hermes_home.mkdir()
(hermes_home / "config.yaml").write_text(
"matrix:\n"
" allowed_rooms:\n"
" - '!room1:srv'\n"
" - '!room2:srv'\n",
encoding="utf-8",
)
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
monkeypatch.setenv("MATRIX_ALLOWED_ROOMS", "__sentinel__")
monkeypatch.delenv("MATRIX_ALLOWED_ROOMS")
load_gateway_config()
import os as _os
assert _os.environ["MATRIX_ALLOWED_ROOMS"] == "!room1:srv,!room2:srv"

10
tests/gateway/test_allowlist_startup_check.py
View file

@ -33,14 +33,4 @@ class TestAllowlistStartupCheck:
with patch.dict(os.environ, {}, clear=True):
assert _would_warn() is True
def test_signal_group_allowed_users_suppresses_warning(self):
with patch.dict(os.environ, {"SIGNAL_GROUP_ALLOWED_USERS": "user1"}, clear=True):
assert _would_warn() is False
def test_telegram_allow_all_users_suppresses_warning(self):
with patch.dict(os.environ, {"TELEGRAM_ALLOW_ALL_USERS": "true"}, clear=True):
assert _would_warn() is False
def test_gateway_allow_all_users_suppresses_warning(self):
with patch.dict(os.environ, {"GATEWAY_ALLOW_ALL_USERS": "yes"}, clear=True):
assert _would_warn() is False

157
tests/gateway/test_api_server_active_work_drain.py
View file

@ -63,46 +63,8 @@ class TestActiveApiRunCount:
runner.adapters = {}
assert runner._active_api_run_count() == 0
def test_delegates_to_primary_api_adapter(self):
runner, _adapter = make_restart_runner()
runner.adapters = {
Platform.API_SERVER: _make_api_adapter(inflight=2, queued_ids=["r1"])
}
assert runner._active_api_run_count() == 3
def test_ignores_non_api_platforms(self):
runner, _adapter = make_restart_runner()
other = SimpleNamespace(
platform=Platform.DISCORD,
active_agent_work_count=lambda: 99,
)
runner.adapters = {Platform.DISCORD: other}
assert runner._active_api_run_count() == 0
def test_never_raises_on_broken_adapter(self):
runner, _adapter = make_restart_runner()
class Bad:
platform = Platform.API_SERVER
@staticmethod
def active_agent_work_count() -> int:
raise RuntimeError("boom")
runner.adapters = {Platform.API_SERVER: Bad()}
assert runner._active_api_run_count() == 0
class TestAPIServerAdapterWorkCount:
def test_concurrency_limit_counts_other_pending_admissions(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
adapter._max_concurrent_runs = 1
adapter._pending_agent_requests = 1
response = adapter._concurrency_limited_response()
assert response is not None
assert response.status == 429
@pytest.mark.asyncio
async def test_concurrency_limit_excludes_current_pending_admission(self):
@ -119,11 +81,6 @@ class TestAPIServerAdapterWorkCount:
assert response.status == 404
def test_counts_pending_admission_before_agent_bookkeeping(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
adapter._pending_agent_requests = 1
assert adapter.active_agent_work_count() == 1
def test_counts_live_run_task_before_agent_creation(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
@ -136,24 +93,8 @@ class TestAPIServerAdapterWorkCount:
assert adapter.active_agent_work_count() == 3
def test_does_not_double_count_started_run_agent(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
adapter._inflight_agent_runs = 0
adapter._active_run_tasks = {"run-1": _RunTask()}
adapter._active_run_agents = {"run-1": object()}
assert adapter.active_agent_work_count() == 1
class TestDrainWaitsForApiWork:
@pytest.mark.asyncio
async def test_drain_returns_immediately_when_nothing_active(self):
runner, _adapter = make_restart_runner()
runner.adapters = {}
_snapshot, timed_out = await runner._drain_active_agents(5.0)
assert timed_out is False
@pytest.mark.asyncio
async def test_drain_waits_for_real_queued_run_before_agent_creation(self):
@ -200,39 +141,6 @@ class TestDrainWaitsForApiWork:
assert timed_out is False
@pytest.mark.asyncio
async def test_drain_times_out_if_api_run_outlives_the_window(self):
runner, _adapter = make_restart_runner()
runner.adapters = {Platform.API_SERVER: _make_api_adapter(queued_ids=["run-1"])}
_snapshot, timed_out = await runner._drain_active_agents(0.1)
assert timed_out is True
@pytest.mark.asyncio
async def test_drain_still_waits_for_chat_cron_and_api_work(self):
import cron.scheduler as sched
runner, _adapter = make_restart_runner()
runner._running_agents = {"session-1": MagicMock()}
sched._running_job_ids.add("job-1")
runner.adapters = {Platform.API_SERVER: _make_api_adapter(queued_ids=["run-1"])}
async def finish_all():
await asyncio.sleep(0.12)
runner._running_agents.clear()
sched._running_job_ids.discard("job-1")
runner.adapters[Platform.API_SERVER]._active_run_tasks.clear()
task = asyncio.create_task(finish_all())
try:
_snapshot, timed_out = await runner._drain_active_agents(2.0)
finally:
await task
sched._running_job_ids.discard("job-1")
assert timed_out is False
class TestDrainAdmission:
@pytest.mark.asyncio
@ -258,69 +166,4 @@ class TestDrainAdmission:
assert response.headers["Retry-After"] == "1"
assert payload["error"]["code"] == "gateway_draining"
@pytest.mark.asyncio
async def test_external_drain_refuses_every_agent_start_endpoint(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
runner = SimpleNamespace(_draining=False, _external_drain_active=True)
app = _make_admission_app(adapter)
paths = (
"/api/sessions/missing/chat",
"/api/sessions/missing/chat/stream",
"/v1/chat/completions",
"/v1/responses",
"/v1/runs",
)
with patch("gateway.run._gateway_runner_ref", lambda: runner):
async with TestClient(TestServer(app)) as client:
for path in paths:
response = await client.post(path, json={})
payload = await response.json()
assert response.status == 503
assert payload["error"]["code"] == "gateway_draining"
@pytest.mark.asyncio
async def test_admitted_request_blocks_drain_before_agent_bookkeeping(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True))
runner, _adapter = make_restart_runner()
runner.adapters = {Platform.API_SERVER: adapter}
app = _make_admission_app(adapter)
body_read_started = asyncio.Event()
allow_body_read = asyncio.Event()
async def delayed_read_json(_request):
body_read_started.set()
await allow_body_read.wait()
return {"message": "hello"}, None
with patch.object(
adapter,
"_get_existing_session_or_404",
return_value=({}, None),
), patch.object(
adapter,
"_read_json_body",
side_effect=delayed_read_json,
), patch.object(
adapter,
"_run_agent",
new=AsyncMock(return_value=({"final_response": "done"}, {})),
):
async with TestClient(TestServer(app)) as client:
request_task = asyncio.create_task(
client.post("/api/sessions/missing/chat", json={})
)
await body_read_started.wait()
assert adapter._pending_agent_requests == 1
drain_task = asyncio.create_task(runner._drain_active_agents(2.0))
await asyncio.sleep(0.1)
assert not drain_task.done()
allow_body_read.set()
response = await request_task
assert response.status == 200
_snapshot, timed_out = await drain_task
assert timed_out is False

73
tests/gateway/test_api_server_bind_guard.py
View file

@ -24,11 +24,6 @@ class TestIsNetworkAccessible:
# -- Loopback (safe, should return False) --
def test_ipv4_loopback(self):
assert is_network_accessible("127.0.0.1") is False
def test_ipv6_loopback(self):
assert is_network_accessible("::1") is False
def test_ipv4_mapped_loopback(self):
# ::ffff:127.0.0.1 — Python's is_loopback returns False for mapped
@ -37,40 +32,21 @@ class TestIsNetworkAccessible:
# -- Network-accessible (should return True) --
def test_ipv4_wildcard(self):
assert is_network_accessible("0.0.0.0") is True
def test_ipv6_wildcard(self):
# This is the bypass vector that the string-based check missed.
assert is_network_accessible("::") is True
def test_ipv4_mapped_unspecified(self):
assert is_network_accessible("::ffff:0.0.0.0") is True
def test_private_ipv4(self):
assert is_network_accessible("10.0.0.1") is True
def test_private_ipv4_class_c(self):
assert is_network_accessible("192.168.1.1") is True
def test_public_ipv4(self):
assert is_network_accessible("8.8.8.8") is True
# -- Hostname resolution --
def test_localhost_resolves_to_loopback(self):
loopback_result = [
(socket.AF_INET, socket.SOCK_STREAM, 0, "", ("127.0.0.1", 0)),
]
with patch("gateway.platforms.base._socket.getaddrinfo", return_value=loopback_result):
assert is_network_accessible("localhost") is False
def test_hostname_resolving_to_non_loopback(self):
non_loopback_result = [
(socket.AF_INET, socket.SOCK_STREAM, 0, "", ("10.0.0.1", 0)),
]
with patch("gateway.platforms.base._socket.getaddrinfo", return_value=non_loopback_result):
assert is_network_accessible("my-server.local") is True
def test_hostname_mixed_resolution(self):
"""If a hostname resolves to both loopback and non-loopback, it's
@ -82,14 +58,6 @@ class TestIsNetworkAccessible:
with patch("gateway.platforms.base._socket.getaddrinfo", return_value=mixed_result):
assert is_network_accessible("dual-host.local") is True
def test_dns_failure_fails_closed(self):
"""Unresolvable hostnames should require an API key (fail closed)."""
with patch(
"gateway.platforms.base._socket.getaddrinfo",
side_effect=socket.gaierror("Name resolution failed"),
):
assert is_network_accessible("nonexistent.invalid") is True
# ---------------------------------------------------------------------------
# Integration tests: connect() startup guard
@ -99,17 +67,6 @@ class TestIsNetworkAccessible:
class TestConnectBindGuard:
"""Verify that connect() refuses dangerous configurations."""
@pytest.mark.asyncio
async def test_refuses_ipv4_wildcard_without_key(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True, extra={"host": "0.0.0.0"}))
result = await adapter.connect()
assert result is False
@pytest.mark.asyncio
async def test_refuses_ipv6_wildcard_without_key(self):
adapter = APIServerAdapter(PlatformConfig(enabled=True, extra={"host": "::"}))
result = await adapter.connect()
assert result is False
@pytest.mark.asyncio
async def test_refuses_loopback_without_key(self):
@ -122,16 +79,6 @@ class TestConnectBindGuard:
assert adapter._app is None
assert adapter._background_tasks == set()
@pytest.mark.asyncio
async def test_refuses_weak_key_without_partial_startup(self):
"""Weak API_SERVER_KEY rejection must not create app or background tasks."""
adapter = APIServerAdapter(
PlatformConfig(enabled=True, extra={"host": "127.0.0.1", "key": "short"}),
)
result = await adapter.connect()
assert result is False
assert adapter._app is None
assert adapter._background_tasks == set()
@pytest.mark.asyncio
async def test_allows_wildcard_with_key(self):
@ -197,26 +144,6 @@ class TestBindMechanics:
finally:
await second.disconnect()
@pytest.mark.asyncio
async def test_live_listener_conflict_returns_false_and_cleans_up(self):
"""A second adapter on an occupied port fails cleanly, not with a raise."""
port = self._free_port()
first = self._make_adapter(port)
assert await first.connect() is True
second = self._make_adapter(port)
try:
result = await second.connect()
assert result is False
assert second._runner is None
assert second._site is None
assert second.is_connected is False
finally:
await first.disconnect()
await second.disconnect()
def test_pre_probe_helper_removed(self):
"""The racy single-family pre-probe must not come back."""
assert not hasattr(APIServerAdapter, "_port_is_available")
@pytest.mark.asyncio
async def test_port_conflict_sets_non_retryable_fatal_error(self):

56
tests/gateway/test_api_server_media_data_urls.py
View file

@ -50,62 +50,6 @@ class TestResolveMediaToDataUrls(unittest.TestCase):
text = "MEDIA:/tmp/archive.zip"
self.assertEqual(_resolve_media_to_data_urls(text), text)
def test_text_without_media_passthrough(self):
self.assertEqual(_resolve_media_to_data_urls("plain text"), "plain text")
self.assertEqual(_resolve_media_to_data_urls(""), "")
def test_oversized_image_skipped(self):
from gateway.platforms import api_server as mod
p = self._write_png()
orig = mod._MEDIA_DATA_URL_MAX_BYTES
mod._MEDIA_DATA_URL_MAX_BYTES = 1
try:
text = f"MEDIA:{p}"
self.assertEqual(_resolve_media_to_data_urls(text), text)
finally:
mod._MEDIA_DATA_URL_MAX_BYTES = orig
def test_multiple_tags(self):
p1 = self._write_png()
p2 = self._write_png("hermes_media_test2")
out = _resolve_media_to_data_urls(f"MEDIA:{p1}\nand MEDIA:{p2}")
self.assertEqual(out.count("data:image/png;base64,"), 2)
def test_relative_traversal_path_not_inlined(self):
"""A relative/traversal path must never be inlined — the anchored
MEDIA_TAG_CLEANUP_RE matcher requires an absolute-path prefix
(~/, /, or a Windows drive letter), so a bare relative token after
MEDIA: is left as literal text rather than resolved against cwd."""
text = "MEDIA:../../../../etc/passwd.png"
self.assertEqual(_resolve_media_to_data_urls(text), text)
def test_credential_path_not_inlined_even_with_image_extension(self):
"""An absolute path under the credential/system-path denylist
(validate_media_delivery_path) must not be inlined even though it
has an allowed image extension and the tag matcher's shape."""
text = "MEDIA:~/.ssh/id_rsa.png"
self.assertEqual(_resolve_media_to_data_urls(text), text)
def test_symlink_escaping_to_denylisted_target_not_inlined(self):
"""A symlink whose resolved target lands under a denylisted system
prefix (/etc) must not be inlined — validate_media_delivery_path
resolves symlinks before the containment/denylist check runs, so
the traversal can't be laundered through an innocuous-looking
image-suffixed symlink name."""
import os
import tempfile
from pathlib import Path
d = Path(tempfile.mkdtemp(prefix="hermes_media_test_symlink"))
link = d / "shot.png"
try:
os.symlink("/etc/hosts", link)
except OSError:
self.skipTest("symlink creation not supported in this environment")
text = f"MEDIA:{link}"
self.assertEqual(_resolve_media_to_data_urls(text), text)
if __name__ == "__main__":
unittest.main()

143
tests/gateway/test_api_server_multimodal.py
View file

@ -43,17 +43,6 @@ class TestNormalizeMultimodalContent:
content = [{"type": "input_text", "text": "hello"}]
assert _normalize_multimodal_content(content) == "hello"
def test_image_url_preserved_with_text(self):
content = [
{"type": "text", "text": "describe this"},
{"type": "image_url", "image_url": {"url": "https://example.com/cat.png", "detail": "high"}},
]
out = _normalize_multimodal_content(content)
assert isinstance(out, list)
assert out == [
{"type": "text", "text": "describe this"},
{"type": "image_url", "image_url": {"url": "https://example.com/cat.png", "detail": "high"}},
]
def test_input_image_converted_to_canonical_shape(self):
content = [
@ -66,56 +55,13 @@ class TestNormalizeMultimodalContent:
{"type": "image_url", "image_url": {"url": "https://example.com/cat.png"}},
]
def test_data_image_url_accepted(self):
content = [{"type": "image_url", "image_url": {"url": "data:image/png;base64,AAAA"}}]
out = _normalize_multimodal_content(content)
assert out == [{"type": "image_url", "image_url": {"url": "data:image/png;base64,AAAA"}}]
def test_non_image_data_url_rejected(self):
content = [{"type": "image_url", "image_url": {"url": "data:text/plain;base64,SGVsbG8="}}]
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content(content)
assert str(exc.value).startswith("unsupported_content_type:")
def test_file_part_rejected(self):
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content([{"type": "file", "file": {"file_id": "f_1"}}])
assert str(exc.value).startswith("unsupported_content_type:")
def test_input_file_part_rejected(self):
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content([{"type": "input_file", "file_id": "f_1"}])
assert str(exc.value).startswith("unsupported_content_type:")
def test_missing_url_rejected(self):
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content([{"type": "image_url", "image_url": {}}])
assert str(exc.value).startswith("invalid_image_url:")
def test_bad_scheme_rejected(self):
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content([{"type": "image_url", "image_url": {"url": "ftp://example.com/x.png"}}])
assert str(exc.value).startswith("invalid_image_url:")
def test_unknown_part_type_rejected(self):
with pytest.raises(ValueError) as exc:
_normalize_multimodal_content([{"type": "audio", "audio": {}}])
assert str(exc.value).startswith("unsupported_content_type:")
class TestContentHasVisiblePayload:
def test_non_empty_string(self):
assert _content_has_visible_payload("hello")
def test_whitespace_only_string(self):
assert not _content_has_visible_payload(" ")
def test_list_with_image_only(self):
assert _content_has_visible_payload([{"type": "image_url", "image_url": {"url": "x"}}])
def test_list_with_only_empty_text(self):
assert not _content_has_visible_payload([{"type": "text", "text": ""}])
# ---------------------------------------------------------------------------
# HTTP integration — real aiohttp client hitting the adapter handlers
@ -176,76 +122,6 @@ class TestChatCompletionsMultimodalHTTP:
assert resp.status == 200, await resp.text()
assert mock_run.captured["user_message"] == image_payload
@pytest.mark.asyncio
async def test_text_only_array_collapses_to_string(self, adapter):
"""Text-only array becomes a plain string so logging stays unchanged."""
app = _create_app(adapter)
async with TestClient(TestServer(app)) as cli:
with patch.object(adapter, "_run_agent", new=MagicMock()) as mock_run:
async def _stub(**kwargs):
mock_run.captured = kwargs
return (
{"final_response": "ok", "messages": [], "api_calls": 1},
{"input_tokens": 0, "output_tokens": 0, "total_tokens": 0},
)
mock_run.side_effect = _stub
resp = await cli.post(
"/v1/chat/completions",
json={
"model": "hermes-agent",
"messages": [
{"role": "user", "content": [{"type": "text", "text": "hello"}]},
],
},
)
assert resp.status == 200, await resp.text()
assert mock_run.captured["user_message"] == "hello"
@pytest.mark.asyncio
async def test_file_part_returns_400(self, adapter):
app = _create_app(adapter)
async with TestClient(TestServer(app)) as cli:
resp = await cli.post(
"/v1/chat/completions",
json={
"model": "hermes-agent",
"messages": [
{"role": "user", "content": [{"type": "file", "file": {"file_id": "f_1"}}]},
],
},
)
assert resp.status == 400
body = await resp.json()
assert body["error"]["code"] == "unsupported_content_type"
assert body["error"]["param"] == "messages[0].content"
@pytest.mark.asyncio
async def test_non_image_data_url_returns_400(self, adapter):
app = _create_app(adapter)
async with TestClient(TestServer(app)) as cli:
resp = await cli.post(
"/v1/chat/completions",
json={
"model": "hermes-agent",
"messages": [
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {"url": "data:text/plain;base64,SGVsbG8="},
},
],
},
],
},
)
assert resp.status == 400
body = await resp.json()
assert body["error"]["code"] == "unsupported_content_type"
class TestResponsesMultimodalHTTP:
@pytest.mark.asyncio
@ -287,22 +163,3 @@ class TestResponsesMultimodalHTTP:
]
assert mock_run.captured["user_message"] == expected
@pytest.mark.asyncio
async def test_input_file_returns_400(self, adapter):
app = _create_app(adapter)
async with TestClient(TestServer(app)) as cli:
resp = await cli.post(
"/v1/responses",
json={
"model": "hermes-agent",
"input": [
{
"role": "user",
"content": [{"type": "input_file", "file_id": "f_1"}],
}
],
},
)
assert resp.status == 400
body = await resp.json()
assert body["error"]["code"] == "unsupported_content_type"

88
tests/gateway/test_api_server_multiplex_secret_scope.py
View file

@ -41,44 +41,6 @@ class TestProfileScopeDefaultFallback:
assert ss.get_secret("OPENROUTER_BASE_URL") == "https://from-environ.example/v1"
assert ss.current_secret_scope() is None
def test_default_scope_installed_under_multiplex(self, adapter, tmp_path, monkeypatch):
"""No /p/ prefix + multiplex active → default profile scope, not nullcontext."""
(tmp_path / ".env").write_text(
"OPENROUTER_BASE_URL=https://openrouter.ai/api/v1\n",
encoding="utf-8",
)
monkeypatch.setattr(
"hermes_constants.get_hermes_home",
lambda: tmp_path,
)
monkeypatch.setenv("OPENROUTER_BASE_URL", "https://leak.example/v1")
ss.set_multiplex_active(True)
with adapter._profile_scope(None):
assert ss.current_secret_scope() is not None
# Profile .env wins; process env must not leak through.
assert ss.get_secret("OPENROUTER_BASE_URL") == "https://openrouter.ai/api/v1"
# Scope torn down; fail-closed behavior restored outside.
assert ss.current_secret_scope() is None
with pytest.raises(ss.UnscopedSecretError):
ss.get_secret("OPENROUTER_BASE_URL")
def test_named_profile_scope_still_wins(self, adapter, tmp_path, monkeypatch):
"""A /p/<profile>/ request keeps resolving that profile's scope."""
profile_home = tmp_path / "profiles" / "worker"
profile_home.mkdir(parents=True)
(profile_home / ".env").write_text(
"OPENROUTER_BASE_URL=https://worker.example/v1\n", encoding="utf-8"
)
monkeypatch.setattr(
"hermes_cli.profiles.get_profile_dir", lambda name: profile_home
)
ss.set_multiplex_active(True)
with adapter._profile_scope("worker"):
assert ss.get_secret("OPENROUTER_BASE_URL") == "https://worker.example/v1"
assert ss.current_secret_scope() is None
# Regression coverage for #72041: profile-bound API authentication
class TestProfileScopedApiAuthentication:
@ -125,30 +87,6 @@ class TestProfileScopedApiAuthentication:
finally:
_api_request_profile.reset(profile_token)
def test_named_profile_without_key_fails_closed(
self, adapter, tmp_path, monkeypatch
):
from gateway.platforms.api_server import _api_request_profile
profile_home = tmp_path / "profiles" / "worker"
profile_home.mkdir(parents=True)
default_key = "default-listener-api-key-123456"
monkeypatch.setattr(
"hermes_cli.profiles.get_profile_dir",
lambda name: profile_home,
)
adapter._api_key = default_key
ss.set_multiplex_active(True)
profile_token = _api_request_profile.set("worker")
try:
with adapter._profile_scope("worker"):
rejected = adapter._check_auth(self._request(default_key))
assert rejected is not None
assert rejected.status == 401
finally:
_api_request_profile.reset(profile_token)
@pytest.mark.asyncio
async def test_profile_middleware_binds_auth_before_handler(
@ -221,29 +159,3 @@ async def test_profile_middleware_binds_auth_before_handler(
assert (await accepted.json())["profile"] == "worker"
def test_named_profile_rejects_weak_profile_key(
adapter, tmp_path, monkeypatch
):
from gateway.platforms.api_server import _api_request_profile
worker_home = tmp_path / "profiles" / "worker"
worker_home.mkdir(parents=True)
(worker_home / ".env").write_text(
"API_SERVER_KEY=short\n", encoding="utf-8"
)
monkeypatch.setattr(
"hermes_cli.profiles.get_profile_dir", lambda name: worker_home
)
adapter._api_key = "b" * 32
ss.set_multiplex_active(True)
token = _api_request_profile.set("worker")
try:
with adapter._profile_scope("worker"):
rejected = adapter._check_auth(
TestProfileScopedApiAuthentication._request("short")
)
assert rejected is not None
assert rejected.status == 401
finally:
_api_request_profile.reset(token)

66
tests/gateway/test_api_server_normalize.py
View file

@ -13,8 +13,6 @@ class TestNormalizeChatContent:
def test_plain_string_returned_as_is(self):
assert _normalize_chat_content("hello world") == "hello world"
def test_empty_string_returned_as_is(self):
assert _normalize_chat_content("") == ""
def test_text_content_part(self):
content = [{"type": "text", "text": "hello"}]
@ -28,49 +26,6 @@ class TestNormalizeChatContent:
content = [{"type": "output_text", "text": "assistant output"}]
assert _normalize_chat_content(content) == "assistant output"
def test_multiple_text_parts_joined_with_newline(self):
content = [
{"type": "text", "text": "first"},
{"type": "text", "text": "second"},
]
assert _normalize_chat_content(content) == "first\nsecond"
def test_mixed_string_and_dict_parts(self):
content = ["plain string", {"type": "text", "text": "dict part"}]
assert _normalize_chat_content(content) == "plain string\ndict part"
def test_image_url_parts_silently_skipped(self):
content = [
{"type": "text", "text": "check this:"},
{"type": "image_url", "image_url": {"url": "https://example.com/img.png"}},
]
assert _normalize_chat_content(content) == "check this:"
def test_integer_content_converted(self):
assert _normalize_chat_content(42) == "42"
def test_boolean_content_converted(self):
assert _normalize_chat_content(True) == "True"
def test_deeply_nested_list_respects_depth_limit(self):
"""Nesting beyond max_depth returns empty string."""
content = [[[[[[[[[[[["deep"]]]]]]]]]]]]
result = _normalize_chat_content(content)
# The deep nesting should be truncated, not crash
assert isinstance(result, str)
def test_large_list_capped(self):
"""Lists beyond MAX_CONTENT_LIST_SIZE are truncated."""
content = [{"type": "text", "text": f"item{i}"} for i in range(2000)]
result = _normalize_chat_content(content)
# Should not contain all 2000 items
assert result.count("item") <= 1000
def test_oversized_string_truncated(self):
"""Strings beyond 64KB are truncated."""
huge = "x" * 100_000
result = _normalize_chat_content(huge)
assert len(result) == 65_536
def test_empty_text_parts_filtered(self):
content = [
@ -80,25 +35,4 @@ class TestNormalizeChatContent:
]
assert _normalize_chat_content(content) == "actual"
def test_dict_without_type_skipped(self):
content = [{"foo": "bar"}, {"type": "text", "text": "real"}]
assert _normalize_chat_content(content) == "real"
def test_empty_list_returns_empty(self):
assert _normalize_chat_content([]) == ""
def test_many_small_parts_normalize_without_quadratic_rescan(self, monkeypatch):
"""Large content arrays should normalize in linear time."""
content = [{"type": "text", "text": "x"} for _ in range(1000)]
sum_calls = 0
def counting_sum(values):
nonlocal sum_calls
sum_calls += 1
return sum(values)
monkeypatch.setattr(api_server, "sum", counting_sum, raising=False)
result = _normalize_chat_content(content)
assert result.count("x") == 1000
assert sum_calls == 0

96
tests/gateway/test_api_server_toolset.py
View file

@ -8,12 +8,6 @@ from toolsets import resolve_toolset, get_toolset, validate_toolset
class TestHermesApiServerToolset:
"""Tests for the hermes-api-server toolset definition."""
def test_toolset_exists(self):
ts = get_toolset("hermes-api-server")
assert ts is not None
def test_toolset_validates(self):
assert validate_toolset("hermes-api-server")
def test_toolset_includes_web_tools(self):
tools = resolve_toolset("hermes-api-server")
@ -39,29 +33,8 @@ class TestHermesApiServerToolset:
"browser_press"]:
assert tool in tools, f"Missing browser tool: {tool}"
def test_toolset_includes_homeassistant_tools(self):
tools = resolve_toolset("hermes-api-server")
for tool in ["ha_list_entities", "ha_get_state", "ha_list_services", "ha_call_service"]:
assert tool in tools, f"Missing HA tool: {tool}"
def test_toolset_excludes_clarify(self):
tools = resolve_toolset("hermes-api-server")
assert "clarify" not in tools
def test_toolset_excludes_send_message(self):
tools = resolve_toolset("hermes-api-server")
assert "send_message" not in tools
def test_toolset_excludes_text_to_speech(self):
tools = resolve_toolset("hermes-api-server")
assert "text_to_speech" not in tools
class TestApiServerPlatformConfig:
def test_platforms_dict_includes_api_server(self):
from hermes_cli.tools_config import PLATFORMS
assert "api_server" in PLATFORMS
assert PLATFORMS["api_server"]["default_toolset"] == "hermes-api-server"
def test_default_api_server_includes_terminal_toolset(self):
"""Regression #49622: desktop-only read_terminal is registered into the
@ -75,46 +48,6 @@ class TestApiServerPlatformConfig:
discover_builtin_tools()
assert "terminal" in _get_platform_tools({}, "api_server")
def test_registering_tool_into_toolset_does_not_drop_toolset_from_inference(self):
"""Class invariant (covers the delegate_cli overlay case): registering a
NEW tool into an existing configurable toolset must never remove that
toolset from a platform whose composite lists the toolset's static
tools. Synthetic registration keeps the test hermetic in CI."""
from tools.registry import registry
from hermes_cli.tools_config import _get_platform_tools
sentinel = "test_sentinel_delegation_tool"
registry.register(
name=sentinel,
toolset="delegation",
schema={"name": sentinel, "description": "test",
"parameters": {"type": "object", "properties": {}}},
handler=lambda args, **kw: "{}",
)
try:
# delegation's static membership (delegate_task) is in the composite,
# so the toolset must survive inference despite the extra registry tool.
assert "delegation" in _get_platform_tools({}, "api_server"), (
"registering a tool into 'delegation' dropped it from api_server"
)
finally:
registry.deregister(sentinel)
def test_default_off_and_restricted_toolsets_stay_off_on_api_server(self):
"""Negative contract: the static-membership comparison must NOT newly
enable default-off or platform-restricted toolsets."""
import os
from unittest.mock import patch
from hermes_cli.tools_config import _get_platform_tools
with patch.dict(os.environ, {}, clear=False):
os.environ.pop("HASS_TOKEN", None)
os.environ.pop("XAI_API_KEY", None)
enabled = _get_platform_tools({}, "api_server")
assert "homeassistant" not in enabled
assert "discord" not in enabled
assert "discord_admin" not in enabled
assert "x_search" not in enabled
class TestApiServerAdapterToolset:
@patch("gateway.platforms.api_server.AIOHTTP_AVAILABLE", True)
@ -147,32 +80,3 @@ class TestApiServerAdapterToolset:
assert len(toolsets) > 0
assert call_kwargs.kwargs.get("platform") == "api_server"
@patch("gateway.platforms.api_server.AIOHTTP_AVAILABLE", True)
def test_create_agent_respects_config_override(self):
"""User can override API server toolsets via platform_toolsets in config.yaml."""
from gateway.platforms.api_server import APIServerAdapter
from gateway.config import PlatformConfig
adapter = APIServerAdapter(PlatformConfig())
with patch("gateway.run._resolve_runtime_agent_kwargs") as mock_kwargs, \
patch("gateway.run._resolve_gateway_model") as mock_model, \
patch("gateway.run._load_gateway_config") as mock_config, \
patch("run_agent.AIAgent") as mock_agent_cls:
mock_kwargs.return_value = {"api_key": "test-key", "base_url": None,
"provider": None, "api_mode": None,
"command": None, "args": []}
mock_model.return_value = "test/model"
# User overrides with just web and terminal
mock_config.return_value = {
"platform_toolsets": {"api_server": ["web", "terminal"]}
}
mock_agent_cls.return_value = MagicMock()
adapter._create_agent()
mock_agent_cls.assert_called_once()
call_kwargs = mock_agent_cls.call_args
toolsets = call_kwargs.kwargs.get("enabled_toolsets")
assert sorted(toolsets) == ["terminal", "web"]

50
tests/gateway/test_approval_prompt_redaction.py
View file

@ -49,9 +49,6 @@ class TestRedactApprovalCommand:
out = _redact_approval_command(raw)
assert _FAKE_JWT not in out
def test_clean_command_passes_through_unchanged(self):
raw = "ls -la /tmp && echo hello"
assert _redact_approval_command(raw) == raw
def test_forces_redaction_even_when_disabled(self, monkeypatch):
"""force=True must redact even if security.redact_secrets is off -- the
@ -62,10 +59,6 @@ class TestRedactApprovalCommand:
out = _redact_approval_command(raw)
assert _FAKE_GHP not in out
def test_handles_none_and_empty(self):
assert _redact_approval_command("") == ""
assert _redact_approval_command(None) == ""
class TestApprovalCommandWiring:
"""Guard the production wiring on BOTH approval-notify transports:
@ -127,31 +120,6 @@ class TestApprovalCommandWiring:
self._assert_redacts_then_uses(api_server, "_approval_notify", "put_nowait")
def test_chat_platform_threads_approval_capabilities_to_adapter(self):
"""The gateway must not drop the backend's one-operation UI contract."""
import ast
import inspect
import gateway.run as run
tree = ast.parse(inspect.getsource(run))
notify = next(
node for node in ast.walk(tree)
if isinstance(node, ast.FunctionDef) and node.name == "_approval_notify_sync"
)
call = next(
node for node in ast.walk(notify)
if isinstance(node, ast.Call)
and isinstance(node.func, ast.Attribute)
and node.func.attr == "send_exec_approval"
)
keywords = {kw.arg: kw.value for kw in call.keywords}
for name, default in (("allow_permanent", True), ("smart_denied", False)):
value = keywords[name]
assert isinstance(value, ast.Call)
assert isinstance(value.func, ast.Attribute) and value.func.attr == "get"
assert isinstance(value.args[0], ast.Constant) and value.args[0].value == name
assert isinstance(value.args[1], ast.Constant) and value.args[1].value is default
class TestApprovalTextFallbackContract:
def test_smart_deny_only_advertises_one_operation(self):
@ -167,22 +135,4 @@ class TestApprovalTextFallbackContract:
assert "approve session" not in text
assert "approve always" not in text
def test_non_smart_restriction_preserves_session_choice(self):
from gateway.run import _format_exec_approval_fallback
text = _format_exec_approval_fallback(
"curl https://example.test", "content warning", "!",
allow_permanent=False, smart_denied=False,
)
assert "`!approve session`" in text
assert "approve always" not in text
def test_manual_prompt_preserves_all_choices(self):
from gateway.run import _format_exec_approval_fallback
text = _format_exec_approval_fallback(
"rm -rf /", "dangerous deletion", "/",
allow_permanent=True, smart_denied=False,
)
assert "`/approve session`" in text
assert "`/approve always`" in text

32
tests/gateway/test_approvals_command.py
View file

@ -36,20 +36,6 @@ def _runner():
return runner
@pytest.mark.asyncio
async def test_gateway_handler_uses_shared_persistent_logic_without_cache_eviction():
runner = _runner()
result = SimpleNamespace(message="Approval mode: manual (persistent profile setting).")
runner._evict_cached_agent = MagicMock()
with patch("hermes_cli.approval_mode.run_approval_mode_command", return_value=result) as run:
output = await runner._handle_approvals_command(_event("/approvals manual"))
assert output == result.message
run.assert_called_once_with("manual")
runner._evict_cached_agent.assert_not_called()
@pytest.mark.asyncio
async def test_gateway_rejects_non_admin_persistent_approval_change():
runner = _runner()
@ -71,21 +57,3 @@ async def test_gateway_rejects_non_admin_persistent_approval_change():
run.assert_not_called()
@pytest.mark.asyncio
async def test_gateway_live_dispatch_routes_and_persists_approvals_command(tmp_path, monkeypatch):
runner = _runner()
home = tmp_path / "home"
home.mkdir()
monkeypatch.setenv("HERMES_HOME", str(home))
monkeypatch.setenv("HERMES_MANAGED_DIR", str(tmp_path / "missing-managed"))
from hermes_cli import managed_scope
from hermes_cli.config import _LOAD_CONFIG_CACHE, _RAW_CONFIG_CACHE
_LOAD_CONFIG_CACHE.clear()
_RAW_CONFIG_CACHE.clear()
managed_scope.invalidate_managed_cache()
output = await runner._handle_message(_event("/approvals manual"))
assert output == "Approval mode: manual (persistent profile setting)."
assert yaml.safe_load((home / "config.yaml").read_text())["approvals"]["mode"] == "manual"

294
tests/gateway/test_approve_deny_commands.py
View file

@ -117,25 +117,6 @@ class TestBlockingGatewayApproval:
assert entry.result == "once"
unregister_gateway_notify(session_key)
def test_resolve_returns_zero_when_no_pending(self):
from tools.approval import resolve_gateway_approval
assert resolve_gateway_approval("nonexistent", "once") == 0
def test_resolve_all_unblocks_multiple_entries(self):
"""resolve_gateway_approval with resolve_all=True signals all entries."""
from tools.approval import (
resolve_gateway_approval, _ApprovalEntry, _gateway_queues,
)
session_key = "test-all"
e1 = _ApprovalEntry({"command": "cmd1"})
e2 = _ApprovalEntry({"command": "cmd2"})
e3 = _ApprovalEntry({"command": "cmd3"})
_gateway_queues[session_key] = [e1, e2, e3]
count = resolve_gateway_approval(session_key, "session", resolve_all=True)
assert count == 3
assert all(e.event.is_set() for e in [e1, e2, e3])
assert all(e.result == "session" for e in [e1, e2, e3])
def test_resolve_single_pops_oldest_fifo(self):
"""resolve_gateway_approval without resolve_all resolves oldest first."""
@ -155,40 +136,6 @@ class TestBlockingGatewayApproval:
assert not e2.event.is_set()
assert len(_gateway_queues[session_key]) == 1
def test_unregister_signals_all_entries(self):
"""unregister_gateway_notify signals all waiting entries to prevent hangs."""
from tools.approval import (
register_gateway_notify, unregister_gateway_notify,
_ApprovalEntry, _gateway_queues,
)
session_key = "test-cleanup"
register_gateway_notify(session_key, lambda d: None)
e1 = _ApprovalEntry({"command": "cmd1"})
e2 = _ApprovalEntry({"command": "cmd2"})
_gateway_queues[session_key] = [e1, e2]
unregister_gateway_notify(session_key)
assert e1.event.is_set()
assert e2.event.is_set()
def test_clear_session_denies_and_signals_all_entries(self):
"""clear_session must wake blocked entries during boundary cleanup."""
from tools.approval import clear_session, _ApprovalEntry, _gateway_queues
session_key = "test-boundary-cleanup"
e1 = _ApprovalEntry({"command": "cmd1"})
e2 = _ApprovalEntry({"command": "cmd2"})
_gateway_queues[session_key] = [e1, e2]
clear_session(session_key)
assert e1.event.is_set()
assert e2.event.is_set()
assert e1.result == "deny"
assert e2.result == "deny"
assert session_key not in _gateway_queues
# ------------------------------------------------------------------
# /approve command
@ -200,22 +147,6 @@ class TestApproveCommand:
def setup_method(self):
_clear_approval_state()
@pytest.mark.asyncio
async def test_approve_resolves_blocking_approval(self):
"""Basic /approve signals the oldest blocked agent thread."""
from tools.approval import _ApprovalEntry, _gateway_queues
runner = _make_runner()
source = _make_source()
session_key = runner._session_key_for_source(source)
entry = _ApprovalEntry({"command": "test"})
_gateway_queues[session_key] = [entry]
result = await runner._handle_approve_command(_make_event("/approve"))
assert "approved" in result.lower()
assert "resuming" in result.lower()
assert entry.event.is_set()
@pytest.mark.asyncio
async def test_approve_all_resolves_multiple(self):
@ -253,25 +184,6 @@ class TestApproveCommand:
assert e1.result == "session"
assert e2.result == "session"
@pytest.mark.asyncio
async def test_approve_no_pending(self):
"""/approve with no pending approval returns helpful message."""
runner = _make_runner()
result = await runner._handle_approve_command(_make_event("/approve"))
assert "No pending command" in result
@pytest.mark.asyncio
async def test_approve_stale_old_style_pending(self):
"""Old-style _pending_approvals without blocking event reports expired."""
runner = _make_runner()
source = _make_source()
session_key = runner._session_key_for_source(source)
runner._pending_approvals[session_key] = {"command": "test"}
result = await runner._handle_approve_command(_make_event("/approve"))
assert "expired" in result.lower() or "no longer waiting" in result.lower()
assert session_key not in runner._pending_approvals
# ------------------------------------------------------------------
# /deny command
@ -283,46 +195,6 @@ class TestDenyCommand:
def setup_method(self):
_clear_approval_state()
@pytest.mark.asyncio
async def test_deny_resolves_blocking_approval(self):
"""/deny signals the oldest blocked agent thread with 'deny'."""
from tools.approval import _ApprovalEntry, _gateway_queues
runner = _make_runner()
source = _make_source()
session_key = runner._session_key_for_source(source)
entry = _ApprovalEntry({"command": "test"})
_gateway_queues[session_key] = [entry]
result = await runner._handle_deny_command(_make_event("/deny"))
assert "denied" in result.lower()
assert entry.event.is_set()
assert entry.result == "deny"
@pytest.mark.asyncio
async def test_deny_all_resolves_all(self):
"""/deny all denies all pending approvals."""
from tools.approval import _ApprovalEntry, _gateway_queues
runner = _make_runner()
source = _make_source()
session_key = runner._session_key_for_source(source)
e1 = _ApprovalEntry({"command": "cmd1"})
e2 = _ApprovalEntry({"command": "cmd2"})
_gateway_queues[session_key] = [e1, e2]
result = await runner._handle_deny_command(_make_event("/deny all"))
assert "2 commands" in result
assert all(e.result == "deny" for e in [e1, e2])
@pytest.mark.asyncio
async def test_deny_no_pending(self):
"""/deny with no pending approval returns helpful message."""
runner = _make_runner()
result = await runner._handle_deny_command(_make_event("/deny"))
assert "No pending command" in result
@pytest.mark.asyncio
async def test_deny_with_reason_attaches_reason(self):
@ -363,22 +235,6 @@ class TestDenyCommand:
assert all(e.result == "deny" for e in [e1, e2])
assert all(e.reason == "wrong directory" for e in [e1, e2])
@pytest.mark.asyncio
async def test_deny_plain_has_no_reason(self):
"""A bare /deny leaves the reason unset (regression guard)."""
from tools.approval import _ApprovalEntry, _gateway_queues
runner = _make_runner()
source = _make_source()
session_key = runner._session_key_for_source(source)
entry = _ApprovalEntry({"command": "test"})
_gateway_queues[session_key] = [entry]
await runner._handle_deny_command(_make_event("/deny"))
assert entry.result == "deny"
assert entry.reason is None
# ------------------------------------------------------------------
# Bare "yes" must NOT trigger approval
@ -436,98 +292,6 @@ class TestBlockingApprovalE2E:
def teardown_method(self):
self._approval_mode_patch.stop()
def test_blocking_approval_approve_once(self):
"""check_all_command_guards blocks until resolve_gateway_approval is called."""
from tools.approval import (
register_gateway_notify, unregister_gateway_notify,
resolve_gateway_approval, check_all_command_guards,
)
session_key = "e2e-test"
notified = []
register_gateway_notify(session_key, lambda d: notified.append(d))
result_holder = [None]
def agent_thread():
from tools.approval import reset_current_session_key, set_current_session_key
token = set_current_session_key(session_key)
os.environ["HERMES_GATEWAY_SESSION"] = "1"
os.environ["HERMES_EXEC_ASK"] = "1"
os.environ["HERMES_SESSION_KEY"] = session_key
try:
result_holder[0] = check_all_command_guards(
"rm -rf /important", "local"
)
finally:
os.environ.pop("HERMES_GATEWAY_SESSION", None)
os.environ.pop("HERMES_EXEC_ASK", None)
os.environ.pop("HERMES_SESSION_KEY", None)
reset_current_session_key(token)
t = threading.Thread(target=agent_thread)
t.start()
for _ in range(50):
if notified:
break
time.sleep(0.05)
assert len(notified) == 1
assert "rm -rf /important" in notified[0]["command"]
resolve_gateway_approval(session_key, "once")
t.join(timeout=5)
assert result_holder[0] is not None
assert result_holder[0]["approved"] is True
unregister_gateway_notify(session_key)
def test_blocking_approval_deny(self):
"""check_all_command_guards returns BLOCKED when denied."""
from tools.approval import (
register_gateway_notify, unregister_gateway_notify,
resolve_gateway_approval, check_all_command_guards,
)
session_key = "e2e-deny"
notified = []
register_gateway_notify(session_key, lambda d: notified.append(d))
result_holder = [None]
def agent_thread():
from tools.approval import reset_current_session_key, set_current_session_key
token = set_current_session_key(session_key)
os.environ["HERMES_GATEWAY_SESSION"] = "1"
os.environ["HERMES_EXEC_ASK"] = "1"
os.environ["HERMES_SESSION_KEY"] = session_key
try:
result_holder[0] = check_all_command_guards(
"rm -rf /important", "local"
)
finally:
os.environ.pop("HERMES_GATEWAY_SESSION", None)
os.environ.pop("HERMES_EXEC_ASK", None)
os.environ.pop("HERMES_SESSION_KEY", None)
reset_current_session_key(token)
t = threading.Thread(target=agent_thread)
t.start()
for _ in range(50):
if notified:
break
time.sleep(0.05)
resolve_gateway_approval(session_key, "deny")
t.join(timeout=5)
assert result_holder[0]["approved"] is False
assert "BLOCKED" in result_holder[0]["message"]
unregister_gateway_notify(session_key)
@pytest.mark.parametrize(
"approval_config",
@ -645,64 +409,6 @@ class TestBlockingApprovalE2E:
assert all(r["approved"] is True for r in results)
unregister_gateway_notify(session_key)
def test_parallel_mixed_approve_deny(self):
"""Approve some, deny others in a parallel batch."""
from tools.approval import (
register_gateway_notify, unregister_gateway_notify,
resolve_gateway_approval, check_all_command_guards,
)
session_key = "e2e-mixed"
register_gateway_notify(session_key, lambda d: None)
results = [None, None]
def make_agent(idx, cmd):
def run():
from tools.approval import reset_current_session_key, set_current_session_key
token = set_current_session_key(session_key)
os.environ["HERMES_GATEWAY_SESSION"] = "1"
os.environ["HERMES_EXEC_ASK"] = "1"
os.environ["HERMES_SESSION_KEY"] = session_key
try:
results[idx] = check_all_command_guards(cmd, "local")
finally:
os.environ.pop("HERMES_GATEWAY_SESSION", None)
os.environ.pop("HERMES_EXEC_ASK", None)
os.environ.pop("HERMES_SESSION_KEY", None)
reset_current_session_key(token)
return run
threads = [
threading.Thread(target=make_agent(0, "rm -rf /x")),
threading.Thread(target=make_agent(1, "rm -rf /y")),
]
for t in threads:
t.start()
# Wait for both threads to register pending approvals instead of
# relying on a fixed sleep. The approval module stores entries in
# _gateway_queues[session_key] — poll until we see 2 entries.
from tools.approval import _gateway_queues
deadline = time.monotonic() + 5
while time.monotonic() < deadline:
if len(_gateway_queues.get(session_key, [])) >= 2:
break
time.sleep(0.05)
# Approve first, deny second
resolve_gateway_approval(session_key, "once") # oldest
resolve_gateway_approval(session_key, "deny") # next
for t in threads:
t.join(timeout=5)
assert all(r is not None for r in results)
assert sorted(r["approved"] for r in results) == [False, True]
assert sum("BLOCKED" in (r.get("message") or "") for r in results) == 1
unregister_gateway_notify(session_key)
# ------------------------------------------------------------------
# Fallback: no gateway callback (cron/batch mode)

198
tests/gateway/test_async_delegation_session_binding.py
View file

@ -44,21 +44,6 @@ class TestInterruptForSessionByParentId:
mine.assert_called_once()
other.assert_not_called()
def test_reset_interrupts_by_key_and_parent(self):
"""A /new reset passes both selectors — either match claims the record."""
by_key = _seed_record("d1", session_key="agent:main:telegram:dm:1", parent_session_id="")
by_parent = _seed_record("d2", session_key="", parent_session_id="sess_old")
unrelated = _seed_record("d3", session_key="other", parent_session_id="other")
n = ad.interrupt_for_session(
session_key="agent:main:telegram:dm:1",
parent_session_id="sess_old",
reason="session_reset",
)
assert n == 2
by_key.assert_called_once()
by_parent.assert_called_once()
unrelated.assert_not_called()
class TestGatewayPinningFailsClosed:
"""The gateway must follow only verified compression continuations."""
@ -113,19 +98,6 @@ class TestGatewayPinningFailsClosed:
runner.session_store, "advance_compression_session"
).assert_not_called()
@pytest.mark.asyncio
async def test_live_spawning_session_stays_pinned(self):
current = self._entry("sess_live")
runner = self._make_runner(
{"sess_live": {"id": "sess_live", "ended_at": None}}
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_live"
)
assert resolved is current
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_live_spawning_session_rebinds_from_different_route(self):
@ -165,64 +137,6 @@ class TestGatewayPinningFailsClosed:
assert resolved is None
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_compression_parent_advances_stale_route_to_live_tip(self):
current = self._entry("sess_parent")
tip = self._entry("sess_tip")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
},
"sess_tip": {
"id": "sess_tip",
"ended_at": None,
"parent_session_id": "sess_parent",
},
},
compression_tip="sess_tip",
switched_entry=tip,
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is tip
getattr(
runner.session_store, "advance_compression_session"
).assert_called_once_with(current.session_key, "sess_parent", "sess_tip")
@pytest.mark.asyncio
async def test_compression_cas_losing_to_new_drops(self):
current = self._entry("sess_parent")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
},
"sess_tip": {
"id": "sess_tip",
"ended_at": None,
"parent_session_id": "sess_parent",
},
},
compression_tip="sess_tip",
switched_entry=None,
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is None
getattr(
runner.session_store, "advance_compression_session"
).assert_called_once_with(current.session_key, "sess_parent", "sess_tip")
@pytest.mark.asyncio
async def test_intermediate_compression_route_advances_to_same_live_tip(self):
@ -293,118 +207,6 @@ class TestGatewayPinningFailsClosed:
runner.session_store, "advance_compression_session"
).assert_called_once_with(current.session_key, "sess_parent", "sess_tip")
@pytest.mark.asyncio
async def test_ended_compression_tip_drops(self):
current = self._entry("sess_parent")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
},
"sess_tip": {
"id": "sess_tip",
"ended_at": "2026-07-08T00:01:00",
"end_reason": "session_reset",
"parent_session_id": "sess_parent",
},
},
compression_tip="sess_tip",
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is None
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_compression_lookup_failure_drops(self):
current = self._entry("sess_parent")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
}
},
compression_error=RuntimeError("db unavailable"),
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is None
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_compression_parent_accepts_already_current_tip(self):
current = self._entry("sess_tip")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
},
"sess_tip": {
"id": "sess_tip",
"ended_at": None,
"parent_session_id": "sess_parent",
},
},
compression_tip="sess_tip",
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is current
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_compression_parent_does_not_override_new_route(self):
current = self._entry("sess_after_new")
runner = self._make_runner(
{
"sess_parent": {
"id": "sess_parent",
"ended_at": "2026-07-08T00:00:00",
"end_reason": "compression",
},
"sess_tip": {
"id": "sess_tip",
"ended_at": None,
"parent_session_id": "sess_parent",
},
},
compression_tip="sess_tip",
)
resolved = await runner._resolve_async_delegation_session(
current, "sess_parent"
)
assert resolved is None
self._assert_no_route_change(runner)
@pytest.mark.asyncio
async def test_unknown_spawning_session_drops(self):
current = self._entry("sess_current")
runner = self._make_runner({})
resolved = await runner._resolve_async_delegation_session(
current, "sess_gone"
)
assert resolved is None
self._assert_no_route_change(runner)
class TestResetHandlerInterruptsDelegations:
def test_reset_command_calls_interrupt_for_session(self):

111
tests/gateway/test_async_delivery_capability.py
View file

@ -39,19 +39,6 @@ class TestAsyncDeliverySupported:
"""CLI / cron / unaware paths never bind the var -> supported."""
assert async_delivery_supported() is True
def test_set_true_is_supported(self):
tokens = set_session_vars(
platform="telegram",
chat_id="123",
session_key="telegram:private:123",
async_delivery=True,
)
try:
assert async_delivery_supported() is True
# Platform metadata stays readable alongside the capability.
assert get_session_env("HERMES_SESSION_PLATFORM") == "telegram"
finally:
clear_session_vars(tokens)
def test_set_false_is_unsupported(self):
tokens = set_session_vars(
@ -68,32 +55,6 @@ class TestAsyncDeliverySupported:
finally:
clear_session_vars(tokens)
def test_omitted_arg_defaults_supported(self):
"""Back-compat: callers that don't pass async_delivery stay supported."""
tokens = set_session_vars(platform="discord", chat_id="9")
try:
assert async_delivery_supported() is True
finally:
clear_session_vars(tokens)
def test_dispatcher_spawned_kanban_worker_is_unsupported(self, monkeypatch):
"""A one-shot Kanban worker cannot receive a detached completion
after its process exits, even when its CLI session otherwise defaults
to supporting async delivery."""
monkeypatch.setenv("HERMES_KANBAN_TASK", "t_review")
assert async_delivery_supported() is False
def test_clear_resets_to_default_supported(self):
"""A cleared context must fall back to default-supported, NOT be
mistaken for an opted-out stateless adapter."""
tokens = set_session_vars(
platform="api_server", session_key="s1", async_delivery=False
)
assert async_delivery_supported() is False
clear_session_vars(tokens)
assert async_delivery_supported() is True
# ---------------------------------------------------------------------------
# Stateless runners — issues #53027 / #63142
@ -109,16 +70,6 @@ class TestDeclareStatelessChannel:
``delegate_task`` is forced background and every subagent result is lost.
"""
def test_declare_stateless_channel_disables_async_delivery(self):
from gateway.session_context import declare_stateless_channel
reset_session_vars() # don't assume ambient contextvar state
assert async_delivery_supported() is True
try:
declare_stateless_channel()
assert async_delivery_supported() is False
finally:
reset_session_vars()
def test_declare_does_not_engage_full_session_context(self):
"""The helper binds ONLY the capability.
@ -203,15 +154,7 @@ class TestStatelessChannelForcesSyncDelegation:
# ---------------------------------------------------------------------------
class TestAdapterCapabilityFlag:
def test_base_default_true(self):
from gateway.platforms.base import BasePlatformAdapter
assert BasePlatformAdapter.supports_async_delivery is True
def test_api_server_false(self):
from gateway.platforms.api_server import APIServerAdapter
assert APIServerAdapter.supports_async_delivery is False
def test_api_server_bind_chokepoint_hardwires_no_delivery(self):
"""Every API-server agent-entry path binds through
@ -229,30 +172,6 @@ class TestAdapterCapabilityFlag:
finally:
clear_session_vars(tokens)
def test_api_server_binding_does_not_outlive_turn(self):
"""The no-delivery decision is request-scoped, NOT stuck to the session.
After clear, a session resumed on a delivering interface re-binds fresh
and is NOT blocked."""
from gateway.platforms.api_server import APIServerAdapter
from gateway.session_context import clear_session_vars
# Turn 1: same session over the API server -> blocked.
tokens = APIServerAdapter._bind_api_server_session(session_key="shared-key")
assert async_delivery_supported() is False
clear_session_vars(tokens)
# Turn 2: SAME session_key resumed on a delivering interface (CLI/gateway)
# -> supported. The earlier False did not follow the session.
tokens = set_session_vars(
platform="telegram",
session_key="shared-key",
async_delivery=True,
)
try:
assert async_delivery_supported() is True
finally:
clear_session_vars(tokens)
# ---------------------------------------------------------------------------
# terminal_tool: refuses to register a watcher on unsupported sessions
@ -290,34 +209,4 @@ class TestTerminalNotifyGate:
assert "poll" in d["notify_unsupported"].lower()
assert len(process_registry.pending_watchers) == 0
def test_gateway_registers_watcher(self):
from tools.process_registry import process_registry
tokens = set_session_vars(
platform="telegram",
chat_id="123",
thread_id="7",
user_id="u1",
session_key="telegram:private:123",
async_delivery=True,
)
try:
d = self._run_bg("sleep 30 && echo DONE")
finally:
clear_session_vars(tokens)
assert d.get("notify_on_complete") is True
assert not d.get("notify_unsupported")
assert len(process_registry.pending_watchers) == 1
assert process_registry.pending_watchers[0]["platform"] == "telegram"
def test_cli_stays_supported(self):
"""CLI delivers via the in-process completion_queue: notify stays on,
no false 'unsupported' note, and no pending_watcher (empty platform)."""
from tools.process_registry import process_registry
d = self._run_bg("sleep 30 && echo DONE")
assert d.get("notify_on_complete") is True
assert not d.get("notify_unsupported")
# No platform bound -> no gateway watcher, but completion_queue still fires.
assert len(process_registry.pending_watchers) == 0

82
tests/gateway/test_async_session_db.py
View file

@ -87,34 +87,6 @@ async def test_offload_goes_through_to_thread(monkeypatch):
assert "returns_str" in seen
@pytest.mark.asyncio
@pytest.mark.parametrize(
"method,expected",
[
("returns_none", None),
("returns_bool", True),
("returns_str", "title"),
("returns_dict", {"id": "s1"}),
("returns_list", [{"id": "s1"}, {"id": "s2"}]),
],
)
async def test_returns_underlying_value_unchanged(method, expected):
facade = AsyncSessionDB(_SpyDB())
assert await getattr(facade, method)() == expected
@pytest.mark.asyncio
async def test_propagates_exception():
facade = AsyncSessionDB(_SpyDB())
with pytest.raises(ValueError, match="boom"):
await facade.raises()
def test_non_callable_attribute_passes_through():
facade = AsyncSessionDB(_SpyDB())
assert facade.attr == "plain-value"
# --------------------------------------------------------------------------
# Guard: no raw self._session_db.<method>( on the gateway loop
# --------------------------------------------------------------------------
@ -314,26 +286,6 @@ def _scan(rel_path: str) -> _RawCallVisitor:
return _RawCallVisitor(ast.parse(source))
def test_no_raw_session_db_calls_on_gateway_loop():
"""Fail if any non-awaited SessionDB call appears in gateway files.
Every loop-reachable DB call must go through AsyncSessionDB (await), whether
spelled directly (self._session_db.<method>(...)) or via a local alias
(db = getattr(self, "_session_db", None); db.<method>(...)). The
sanitize_title staticmethod is called on the class, not self/an alias, so it
is not matched; the _db. sync escape is checked separately below.
"""
violations = []
for rel in _GATEWAY_FILES:
v = _scan(rel)
violations.extend(f"{rel}:{ln} self._session_db.{m}(" for m, ln in v.raw_calls)
violations.extend(f"{rel}:{ln} <alias>.{m}( (binds _session_db)" for m, ln in v.alias_calls)
assert not violations, (
"Non-awaited SessionDB calls on the gateway loop — route through "
"AsyncSessionDB (await ...):\n " + "\n ".join(violations)
)
def test_sync_db_escape_confined_to_off_loop_sites():
"""The self._session_db._db. sync escape must stay confined to known sites.
@ -349,31 +301,6 @@ def test_sync_db_escape_confined_to_off_loop_sites():
)
def test_offloaded_helpers_never_called_bare_on_loop():
"""The offloaded sync helpers must never be called bare on the event loop.
They touch SessionDB synchronously, so a bare ``self._helper(...)`` on the
loop would freeze it. The contract: loop-side callers wrap them in
``await asyncio.to_thread(self._helper, ...)`` (which references the helper
as an attribute — no Call node — so it never appears here). A bare call is
only legitimate when it runs off-loop: inside the ``run_sync`` thread-pool
closure, or inside another offloaded helper (sync->sync, same thread). Any
other bare call means a helper whose body the guard exempts is being invoked
on the loop anyway — re-freezing the loop through the exemption.
"""
off_loop_ok = _OFFLOADED_SYNC_HELPERS | {"run_sync"}
violations = []
for rel in _GATEWAY_FILES:
v = _scan(rel)
for helper, ln, ancestors in v.bare_helper_calls:
if not (ancestors & off_loop_ok):
violations.append(f"{rel}:{ln} bare self.{helper}( on the loop")
assert not violations, (
"Offloaded sync helper called bare on the gateway loop — wrap in "
"await asyncio.to_thread(self.<helper>, ...):\n " + "\n ".join(violations)
)
# --------------------------------------------------------------------------
# Interleaving safety: offloading opens await points where coroutines can
# interleave against the same session rows. The gateway relies on SessionDB's
@ -393,12 +320,3 @@ async def test_concurrent_claim_handoff_single_winner(tmp_path):
assert sum(results) == 1, f"exactly one claim must win, got {sum(results)}"
@pytest.mark.asyncio
async def test_concurrent_create_session_idempotent(tmp_path):
db = AsyncSessionDB(hermes_state.SessionDB(db_path=tmp_path / "state.db"))
sid = "s-create"
await asyncio.gather(*(db.create_session(sid, "test") for _ in range(20)))
rows = await db.list_sessions_rich(limit=100)
assert sum(1 for r in rows if r["id"] == sid) == 1

53
tests/gateway/test_async_session_store.py
View file

@ -20,19 +20,6 @@ class _SpyStore:
return value
@pytest.mark.asyncio
async def test_async_session_store_offloads_calls() -> None:
store = _SpyStore()
facade = AsyncSessionStore(store) # type: ignore[arg-type]
loop_thread = threading.get_ident()
assert await facade.read("ok") == "ok"
assert store.calls == [("ok", store.calls[0][1])]
assert store.calls[0][1] != loop_thread
assert facade.label == "store"
assert facade._store is store
def _nearest_function(node: ast.AST, parents: dict[ast.AST, ast.AST]):
current = node
while current in parents:
@ -107,46 +94,6 @@ def test_gateway_async_code_uses_one_awaited_session_store_boundary() -> None:
assert not violations, "\n".join(violations)
def test_every_async_compression_check_is_awaited() -> None:
root = Path(__file__).resolve().parents[2]
tree = ast.parse((root / "gateway/run.py").read_text(encoding="utf-8"))
parents = {
child: parent
for parent in ast.walk(tree)
for child in ast.iter_child_nodes(parent)
}
violations = []
for node in ast.walk(tree):
if (
isinstance(node, ast.Call)
and isinstance(node.func, ast.Attribute)
and node.func.attr == "_session_has_compression_in_flight"
and not _is_awaited(node, parents)
):
violations.append(node.lineno)
assert not violations, f"compression check must be awaited at lines {violations}"
def test_gateway_initializes_async_session_store_facade() -> None:
source = (Path(__file__).resolve().parents[2] / "gateway/run.py").read_text(
encoding="utf-8"
)
tree = ast.parse(source)
assignments = [
node
for node in ast.walk(tree)
if isinstance(node, ast.Assign)
and any(
isinstance(target, ast.Attribute)
and isinstance(target.value, ast.Name)
and target.value.id == "self"
and target.attr == "_async_session_store"
for target in node.targets
)
]
assert assignments, "GatewayRunner must initialize one AsyncSessionStore facade"
def test_no_repository_local_claude_permissions_file() -> None:
root = Path(__file__).resolve().parents[2]
assert not (root / ".claude" / "settings.json").exists()

80
tests/gateway/test_audio_cache.py
View file

@ -38,12 +38,6 @@ class TestGetAudioCacheDir:
assert cache_dir.exists()
assert cache_dir.is_dir()
def test_returns_existing_directory(self):
first = get_audio_cache_dir()
second = get_audio_cache_dir()
assert first == second
assert first.exists()
# ---------------------------------------------------------------------------
# TestCacheAudioFromBytes
@ -60,20 +54,6 @@ class TestCacheAudioFromBytes:
path = cache_audio_from_bytes(b"data")
assert path.endswith(".ogg")
def test_custom_extension(self):
path = cache_audio_from_bytes(b"data", ext=".mp3")
assert path.endswith(".mp3")
def test_unique_filenames(self):
p1 = cache_audio_from_bytes(b"a")
p2 = cache_audio_from_bytes(b"b")
assert p1 != p2
def test_file_written_inside_cache_dir(self):
path = cache_audio_from_bytes(b"data")
cache_dir = get_audio_cache_dir()
assert Path(path).resolve().is_relative_to(cache_dir.resolve())
# ---------------------------------------------------------------------------
# TestCleanupAudioCache
@ -101,56 +81,12 @@ class TestCleanupAudioCache:
assert removed == 0
assert recent.exists()
def test_returns_removed_count(self):
cache_dir = get_audio_cache_dir()
old_time = time.time() - 48 * 3600
for i in range(3):
f = cache_dir / f"old_{i}.ogg"
f.write_text("old")
os.utime(f, (old_time, old_time))
removed = cleanup_audio_cache(max_age_hours=24)
assert removed == 3
def test_ignores_subdirectories(self):
cache_dir = get_audio_cache_dir()
subdir = cache_dir / "subdir"
subdir.mkdir()
old_time = time.time() - 48 * 3600
os.utime(subdir, (old_time, old_time))
# Should not raise or attempt to remove the directory as a file.
removed = cleanup_audio_cache(max_age_hours=24)
assert removed == 0
assert subdir.exists()
def test_empty_cache_returns_zero(self):
removed = cleanup_audio_cache(max_age_hours=24)
assert removed == 0
# ---------------------------------------------------------------------------
# TestUnifiedMediaCacheCleanup — video + screenshot ride the same shared loop
# ---------------------------------------------------------------------------
class TestUnifiedMediaCacheCleanup:
def test_cleanup_video_cache_removes_old_files(self, tmp_path, monkeypatch):
from gateway.platforms.base import cleanup_video_cache, get_video_cache_dir
monkeypatch.setattr(
"gateway.platforms.base.VIDEO_CACHE_DIR", tmp_path / "video_cache"
)
cache_dir = get_video_cache_dir()
old_file = cache_dir / "old.mp4"
old_file.write_text("old")
old_mtime = time.time() - 48 * 3600
os.utime(old_file, (old_mtime, old_mtime))
fresh = cache_dir / "fresh.mp4"
fresh.write_text("fresh")
removed = cleanup_video_cache(max_age_hours=24)
assert removed == 1
assert not old_file.exists()
assert fresh.exists()
def test_cleanup_screenshot_cache_removes_old_files(self, tmp_path, monkeypatch):
from gateway.platforms.base import (
@ -174,19 +110,3 @@ class TestUnifiedMediaCacheCleanup:
assert not old_file.exists()
assert fresh.exists()
def test_housekeeping_loop_covers_all_media_caches(self):
"""The housekeeping tick prunes every media cache via one shared loop."""
import inspect
from gateway import run as gateway_run
src = inspect.getsource(gateway_run._start_gateway_housekeeping)
assert "MEDIA_CACHE_CLEANUPS" in src
for fn_name in (
"cleanup_image_cache",
"cleanup_document_cache",
"cleanup_audio_cache",
"cleanup_video_cache",
"cleanup_screenshot_cache",
):
assert fn_name in src, f"{fn_name} missing from housekeeping loop"

58
tests/gateway/test_auth_fallback.py
View file

@ -54,62 +54,4 @@ class TestResolveRuntimeAgentKwargsAuthFallback:
# Should have been called at least twice (primary + fallback)
assert call_count["n"] >= 2
def test_auth_error_no_fallback_raises(self, tmp_path, monkeypatch):
"""When primary fails and no fallback configured, RuntimeError is raised."""
from hermes_cli.auth import AuthError
config_path = tmp_path / "config.yaml"
config_path.write_text("model:\n provider: openai-codex\n")
monkeypatch.setattr("gateway.run._hermes_home", tmp_path)
with patch(
"hermes_cli.runtime_provider.resolve_runtime_provider",
side_effect=AuthError("token expired"),
):
from gateway.run import _resolve_runtime_agent_kwargs
with pytest.raises(RuntimeError):
_resolve_runtime_agent_kwargs()
def test_legacy_fallback_is_appended_after_fallback_providers(self, tmp_path, monkeypatch):
"""When both keys exist, the legacy entry still participates in resolution."""
config_path = tmp_path / "config.yaml"
config_path.write_text(
"fallback_providers:\n"
" - provider: openrouter\n"
" model: anthropic/claude-sonnet-4.6\n"
"fallback_model:\n"
" provider: nous\n"
" model: Hermes-4\n"
)
monkeypatch.setattr("gateway.run._hermes_home", tmp_path)
calls = []
def _mock_resolve(**kwargs):
requested = kwargs.get("requested")
calls.append(requested)
if requested == "openrouter":
raise RuntimeError("openrouter unavailable")
return {
"api_key": "nous-key",
"base_url": "https://portal.nousresearch.com/v1",
"provider": "nous",
"api_mode": "chat_completions",
"command": None,
"args": None,
"credential_pool": None,
}
with patch(
"hermes_cli.runtime_provider.resolve_runtime_provider",
side_effect=_mock_resolve,
):
from gateway.run import _try_resolve_fallback_provider
result = _try_resolve_fallback_provider()
assert calls == ["openrouter", "nous"]
assert result["provider"] == "nous"
assert result["model"] == "Hermes-4"

170
tests/gateway/test_auto_continue.py
View file

@ -7,7 +7,6 @@ does not re-execute stale interrupted tool calls before addressing new input.
"""
def _simulate_auto_continue(agent_history: list, user_message: str) -> str:
"""Reproduce the auto-continue injection logic from _run_agent().
@ -45,55 +44,11 @@ class TestAutoDetection:
assert "Do NOT re-execute" in result
assert "what happened?" in result
def test_trailing_assistant_message_no_note(self):
history = [
{"role": "user", "content": "hello"},
{"role": "assistant", "content": "Hi there!"},
]
result = _simulate_auto_continue(history, "how are you?")
assert "[System note:" not in result
assert result == "how are you?"
def test_empty_history_no_note(self):
result = _simulate_auto_continue([], "hello")
assert result == "hello"
def test_trailing_user_message_no_note(self):
"""Shouldn't happen in practice, but ensure no false positive."""
history = [
{"role": "user", "content": "hello"},
]
result = _simulate_auto_continue(history, "hello again")
assert result == "hello again"
def test_multiple_tool_results_still_triggers(self):
"""Multiple tool calls in a row — last one is still role=tool."""
history = [
{"role": "user", "content": "search and read"},
{"role": "assistant", "content": None, "tool_calls": [
{"id": "call_1", "function": {"name": "search", "arguments": "{}"}},
{"id": "call_2", "function": {"name": "read", "arguments": "{}"}},
]},
{"role": "tool", "tool_call_id": "call_1", "content": "found it"},
{"role": "tool", "tool_call_id": "call_2", "content": "file content here"},
]
result = _simulate_auto_continue(history, "continue")
assert "[System note:" in result
def test_original_message_preserved_after_note(self):
"""The user's actual message must appear after the system note."""
history = [
{"role": "assistant", "content": None, "tool_calls": [
{"id": "c1", "function": {"name": "t", "arguments": "{}"}}
]},
{"role": "tool", "tool_call_id": "c1", "content": "done"},
]
result = _simulate_auto_continue(history, "now do X")
# System note comes first, then user's message
note_end = result.index("]\n\n")
user_msg_start = result.index("now do X")
assert user_msg_start > note_end
class TestInterruptedReplayFiltering:
def test_interrupted_side_effect_is_replayed_as_unknown(self):
@ -123,53 +78,6 @@ class TestInterruptedReplayFiltering:
assert agent_history[-1]["tool_call_id"] == "call_1"
assert agent_history[-1]["effect_disposition"] == "unknown"
def test_mixed_tail_preserves_results_and_marks_interrupted_effect_unknown(self):
from gateway.run import _build_gateway_agent_history
history = [
{"role": "user", "content": "search and transcribe"},
{
"role": "assistant",
"content": None,
"tool_calls": [
{"id": "call_1", "function": {"name": "web_search", "arguments": "{}"}},
{"id": "call_2", "function": {"name": "terminal", "arguments": "{}"}},
],
},
{"role": "tool", "tool_call_id": "call_1", "content": "found URL"},
{
"role": "tool",
"tool_call_id": "call_2",
"content": '{"exit_code": 130, "output": "[Command interrupted]"}',
},
]
agent_history, _observed_context = _build_gateway_agent_history(history)
assert agent_history[:3] == history[:3]
assert agent_history[-1]["role"] == "tool"
assert agent_history[-1]["tool_call_id"] == "call_2"
assert agent_history[-1]["effect_disposition"] == "unknown"
def test_successful_tool_tail_is_preserved(self):
from gateway.run import _build_gateway_agent_history
history = [
{"role": "user", "content": "deploy"},
{
"role": "assistant",
"content": None,
"tool_calls": [
{"id": "call_1", "function": {"name": "terminal", "arguments": "{}"}},
],
},
{"role": "tool", "tool_call_id": "call_1", "content": "deployed successfully"},
]
agent_history, _observed_context = _build_gateway_agent_history(history)
assert agent_history[-1]["role"] == "tool"
assert agent_history[-1]["content"] == "deployed successfully"
def test_dangling_unanswered_side_effect_is_replayed_as_unknown(self):
"""A trailing side-effecting call gets an UNKNOWN result, not a retry.
@ -206,82 +114,4 @@ class TestInterruptedReplayFiltering:
assert agent_history[-1]["tool_call_id"] == "call_1"
assert agent_history[-1]["effect_disposition"] == "unknown"
def test_dangling_tail_after_completed_pair_gets_unknown_result(self):
"""The completed pair survives and the trailing call becomes UNKNOWN.
An earlier completed assistant→tool pair must survive, and the final
assistant(tool_calls) receives a matching UNKNOWN result.
"""
from gateway.run import _build_gateway_agent_history
history = [
{"role": "user", "content": "do two things"},
{
"role": "assistant",
"content": None,
"tool_calls": [
{"id": "call_1", "function": {"name": "web_search", "arguments": "{}"}},
],
},
{"role": "tool", "tool_call_id": "call_1", "content": "found it"},
{
"role": "assistant",
"content": None,
"tool_calls": [
{
"id": "call_2",
"function": {
"name": "terminal",
"arguments": '{"command": "systemctl restart hermes"}',
},
},
],
},
]
agent_history, _observed_context = _build_gateway_agent_history(history)
# The completed call_1 pair survives; call_2 is closed truthfully.
assert agent_history[-1]["role"] == "tool"
assert agent_history[-1]["tool_call_id"] == "call_2"
assert agent_history[-1]["effect_disposition"] == "unknown"
assert agent_history[2]["content"] == "found it"
# Both assistant calls survive with matching tool results.
_surviving_calls = [
tc.get("id")
for m in agent_history
if m.get("role") == "assistant" and m.get("tool_calls")
for tc in m["tool_calls"]
]
assert _surviving_calls == ["call_1", "call_2"]
def test_persisted_auto_continue_note_is_not_replayed(self):
from gateway.run import _build_gateway_agent_history
history = [
{"role": "user", "content": "first real question"},
{
"role": "user",
"content": (
"[System note: Your previous turn was interrupted before you could "
"process the last tool result(s).]\n\nsecond real question"
),
},
{"role": "assistant", "content": "answer"},
{
"role": "user",
"content": (
"[System note: A new message has arrived. The conversation "
"history contains pending tool outputs from an interrupted turn.]\n\nthird"
),
},
]
agent_history, _observed_context = _build_gateway_agent_history(history)
assert agent_history == [
{"role": "user", "content": "first real question"},
{"role": "user", "content": "second real question"},
{"role": "assistant", "content": "answer"},
{"role": "user", "content": "third"},
]

88
tests/gateway/test_auto_voice_reply_format.py
View file

@ -13,63 +13,7 @@ from gateway.session import SessionSource
class TestAutoVoiceReplyFormat:
@pytest.mark.asyncio
async def test_telegram_auto_voice_reply_requests_ogg_for_native_voice_bubble(self):
"""Telegram auto-TTS should request OGG/Opus so send_voice sends a voice bubble."""
runner = _make_runner()
adapter = _make_adapter(Platform.TELEGRAM)
runner.adapters[Platform.TELEGRAM] = adapter
event = _make_event(Platform.TELEGRAM)
requested_paths = []
def fake_tts(*, text, output_path):
requested_paths.append(output_path)
assert output_path.endswith(".ogg")
Path(output_path).parent.mkdir(parents=True, exist_ok=True)
Path(output_path).write_bytes(b"fake ogg opus")
return json.dumps({
"success": True,
"file_path": output_path,
"provider": "gemini",
"voice_compatible": True,
})
with patch("tools.tts_tool.text_to_speech_tool", side_effect=fake_tts):
await runner._send_voice_reply(event, "hello from auto tts")
assert requested_paths
assert requested_paths[0].endswith(".ogg")
adapter.send_voice.assert_awaited_once()
assert adapter.send_voice.await_args.kwargs["audio_path"].endswith(".ogg")
@pytest.mark.asyncio
async def test_non_telegram_auto_voice_reply_keeps_mp3_default(self):
"""Non-Telegram platforms should keep the current MP3 default."""
runner = _make_runner()
adapter = _make_adapter(Platform.SLACK)
runner.adapters[Platform.SLACK] = adapter
event = _make_event(Platform.SLACK)
requested_paths = []
def fake_tts(*, text, output_path):
requested_paths.append(output_path)
assert output_path.endswith(".mp3")
Path(output_path).parent.mkdir(parents=True, exist_ok=True)
Path(output_path).write_bytes(b"fake mp3")
return json.dumps({
"success": True,
"file_path": output_path,
"provider": "gemini",
"voice_compatible": False,
})
with patch("tools.tts_tool.text_to_speech_tool", side_effect=fake_tts):
await runner._send_voice_reply(event, "hello from auto tts")
assert requested_paths
assert requested_paths[0].endswith(".mp3")
adapter.send_voice.assert_awaited_once()
assert adapter.send_voice.await_args.kwargs["audio_path"].endswith(".mp3")
@pytest.mark.asyncio
@pytest.mark.parametrize(
@ -129,38 +73,6 @@ class TestAutoVoiceReplyFormat:
voice_event, "hello", [], already_sent=True
) is True
def test_should_send_voice_reply_uses_global_auto_tts_adapter_default(self):
"""voice.auto_tts=true should make normal text replies get voice too."""
runner = _make_runner()
adapter = _make_adapter(Platform.TELEGRAM)
adapter._should_auto_tts_for_chat = MagicMock(return_value=True)
runner.adapters[Platform.TELEGRAM] = adapter
event = _make_event(Platform.TELEGRAM, chat_id="123")
assert runner._should_send_voice_reply(event, "hello", []) is True
adapter._should_auto_tts_for_chat.assert_called_once_with("123")
def test_should_send_voice_reply_honors_explicit_voice_off_over_global_auto_tts(self):
"""A chat-level /voice off remains a hard override."""
runner = _make_runner()
runner._voice_mode["telegram:123"] = "off"
adapter = _make_adapter(Platform.TELEGRAM)
adapter._should_auto_tts_for_chat = MagicMock(return_value=True)
runner.adapters[Platform.TELEGRAM] = adapter
event = _make_event(Platform.TELEGRAM, chat_id="123")
assert runner._should_send_voice_reply(event, "hello", []) is False
def test_should_send_voice_reply_voice_only_still_requires_voice_input(self):
runner = _make_runner()
runner._voice_mode["telegram:123"] = "voice_only"
event = _make_event(Platform.TELEGRAM, chat_id="123")
assert runner._should_send_voice_reply(event, "hello", []) is False
voice_event = _make_event(Platform.TELEGRAM, chat_id="123", message_type=MessageType.VOICE)
assert runner._should_send_voice_reply(voice_event, "hello", [], already_sent=True) is True
def _make_runner() -> GatewayRunner:
with patch("gateway.run.GatewayRunner._load_voice_modes", return_value={}):

Some files were not shown because too many files have changed in this diff Show more