hermes-agent/tests/hermes_cli/test_kanban_block_classify.py
teknium1 31017b7344 fix(kanban): a caller asserting run ownership cannot classify a parked card
Review follow-up for #117363: the classify-in-place branch returned before
the expected_run_id guard, so a worker whose run had ended could type a
breaker-parked card. Refuse when expected_run_id is given; the run is over.
2026-09-20 15:55:14 -07:00

88 lines
4 KiB
Python

"""block_task() classifies an untyped breaker block in place (#117363)."""
import os
import time
from pathlib import Path
import pytest
from hermes_cli import kanban_db as kb
from hermes_cli import kanban_db_connect as kbc
from hermes_cli import kanban_db_dispatch as kbd
@pytest.fixture
def kanban_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
home = tmp_path / ".hermes"
home.mkdir()
monkeypatch.setenv("HERMES_HOME", str(home))
monkeypatch.setattr(Path, "home", lambda: tmp_path)
kb.init_db()
return home
def _time_out_once(conn, tid: str) -> None:
kb.claim_task(conn, tid)
kbd._set_worker_pid(conn, tid, os.getpid())
started = int(time.time()) - 30
with kb.write_txn(conn):
conn.execute("UPDATE tasks SET started_at = ? WHERE id = ?", (started, tid))
conn.execute(
"UPDATE task_runs SET started_at = ? "
"WHERE id = (SELECT current_run_id FROM tasks WHERE id = ?)",
(started, tid),
)
assert tid in kbd.enforce_max_runtime(conn, signal_fn=lambda pid, sig: None)
def test_typed_block_classifies_untyped_breaker_block(kanban_home, monkeypatch):
"""Two timeouts trip the breaker untyped; the supervisor's typed block then
attaches the kind without a status flap, a synthetic run, or lost evidence."""
monkeypatch.setattr(kb, "_pid_alive", lambda pid: False)
with kbc.connect() as conn:
tid = kb.create_task(conn, title="ceiling", assignee="worker", max_runtime_seconds=1)
_time_out_once(conn, tid)
assert kb.get_task(conn, tid).status == "ready"
_time_out_once(conn, tid)
parked = kb.get_task(conn, tid)
assert (parked.status, parked.block_kind, parked.block_recurrences) == ("blocked", None, 0)
assert kb.block_task(conn, tid, reason="needs a human decision", kind="needs_input") is True
after = kb.get_task(conn, tid)
assert (after.status, after.block_kind, after.block_recurrences) == ("blocked", "needs_input", 1)
assert after.consecutive_failures == parked.consecutive_failures
assert after.last_failure_error == parked.last_failure_error
assert after.current_run_id is None
kinds = [e.kind for e in kb.list_events(conn, tid)]
assert (kinds.count("blocked"), kinds.count("gave_up"), kinds.count("timed_out")) == (1, 1, 2)
assert len(kb.list_runs(conn, tid)) == 2
def test_typed_block_still_refuses_typed_or_live_blocked_cards(kanban_home, monkeypatch):
monkeypatch.setattr(kb, "_pid_alive", lambda pid: False)
with kbc.connect() as conn:
parked = kb.create_task(conn, title="parked", assignee="worker", max_runtime_seconds=1)
_time_out_once(conn, parked)
_time_out_once(conn, parked)
assert kb.get_task(conn, parked).status == "blocked"
stale_run_id = conn.execute(
"SELECT MAX(id) FROM task_runs WHERE task_id = ?", (parked,)).fetchone()[0]
assert stale_run_id is not None
# A worker asserting ownership of its (ended) run cannot classify a parked card.
assert kb.block_task(conn, parked, reason="mine", kind="needs_input",
expected_run_id=stale_run_id) is False
assert kb.get_task(conn, parked).block_kind is None
typed = kb.create_task(conn, title="typed once", assignee="worker")
kb.claim_task(conn, typed)
assert kb.block_task(conn, typed, reason="decision", kind="needs_input") is True
assert kb.block_task(conn, typed, reason="again", kind="capability") is False
assert kb.get_task(conn, typed).block_kind == "needs_input"
live = kb.create_task(conn, title="live run", assignee="worker")
kb.claim_task(conn, live)
with kb.write_txn(conn):
conn.execute("UPDATE tasks SET status = 'blocked' WHERE id = ?", (live,))
assert kb.block_task(conn, live, reason="race", kind="needs_input") is False
assert kb.block_task(conn, live, reason="no kind") is False
assert kb.get_task(conn, live).block_kind is None