hermes-agent/tests/hermes_state/test_restore_alternation_repair.py
Teknium 39975613b1
test: prune wave 2 + speed fixes — 28,106 → 19,757 test functions, suite wall 315s → 294s
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.
2026-07-29 13:39:40 -07:00

101 lines
4.3 KiB
Python

"""get_messages_as_conversation(repair_alternation=True) — heal durable
alternation violations at the restore boundary.
A turn that persists a user row but no assistant row (e.g. its reply was
suppressed, or two concurrent turns interleaved their flushes) leaves a
``user;user`` pair in state.db. Without repair at restore, the defensive
pre-request ``repair_message_sequence`` re-fires on EVERY request for the
rest of the session's life, because it mutates only the per-request list.
Default (``repair_alternation=False``) must stay verbatim: inspection and
export consumers (trace upload, context guard) read the transcript as-is.
"""
import pytest
from hermes_state import SessionDB
@pytest.fixture()
def db(tmp_path):
db_path = tmp_path / "test_state.db"
session_db = SessionDB(db_path=db_path)
yield session_db
session_db.close()
def _seed_wedged_session(db, session_id="s1"):
"""assistant → user → user (no assistant row between): the durable wedge."""
db.create_session(session_id, "system prompt")
db.append_message(session_id=session_id, role="user", content="first ask")
db.append_message(session_id=session_id, role="assistant", content="first reply")
db.append_message(session_id=session_id, role="user", content="unanswered turn")
db.append_message(session_id=session_id, role="user", content="next turn")
db.append_message(session_id=session_id, role="assistant", content="next reply")
def test_repair_alternation_merges_user_pair(db):
_seed_wedged_session(db)
messages = db.get_messages_as_conversation("s1", repair_alternation=True)
roles = [m["role"] for m in messages]
assert roles == ["user", "assistant", "user", "assistant"]
# Both user texts survive, merged in order — no user input is lost.
merged = messages[2]["content"]
assert "unanswered turn" in merged and "next turn" in merged
assert merged.index("unanswered turn") < merged.index("next turn")
def test_repaired_load_is_stable_under_prerequest_repair(db):
"""The restored list must yield ZERO further repairs — this is the whole
point: the pre-request defensive repair stops firing every turn."""
from agent.agent_runtime_helpers import repair_message_sequence
_seed_wedged_session(db)
messages = db.get_messages_as_conversation("s1", repair_alternation=True)
assert repair_message_sequence(None, messages) == 0
# ---------------------------------------------------------------------------
# The live-replay restore SITES must pass repair_alternation=True. The initial
# fix covered gateway load_transcript + CLI startup resume; these are the other
# live-replay restore paths (ACP session resume, CLI /resume, TUI resume) that
# hand the loaded transcript to a live agent for subsequent turns.
# ---------------------------------------------------------------------------
def _seed_wedged_acp_session(db, session_id="acp1"):
db.create_session(session_id, "acp")
db.append_message(session_id=session_id, role="user", content="first ask")
db.append_message(session_id=session_id, role="assistant", content="first reply")
db.append_message(session_id=session_id, role="user", content="unanswered turn")
db.append_message(session_id=session_id, role="user", content="next turn")
db.append_message(session_id=session_id, role="assistant", content="next reply")
def test_acp_restore_heals_alternation_for_live_replay(db):
"""acp_adapter.SessionManager._restore feeds LIVE REPLAY: the loaded history
becomes the resumed agent's working conversation. It must be alternation-
clean so the pre-request repair doesn't re-fire every turn."""
from acp_adapter.session import SessionManager
_seed_wedged_acp_session(db, "acp1")
class _StubAgent:
model = "stub"
mgr = SessionManager(agent_factory=lambda: _StubAgent(), db=db)
state = mgr._restore("acp1")
assert state is not None
roles = [m["role"] for m in state.history]
# No consecutive user turns — the durable user;user wedge was healed.
assert roles == ["user", "assistant", "user", "assistant"], roles
for a, b in zip(roles, roles[1:]):
assert not (a == "user" and b == "user"), "unhealed user;user in ACP live replay"
# No user input lost — both user texts survive, merged in order.
merged = state.history[2]["content"]
assert "unanswered turn" in merged and "next turn" in merged