hermes-agent/tests/cron/test_bot_chat_warning_replay.py
teknium1 aedc6ccc3a test: purge low-value tests, lane py05 (339 removed)
Change-detectors, tautologies, source-reading tests, redundant duplicates,
mock-echo tests and dead/unrunnable tests. Per-test rationale in the lane
ledger (category + reason for every removal).
2026-09-23 03:15:26 -07:00

169 lines
7.2 KiB
Python

"""Warning policy cannot change the identity or outcome of a Bot Chat handoff."""
import json
from unittest.mock import Mock
import pytest
from cron import bot_chat_delivery as pending
from cron import scheduler_delivery as delivery
from hermes_cli.active_sessions import try_acquire_active_session
from hermes_state import SessionDB
from tools import bot_live_delivery as mailbox
@pytest.fixture
def owner(tmp_path, monkeypatch):
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
db = SessionDB(db_path=tmp_path / "state.db")
db.create_session(session_id="chat", source="tui")
db.set_session_title("chat", "Bot Chat")
leases = []
run = Mock(side_effect=AssertionError("must not launch a second owner"))
monkeypatch.setattr(delivery, "_run_bot_chat_turn", run)
def acquire(live):
lease, refusal = try_acquire_active_session(
session_id="chat", surface="desktop" if live else "cli", config={},
registry_home=tmp_path,
metadata={"bot_live_delivery_consumer": True, "live_session_id": "live"} if live else {},
)
assert refusal is None
leases.append(lease)
return lease
yield tmp_path, acquire, run
for lease in leases:
lease.release()
db.close()
def policy(home, suppress):
(home / "config.yaml").write_text(
f"display: {{suppress_warning_notifications: {str(suppress).lower()}}}\n"
)
def receipt_key(job):
return job["_bot_chat_delivery_receipts"]["bot-chat:(own)"]["delivery_id"]
@pytest.mark.parametrize("live,first_failure,suppress_retry", [
(False, True, True), (True, False, True), (True, True, False),
])
def test_admitted_identity_rejects_category_changing_retry(owner, live, first_failure, suppress_retry):
home, acquire, run = owner
acquire(live)
job = {"id": "job", "execution_id": "run"}
assert "queued" in delivery._deliver_to_bot_chat(job, "same payload", "", for_failure=first_failure)
key = receipt_key(job)
before = mailbox.read_delivery_result(home, key) if live else pending.read_pending(key)
policy(home, suppress_retry)
result = delivery._deliver_to_bot_chat(job, "same payload", "", for_failure=not first_failure)
assert result and "different payload" in result
assert not job.get("_notification_all_targets_suppressed")
after = mailbox.read_delivery_result(home, key) if live else pending.read_pending(key)
assert after == before
run.assert_not_called()
@pytest.mark.parametrize("live,status", [
(False, "queued"), (False, "settled"), (True, "claimed"), (True, "ambiguous"),
])
def test_admitted_outcome_survives_suppressed_retry(owner, live, status):
home, acquire, run = owner
acquire(live)
job = {"id": "job", "execution_id": "run"}
assert "queued" in delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True)
key = receipt_key(job)
if live:
if status != "queued":
mailbox.claim_pending_delivery(home, mailbox.find_canonical_live_owner(home))
if status not in ("queued", "claimed"):
mailbox.complete_delivery(home, key, status=status, reply="retained result")
before = mailbox.read_delivery_result(home, key)
else:
path = home / "cron" / "bot_chat_pending" / f"{key}.json"
record = pending.read_pending(key)
record["status"] = status
path.write_text(json.dumps(record))
before = pending.read_pending(key)
policy(home, True)
result = delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True)
if not live and status == "queued":
assert result is None
assert pending.read_pending(key)["status"] == "suppressed"
assert job.get("_notification_all_targets_suppressed")
else:
assert result is None if status == "settled" else status in result
assert not job.get("_notification_all_targets_suppressed")
assert (mailbox.read_delivery_result(home, key) if live else pending.read_pending(key)) == before
run.assert_not_called()
@pytest.mark.parametrize("live", [False, True])
def test_suppressed_admission_is_durable_across_policy_changes(owner, live):
home, acquire, run = owner
acquire(live)
policy(home, True)
job = {"id": "job", "execution_id": "run"}
assert delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True) is None
assert job.get("_notification_all_targets_suppressed")
policy(home, False)
assert delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True) is None
assert job.get("_notification_all_targets_suppressed")
key = receipt_key(job)
assert pending.read_pending(key)["status"] == "suppressed"
assert pending.read_pending(key)["content"] == "diagnostic"
assert mailbox.read_delivery_result(home, key) is None
pending.drain()
run.assert_not_called()
@pytest.mark.parametrize("owner_suppressed", [False, True])
def test_named_bot_chat_uses_recipient_policy_not_launch_home(owner, monkeypatch, owner_suppressed):
home, acquire, run = owner
acquire(True)
launch = home / "launch"
launch.mkdir()
policy(home, owner_suppressed)
policy(launch, not owner_suppressed)
monkeypatch.setenv("HERMES_HOME", str(launch))
monkeypatch.setattr("hermes_cli.profiles.get_profile_dir", lambda name: home)
job = {"id": "job", "execution_id": "recipient-run"}
result = delivery._deliver_to_bot_chat(job, "diagnostic", "recipient", for_failure=True)
if owner_suppressed:
assert result is None and job.get("_notification_all_targets_suppressed")
else:
assert result and "queued" in result
key = job["_bot_chat_delivery_receipts"]["bot-chat:recipient"]["delivery_id"]
assert mailbox.read_delivery_result(home, key)["notification_category"] == "diagnostic"
assert mailbox.read_delivery_result(launch, key) is None
# Return to the launch home's own policy, proving recipient lookup did not leak.
own = {"id": "own", "execution_id": "own-run"}
if not owner_suppressed:
assert delivery._deliver_to_bot_chat(own, "diagnostic", "", for_failure=True) is None
assert own.get("_notification_all_targets_suppressed")
run.assert_not_called()
def test_deferred_diagnostic_transfers_category_to_real_live_mailbox(owner):
home, acquire, run = owner
cli = acquire(False)
job = {"id": "job", "execution_id": "run"}
assert "queued" in delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True)
key = receipt_key(job)
cli.release()
acquire(True)
pending.drain()
assert pending.read_pending(key)["status"] == "transferred"
record = mailbox.claim_pending_delivery(home, mailbox.find_canonical_live_owner(home))
assert record["delivery_id"] == key
assert record["notification_category"] == "diagnostic"
assert "diagnostic" in record["message"]
mailbox.complete_delivery(home, key, status="settled", reply="handled")
policy(home, True)
assert delivery._deliver_to_bot_chat(job, "diagnostic", "", for_failure=True) is None
assert not job.get("_notification_all_targets_suppressed")
pending.drain()
assert mailbox.claim_pending_delivery(home, mailbox.find_canonical_live_owner(home)) is None
run.assert_not_called()