mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 21:32:52 +00:00
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).
169 lines
7.2 KiB
Python
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()
|