hermes-agent/tests/gateway/test_media_only_outcome.py
Halldrix 78de23053f fix(gateway): report media-only turns as SUCCESS when attachments deliver
Thread record_delivery through _deliver_attachments, _deliver_media_attachments
and _send_image_batch so attachment sends feed the turn outcome tracker.
send_multiple_images (base default and Signal override) now returns SendResult
(success when at least one image/batch was accepted); _send_attachment_batch
returns bool. Legacy native-batch overrides that still return None record
nothing, keeping their previous behavior until migrated.

Fixes #106153
2026-09-09 09:45:54 -07:00

120 lines
4.3 KiB
Python

"""Regression tests for #106153 — media-only turns reported FAILURE.
``_process_message_background`` fed its ``on_processing_complete`` outcome from
``delivery_attempted``/``delivery_succeeded``, which only text/TTS sends
populated. A turn replying with just ``MEDIA:<path>`` delivered the attachment
fine but computed ``processing_ok = False`` (no text attempted, non-empty
response), so Signal swapped the 👀 reaction for ❌ instead of ✅.
The attachment path now feeds the same tracker, so a delivered media-only
turn reports SUCCESS and a failed one still reports FAILURE.
"""
import asyncio
import pytest
from gateway.config import Platform, PlatformConfig
from gateway.platforms.base import (
BasePlatformAdapter,
SendResult,
)
from gateway.platforms.event import MessageEvent, MessageType, ProcessingOutcome
from gateway.session import SessionSource, build_session_key
class _MediaOutcomeAdapter(BasePlatformAdapter):
"""Base-loop adapter (no ``send_multiple_images`` override) that records
the turn outcome via the production ``on_processing_complete`` hook."""
def __init__(self, *, image_ok: bool = True):
super().__init__(PlatformConfig(enabled=True, token="fake-token"), Platform.SIGNAL)
self._image_ok = image_ok
self.outcomes: list = []
self.images_sent: list = []
async def connect(self, *, is_reconnect: bool = False) -> bool:
return True
async def disconnect(self) -> None:
return None
async def send(self, chat_id, content, reply_to=None, metadata=None) -> SendResult:
return SendResult(success=True, message_id="msg-1")
async def send_typing(self, chat_id: str, metadata=None) -> None:
return None
async def get_chat_info(self, chat_id: str):
return {"id": chat_id}
async def send_image_file(self, chat_id, image_path, caption=None,
reply_to=None, metadata=None, **kwargs) -> SendResult:
self.images_sent.append(str(image_path))
if self._image_ok:
return SendResult(success=True, message_id="img-1")
return SendResult(success=False, error="boom")
async def on_processing_complete(self, event: MessageEvent, outcome: ProcessingOutcome) -> None:
self.outcomes.append(outcome)
async def _hold_typing(_chat_id, interval=2.0, metadata=None, stop_event=None):
if stop_event is not None:
await stop_event.wait()
else:
await asyncio.Event().wait()
def _allowed_image(tmp_path, monkeypatch, name: str = "photo.png"):
root = tmp_path / "media-cache"
f = root / name
f.parent.mkdir(parents=True, exist_ok=True)
f.write_bytes(b"\x89PNG\r\n\x1a\n" + b"x" * 64)
monkeypatch.setattr("gateway.platforms.base.MEDIA_DELIVERY_SAFE_ROOTS", (root,))
return f.resolve()
def _make_event() -> MessageEvent:
return MessageEvent(
text="send the photo",
message_type=MessageType.TEXT,
source=SessionSource(platform=Platform.SIGNAL, chat_id="111", chat_type="dm"),
message_id="m1",
)
@pytest.mark.asyncio
async def test_media_only_success_reports_success(tmp_path, monkeypatch):
"""Delivered media-only turn must report SUCCESS (was FAILURE → ❌)."""
png = _allowed_image(tmp_path, monkeypatch)
adapter = _MediaOutcomeAdapter(image_ok=True)
adapter._keep_typing = _hold_typing
async def handler(_event):
return f"MEDIA:{png}"
adapter.set_message_handler(handler)
event = _make_event()
await adapter._process_message_background(event, build_session_key(event.source))
assert adapter.images_sent == [str(png)]
assert adapter.outcomes == [ProcessingOutcome.SUCCESS]
@pytest.mark.asyncio
async def test_media_only_failure_still_reports_failure(tmp_path, monkeypatch):
"""A media-only turn whose attachment failed must still report FAILURE."""
png = _allowed_image(tmp_path, monkeypatch)
adapter = _MediaOutcomeAdapter(image_ok=False)
adapter._keep_typing = _hold_typing
async def handler(_event):
return f"MEDIA:{png}"
adapter.set_message_handler(handler)
event = _make_event()
await adapter._process_message_background(event, build_session_key(event.source))
assert adapter.images_sent == [str(png)]
assert adapter.outcomes == [ProcessingOutcome.FAILURE]