Merge remote-tracking branch 'origin/main' into feat/honcho-async-memory
Made-with: Cursor # Conflicts: # cli.py # tests/test_run_agent.py
This commit is contained in:
Erosika
commit
a0b0dbe6b2
138 changed files with 17829 additions and 1109 deletions
305
tests/gateway/test_background_command.py
Normal file
305
tests/gateway/test_background_command.py
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
"""Tests for /background gateway slash command.
|
||||
|
||||
Tests the _handle_background_command handler (run a prompt in a separate
|
||||
background session) across gateway messenger platforms.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from gateway.config import Platform
|
||||
from gateway.platforms.base import MessageEvent
|
||||
from gateway.session import SessionSource
|
||||
|
||||
|
||||
def _make_event(text="/background", platform=Platform.TELEGRAM,
|
||||
user_id="12345", chat_id="67890"):
|
||||
"""Build a MessageEvent for testing."""
|
||||
source = SessionSource(
|
||||
platform=platform,
|
||||
user_id=user_id,
|
||||
chat_id=chat_id,
|
||||
user_name="testuser",
|
||||
)
|
||||
return MessageEvent(text=text, source=source)
|
||||
|
||||
|
||||
def _make_runner():
|
||||
"""Create a bare GatewayRunner with minimal mocks."""
|
||||
from gateway.run import GatewayRunner
|
||||
runner = object.__new__(GatewayRunner)
|
||||
runner.adapters = {}
|
||||
runner._session_db = None
|
||||
runner._reasoning_config = None
|
||||
runner._provider_routing = {}
|
||||
runner._fallback_model = None
|
||||
runner._running_agents = {}
|
||||
|
||||
mock_store = MagicMock()
|
||||
runner.session_store = mock_store
|
||||
|
||||
from gateway.hooks import HookRegistry
|
||||
runner.hooks = HookRegistry()
|
||||
|
||||
return runner
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# _handle_background_command
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TestHandleBackgroundCommand:
|
||||
"""Tests for GatewayRunner._handle_background_command."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_prompt_shows_usage(self):
|
||||
"""Running /background with no prompt shows usage."""
|
||||
runner = _make_runner()
|
||||
event = _make_event(text="/background")
|
||||
result = await runner._handle_background_command(event)
|
||||
assert "Usage:" in result
|
||||
assert "/background" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_empty_prompt_shows_usage(self):
|
||||
"""Running /background with only whitespace shows usage."""
|
||||
runner = _make_runner()
|
||||
event = _make_event(text="/background ")
|
||||
result = await runner._handle_background_command(event)
|
||||
assert "Usage:" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_valid_prompt_starts_task(self):
|
||||
"""Running /background with a prompt returns confirmation and starts task."""
|
||||
runner = _make_runner()
|
||||
|
||||
# Patch asyncio.create_task to capture the coroutine
|
||||
created_tasks = []
|
||||
original_create_task = asyncio.create_task
|
||||
|
||||
def capture_task(coro, *args, **kwargs):
|
||||
# Close the coroutine to avoid warnings
|
||||
coro.close()
|
||||
mock_task = MagicMock()
|
||||
created_tasks.append(mock_task)
|
||||
return mock_task
|
||||
|
||||
with patch("gateway.run.asyncio.create_task", side_effect=capture_task):
|
||||
event = _make_event(text="/background Summarize the top HN stories")
|
||||
result = await runner._handle_background_command(event)
|
||||
|
||||
assert "🔄" in result
|
||||
assert "Background task started" in result
|
||||
assert "bg_" in result # task ID starts with bg_
|
||||
assert "Summarize the top HN stories" in result
|
||||
assert len(created_tasks) == 1 # background task was created
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_prompt_truncated_in_preview(self):
|
||||
"""Long prompts are truncated to 60 chars in the confirmation message."""
|
||||
runner = _make_runner()
|
||||
long_prompt = "A" * 100
|
||||
|
||||
with patch("gateway.run.asyncio.create_task", side_effect=lambda c, **kw: (c.close(), MagicMock())[1]):
|
||||
event = _make_event(text=f"/background {long_prompt}")
|
||||
result = await runner._handle_background_command(event)
|
||||
|
||||
assert "..." in result
|
||||
# Should not contain the full prompt
|
||||
assert long_prompt not in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_task_id_is_unique(self):
|
||||
"""Each background task gets a unique task ID."""
|
||||
runner = _make_runner()
|
||||
task_ids = set()
|
||||
|
||||
with patch("gateway.run.asyncio.create_task", side_effect=lambda c, **kw: (c.close(), MagicMock())[1]):
|
||||
for i in range(5):
|
||||
event = _make_event(text=f"/background task {i}")
|
||||
result = await runner._handle_background_command(event)
|
||||
# Extract task ID from result (format: "Task ID: bg_HHMMSS_hex")
|
||||
for line in result.split("\n"):
|
||||
if "Task ID:" in line:
|
||||
tid = line.split("Task ID:")[1].strip()
|
||||
task_ids.add(tid)
|
||||
|
||||
assert len(task_ids) == 5 # all unique
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_works_across_platforms(self):
|
||||
"""The /background command works for all platforms."""
|
||||
for platform in [Platform.TELEGRAM, Platform.DISCORD, Platform.SLACK]:
|
||||
runner = _make_runner()
|
||||
with patch("gateway.run.asyncio.create_task", side_effect=lambda c, **kw: (c.close(), MagicMock())[1]):
|
||||
event = _make_event(
|
||||
text="/background test task",
|
||||
platform=platform,
|
||||
)
|
||||
result = await runner._handle_background_command(event)
|
||||
assert "Background task started" in result
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# _run_background_task
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TestRunBackgroundTask:
|
||||
"""Tests for GatewayRunner._run_background_task (the actual execution)."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_adapter_returns_silently(self):
|
||||
"""When no adapter is available, the task returns without error."""
|
||||
runner = _make_runner()
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
user_id="12345",
|
||||
chat_id="67890",
|
||||
user_name="testuser",
|
||||
)
|
||||
# No adapters set — should not raise
|
||||
await runner._run_background_task("test prompt", source, "bg_test")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_credentials_sends_error(self):
|
||||
"""When provider credentials are missing, an error is sent."""
|
||||
runner = _make_runner()
|
||||
mock_adapter = AsyncMock()
|
||||
mock_adapter.send = AsyncMock()
|
||||
runner.adapters[Platform.TELEGRAM] = mock_adapter
|
||||
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
user_id="12345",
|
||||
chat_id="67890",
|
||||
user_name="testuser",
|
||||
)
|
||||
|
||||
with patch("gateway.run._resolve_runtime_agent_kwargs", return_value={"api_key": None}):
|
||||
await runner._run_background_task("test prompt", source, "bg_test")
|
||||
|
||||
# Should have sent an error message
|
||||
mock_adapter.send.assert_called_once()
|
||||
call_args = mock_adapter.send.call_args
|
||||
assert "failed" in call_args[1].get("content", call_args[0][1] if len(call_args[0]) > 1 else "").lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_successful_task_sends_result(self):
|
||||
"""When the agent completes successfully, the result is sent."""
|
||||
runner = _make_runner()
|
||||
mock_adapter = AsyncMock()
|
||||
mock_adapter.send = AsyncMock()
|
||||
mock_adapter.extract_media = MagicMock(return_value=([], "Hello from background!"))
|
||||
mock_adapter.extract_images = MagicMock(return_value=([], "Hello from background!"))
|
||||
runner.adapters[Platform.TELEGRAM] = mock_adapter
|
||||
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
user_id="12345",
|
||||
chat_id="67890",
|
||||
user_name="testuser",
|
||||
)
|
||||
|
||||
mock_result = {"final_response": "Hello from background!", "messages": []}
|
||||
|
||||
with patch("gateway.run._resolve_runtime_agent_kwargs", return_value={"api_key": "test-key"}), \
|
||||
patch("run_agent.AIAgent") as MockAgent:
|
||||
mock_agent_instance = MagicMock()
|
||||
mock_agent_instance.run_conversation.return_value = mock_result
|
||||
MockAgent.return_value = mock_agent_instance
|
||||
|
||||
await runner._run_background_task("say hello", source, "bg_test")
|
||||
|
||||
# Should have sent the result
|
||||
mock_adapter.send.assert_called_once()
|
||||
call_args = mock_adapter.send.call_args
|
||||
content = call_args[1].get("content", call_args[0][1] if len(call_args[0]) > 1 else "")
|
||||
assert "Background task complete" in content
|
||||
assert "Hello from background!" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_exception_sends_error_message(self):
|
||||
"""When the agent raises an exception, an error message is sent."""
|
||||
runner = _make_runner()
|
||||
mock_adapter = AsyncMock()
|
||||
mock_adapter.send = AsyncMock()
|
||||
runner.adapters[Platform.TELEGRAM] = mock_adapter
|
||||
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
user_id="12345",
|
||||
chat_id="67890",
|
||||
user_name="testuser",
|
||||
)
|
||||
|
||||
with patch("gateway.run._resolve_runtime_agent_kwargs", side_effect=RuntimeError("boom")):
|
||||
await runner._run_background_task("test prompt", source, "bg_test")
|
||||
|
||||
mock_adapter.send.assert_called_once()
|
||||
call_args = mock_adapter.send.call_args
|
||||
content = call_args[1].get("content", call_args[0][1] if len(call_args[0]) > 1 else "")
|
||||
assert "failed" in content.lower()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# /background in help and known_commands
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TestBackgroundInHelp:
|
||||
"""Verify /background appears in help text and known commands."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_background_in_help_output(self):
|
||||
"""The /help output includes /background."""
|
||||
runner = _make_runner()
|
||||
event = _make_event(text="/help")
|
||||
result = await runner._handle_help_command(event)
|
||||
assert "/background" in result
|
||||
|
||||
def test_background_is_known_command(self):
|
||||
"""The /background command is in the _known_commands set."""
|
||||
from gateway.run import GatewayRunner
|
||||
import inspect
|
||||
source = inspect.getsource(GatewayRunner._handle_message)
|
||||
assert '"background"' in source
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# CLI /background command definition
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TestBackgroundInCLICommands:
|
||||
"""Verify /background is registered in the CLI command system."""
|
||||
|
||||
def test_background_in_commands_dict(self):
|
||||
"""The /background command is in the COMMANDS dict."""
|
||||
from hermes_cli.commands import COMMANDS
|
||||
assert "/background" in COMMANDS
|
||||
|
||||
def test_background_in_session_category(self):
|
||||
"""The /background command is in the Session category."""
|
||||
from hermes_cli.commands import COMMANDS_BY_CATEGORY
|
||||
assert "/background" in COMMANDS_BY_CATEGORY["Session"]
|
||||
|
||||
def test_background_autocompletes(self):
|
||||
"""The /background command appears in autocomplete results."""
|
||||
from hermes_cli.commands import SlashCommandCompleter
|
||||
from prompt_toolkit.document import Document
|
||||
|
||||
completer = SlashCommandCompleter()
|
||||
doc = Document("backgro") # Partial match
|
||||
completions = list(completer.get_completions(doc, None))
|
||||
# Text doesn't start with / so no completions
|
||||
assert len(completions) == 0
|
||||
|
||||
doc = Document("/backgro") # With slash prefix
|
||||
completions = list(completer.get_completions(doc, None))
|
||||
cmd_displays = [str(c.display) for c in completions]
|
||||
assert any("/background" in d for d in cmd_displays)
|
||||
135
tests/gateway/test_base_topic_sessions.py
Normal file
135
tests/gateway/test_base_topic_sessions.py
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
"""Tests for BasePlatformAdapter topic-aware session handling."""
|
||||
|
||||
import asyncio
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from gateway.config import Platform, PlatformConfig
|
||||
from gateway.platforms.base import BasePlatformAdapter, MessageEvent, SendResult
|
||||
from gateway.session import SessionSource, build_session_key
|
||||
|
||||
|
||||
class DummyTelegramAdapter(BasePlatformAdapter):
|
||||
def __init__(self):
|
||||
super().__init__(PlatformConfig(enabled=True, token="fake-token"), Platform.TELEGRAM)
|
||||
self.sent = []
|
||||
self.typing = []
|
||||
|
||||
async def connect(self) -> bool:
|
||||
return True
|
||||
|
||||
async def disconnect(self) -> None:
|
||||
return None
|
||||
|
||||
async def send(self, chat_id, content, reply_to=None, metadata=None) -> SendResult:
|
||||
self.sent.append(
|
||||
{
|
||||
"chat_id": chat_id,
|
||||
"content": content,
|
||||
"reply_to": reply_to,
|
||||
"metadata": metadata,
|
||||
}
|
||||
)
|
||||
return SendResult(success=True, message_id="1")
|
||||
|
||||
async def send_typing(self, chat_id: str, metadata=None) -> None:
|
||||
self.typing.append({"chat_id": chat_id, "metadata": metadata})
|
||||
return None
|
||||
|
||||
async def get_chat_info(self, chat_id: str):
|
||||
return {"id": chat_id}
|
||||
|
||||
|
||||
def _make_event(chat_id: str, thread_id: str, message_id: str = "1") -> MessageEvent:
|
||||
return MessageEvent(
|
||||
text="hello",
|
||||
source=SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
chat_id=chat_id,
|
||||
chat_type="group",
|
||||
thread_id=thread_id,
|
||||
),
|
||||
message_id=message_id,
|
||||
)
|
||||
|
||||
|
||||
class TestBasePlatformTopicSessions:
|
||||
@pytest.mark.asyncio
|
||||
async def test_handle_message_does_not_interrupt_different_topic(self, monkeypatch):
|
||||
adapter = DummyTelegramAdapter()
|
||||
adapter.set_message_handler(lambda event: asyncio.sleep(0, result=None))
|
||||
|
||||
active_event = _make_event("-1001", "10")
|
||||
adapter._active_sessions[build_session_key(active_event.source)] = asyncio.Event()
|
||||
|
||||
scheduled = []
|
||||
|
||||
def fake_create_task(coro):
|
||||
scheduled.append(coro)
|
||||
coro.close()
|
||||
return SimpleNamespace()
|
||||
|
||||
monkeypatch.setattr(asyncio, "create_task", fake_create_task)
|
||||
|
||||
await adapter.handle_message(_make_event("-1001", "11"))
|
||||
|
||||
assert len(scheduled) == 1
|
||||
assert adapter._pending_messages == {}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_handle_message_interrupts_same_topic(self, monkeypatch):
|
||||
adapter = DummyTelegramAdapter()
|
||||
adapter.set_message_handler(lambda event: asyncio.sleep(0, result=None))
|
||||
|
||||
active_event = _make_event("-1001", "10")
|
||||
adapter._active_sessions[build_session_key(active_event.source)] = asyncio.Event()
|
||||
|
||||
scheduled = []
|
||||
|
||||
def fake_create_task(coro):
|
||||
scheduled.append(coro)
|
||||
coro.close()
|
||||
return SimpleNamespace()
|
||||
|
||||
monkeypatch.setattr(asyncio, "create_task", fake_create_task)
|
||||
|
||||
pending_event = _make_event("-1001", "10", message_id="2")
|
||||
await adapter.handle_message(pending_event)
|
||||
|
||||
assert scheduled == []
|
||||
assert adapter.get_pending_message(build_session_key(pending_event.source)) == pending_event
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_message_background_replies_in_same_topic(self):
|
||||
adapter = DummyTelegramAdapter()
|
||||
typing_calls = []
|
||||
|
||||
async def handler(_event):
|
||||
await asyncio.sleep(0)
|
||||
return "ack"
|
||||
|
||||
async def hold_typing(_chat_id, interval=2.0, metadata=None):
|
||||
typing_calls.append({"chat_id": _chat_id, "metadata": metadata})
|
||||
await asyncio.Event().wait()
|
||||
|
||||
adapter.set_message_handler(handler)
|
||||
adapter._keep_typing = hold_typing
|
||||
|
||||
event = _make_event("-1001", "17585")
|
||||
await adapter._process_message_background(event, build_session_key(event.source))
|
||||
|
||||
assert adapter.sent == [
|
||||
{
|
||||
"chat_id": "-1001",
|
||||
"content": "ack",
|
||||
"reply_to": "1",
|
||||
"metadata": {"thread_id": "17585"},
|
||||
}
|
||||
]
|
||||
assert typing_calls == [
|
||||
{
|
||||
"chat_id": "-1001",
|
||||
"metadata": {"thread_id": "17585"},
|
||||
}
|
||||
]
|
||||
|
|
@ -111,6 +111,13 @@ class TestResolveChannelName:
|
|||
with self._setup(tmp_path, platforms):
|
||||
assert resolve_channel_name("telegram", "nonexistent") is None
|
||||
|
||||
def test_topic_name_resolves_to_composite_id(self, tmp_path):
|
||||
platforms = {
|
||||
"telegram": [{"id": "-1001:17585", "name": "Coaching Chat / topic 17585", "type": "group"}]
|
||||
}
|
||||
with self._setup(tmp_path, platforms):
|
||||
assert resolve_channel_name("telegram", "Coaching Chat / topic 17585") == "-1001:17585"
|
||||
|
||||
|
||||
class TestBuildFromSessions:
|
||||
def _write_sessions(self, tmp_path, sessions_data):
|
||||
|
|
@ -169,6 +176,42 @@ class TestBuildFromSessions:
|
|||
|
||||
assert len(entries) == 1
|
||||
|
||||
def test_keeps_distinct_topics_with_same_chat_id(self, tmp_path):
|
||||
self._write_sessions(tmp_path, {
|
||||
"group_root": {
|
||||
"origin": {"platform": "telegram", "chat_id": "-1001", "chat_name": "Coaching Chat"},
|
||||
"chat_type": "group",
|
||||
},
|
||||
"topic_a": {
|
||||
"origin": {
|
||||
"platform": "telegram",
|
||||
"chat_id": "-1001",
|
||||
"chat_name": "Coaching Chat",
|
||||
"thread_id": "17585",
|
||||
},
|
||||
"chat_type": "group",
|
||||
},
|
||||
"topic_b": {
|
||||
"origin": {
|
||||
"platform": "telegram",
|
||||
"chat_id": "-1001",
|
||||
"chat_name": "Coaching Chat",
|
||||
"thread_id": "17587",
|
||||
},
|
||||
"chat_type": "group",
|
||||
},
|
||||
})
|
||||
|
||||
with patch.object(Path, "home", return_value=tmp_path):
|
||||
entries = _build_from_sessions("telegram")
|
||||
|
||||
ids = {entry["id"] for entry in entries}
|
||||
names = {entry["name"] for entry in entries}
|
||||
assert ids == {"-1001", "-1001:17585", "-1001:17587"}
|
||||
assert "Coaching Chat" in names
|
||||
assert "Coaching Chat / topic 17585" in names
|
||||
assert "Coaching Chat / topic 17587" in names
|
||||
|
||||
|
||||
class TestFormatDirectoryForDisplay:
|
||||
def test_empty_directory(self, tmp_path):
|
||||
|
|
@ -181,6 +224,7 @@ class TestFormatDirectoryForDisplay:
|
|||
"telegram": [
|
||||
{"id": "123", "name": "Alice", "type": "dm"},
|
||||
{"id": "456", "name": "Dev Group", "type": "group"},
|
||||
{"id": "-1001:17585", "name": "Coaching Chat / topic 17585", "type": "group"},
|
||||
]
|
||||
})
|
||||
with patch("gateway.channel_directory.DIRECTORY_PATH", cache_file):
|
||||
|
|
@ -189,6 +233,7 @@ class TestFormatDirectoryForDisplay:
|
|||
assert "Telegram:" in result
|
||||
assert "telegram:Alice" in result
|
||||
assert "telegram:Dev Group" in result
|
||||
assert "telegram:Coaching Chat / topic 17585" in result
|
||||
|
||||
def test_discord_grouped_by_guild(self, tmp_path):
|
||||
cache_file = _write_directory(tmp_path, {
|
||||
|
|
|
|||
|
|
@ -24,10 +24,11 @@ class TestParseTargetPlatformChat:
|
|||
assert target.chat_id is None
|
||||
|
||||
def test_origin_with_source(self):
|
||||
origin = SessionSource(platform=Platform.TELEGRAM, chat_id="789")
|
||||
origin = SessionSource(platform=Platform.TELEGRAM, chat_id="789", thread_id="42")
|
||||
target = DeliveryTarget.parse("origin", origin=origin)
|
||||
assert target.platform == Platform.TELEGRAM
|
||||
assert target.chat_id == "789"
|
||||
assert target.thread_id == "42"
|
||||
assert target.is_origin is True
|
||||
|
||||
def test_origin_without_source(self):
|
||||
|
|
@ -64,7 +65,7 @@ class TestParseDeliverSpec:
|
|||
|
||||
class TestTargetToStringRoundtrip:
|
||||
def test_origin_roundtrip(self):
|
||||
origin = SessionSource(platform=Platform.TELEGRAM, chat_id="111")
|
||||
origin = SessionSource(platform=Platform.TELEGRAM, chat_id="111", thread_id="42")
|
||||
target = DeliveryTarget.parse("origin", origin=origin)
|
||||
assert target.to_string() == "origin"
|
||||
|
||||
|
|
|
|||
117
tests/gateway/test_discord_bot_filter.py
Normal file
117
tests/gateway/test_discord_bot_filter.py
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
"""Tests for Discord bot message filtering (DISCORD_ALLOW_BOTS)."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import unittest
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
|
||||
def _make_author(*, bot: bool = False, is_self: bool = False):
|
||||
"""Create a mock Discord author."""
|
||||
author = MagicMock()
|
||||
author.bot = bot
|
||||
author.id = 99999 if is_self else 12345
|
||||
author.name = "TestBot" if bot else "TestUser"
|
||||
author.display_name = author.name
|
||||
return author
|
||||
|
||||
|
||||
def _make_message(*, author=None, content="hello", mentions=None, is_dm=False):
|
||||
"""Create a mock Discord message."""
|
||||
msg = MagicMock()
|
||||
msg.author = author or _make_author()
|
||||
msg.content = content
|
||||
msg.attachments = []
|
||||
msg.mentions = mentions or []
|
||||
if is_dm:
|
||||
import discord
|
||||
msg.channel = MagicMock(spec=discord.DMChannel)
|
||||
msg.channel.id = 111
|
||||
else:
|
||||
msg.channel = MagicMock()
|
||||
msg.channel.id = 222
|
||||
msg.channel.name = "test-channel"
|
||||
msg.channel.guild = MagicMock()
|
||||
msg.channel.guild.name = "TestServer"
|
||||
# Make isinstance checks fail for DMChannel and Thread
|
||||
type(msg.channel).__name__ = "TextChannel"
|
||||
return msg
|
||||
|
||||
|
||||
class TestDiscordBotFilter(unittest.TestCase):
|
||||
"""Test the DISCORD_ALLOW_BOTS filtering logic."""
|
||||
|
||||
def _run_filter(self, message, allow_bots="none", client_user=None):
|
||||
"""Simulate the on_message filter logic and return whether message was accepted."""
|
||||
# Replicate the exact filter logic from discord.py on_message
|
||||
if message.author == client_user:
|
||||
return False # own messages always ignored
|
||||
|
||||
if getattr(message.author, "bot", False):
|
||||
allow = allow_bots.lower().strip()
|
||||
if allow == "none":
|
||||
return False
|
||||
elif allow == "mentions":
|
||||
if not client_user or client_user not in message.mentions:
|
||||
return False
|
||||
# "all" falls through
|
||||
|
||||
return True # message accepted
|
||||
|
||||
def test_own_messages_always_ignored(self):
|
||||
"""Bot's own messages are always ignored regardless of allow_bots."""
|
||||
bot_user = _make_author(is_self=True)
|
||||
msg = _make_message(author=bot_user)
|
||||
self.assertFalse(self._run_filter(msg, "all", bot_user))
|
||||
|
||||
def test_human_messages_always_accepted(self):
|
||||
"""Human messages are always accepted regardless of allow_bots."""
|
||||
human = _make_author(bot=False)
|
||||
msg = _make_message(author=human)
|
||||
self.assertTrue(self._run_filter(msg, "none"))
|
||||
self.assertTrue(self._run_filter(msg, "mentions"))
|
||||
self.assertTrue(self._run_filter(msg, "all"))
|
||||
|
||||
def test_allow_bots_none_rejects_bots(self):
|
||||
"""With allow_bots=none, all other bot messages are rejected."""
|
||||
bot = _make_author(bot=True)
|
||||
msg = _make_message(author=bot)
|
||||
self.assertFalse(self._run_filter(msg, "none"))
|
||||
|
||||
def test_allow_bots_all_accepts_bots(self):
|
||||
"""With allow_bots=all, all bot messages are accepted."""
|
||||
bot = _make_author(bot=True)
|
||||
msg = _make_message(author=bot)
|
||||
self.assertTrue(self._run_filter(msg, "all"))
|
||||
|
||||
def test_allow_bots_mentions_rejects_without_mention(self):
|
||||
"""With allow_bots=mentions, bot messages without @mention are rejected."""
|
||||
our_user = _make_author(is_self=True)
|
||||
bot = _make_author(bot=True)
|
||||
msg = _make_message(author=bot, mentions=[])
|
||||
self.assertFalse(self._run_filter(msg, "mentions", our_user))
|
||||
|
||||
def test_allow_bots_mentions_accepts_with_mention(self):
|
||||
"""With allow_bots=mentions, bot messages with @mention are accepted."""
|
||||
our_user = _make_author(is_self=True)
|
||||
bot = _make_author(bot=True)
|
||||
msg = _make_message(author=bot, mentions=[our_user])
|
||||
self.assertTrue(self._run_filter(msg, "mentions", our_user))
|
||||
|
||||
def test_default_is_none(self):
|
||||
"""Default behavior (no env var) should be 'none'."""
|
||||
default = os.getenv("DISCORD_ALLOW_BOTS", "none")
|
||||
self.assertEqual(default, "none")
|
||||
|
||||
def test_case_insensitive(self):
|
||||
"""Allow_bots value should be case-insensitive."""
|
||||
bot = _make_author(bot=True)
|
||||
msg = _make_message(author=bot)
|
||||
self.assertTrue(self._run_filter(msg, "ALL"))
|
||||
self.assertTrue(self._run_filter(msg, "All"))
|
||||
self.assertFalse(self._run_filter(msg, "NONE"))
|
||||
self.assertFalse(self._run_filter(msg, "None"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
1034
tests/gateway/test_email.py
Normal file
1034
tests/gateway/test_email.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -57,6 +57,26 @@ class TestFindSessionId:
|
|||
|
||||
assert result == "sess_new"
|
||||
|
||||
def test_thread_id_disambiguates_same_chat(self, tmp_path):
|
||||
sessions_dir, index_file = _setup_sessions(tmp_path, {
|
||||
"topic_a": {
|
||||
"session_id": "sess_topic_a",
|
||||
"origin": {"platform": "telegram", "chat_id": "-1001", "thread_id": "10"},
|
||||
"updated_at": "2026-01-01T00:00:00",
|
||||
},
|
||||
"topic_b": {
|
||||
"session_id": "sess_topic_b",
|
||||
"origin": {"platform": "telegram", "chat_id": "-1001", "thread_id": "11"},
|
||||
"updated_at": "2026-02-01T00:00:00",
|
||||
},
|
||||
})
|
||||
|
||||
with patch.object(mirror_mod, "_SESSIONS_DIR", sessions_dir), \
|
||||
patch.object(mirror_mod, "_SESSIONS_INDEX", index_file):
|
||||
result = _find_session_id("telegram", "-1001", thread_id="10")
|
||||
|
||||
assert result == "sess_topic_a"
|
||||
|
||||
def test_no_match_returns_none(self, tmp_path):
|
||||
sessions_dir, index_file = _setup_sessions(tmp_path, {
|
||||
"sess": {
|
||||
|
|
@ -146,6 +166,29 @@ class TestMirrorToSession:
|
|||
assert msg["mirror"] is True
|
||||
assert msg["mirror_source"] == "cli"
|
||||
|
||||
def test_successful_mirror_uses_thread_id(self, tmp_path):
|
||||
sessions_dir, index_file = _setup_sessions(tmp_path, {
|
||||
"topic_a": {
|
||||
"session_id": "sess_topic_a",
|
||||
"origin": {"platform": "telegram", "chat_id": "-1001", "thread_id": "10"},
|
||||
"updated_at": "2026-01-01T00:00:00",
|
||||
},
|
||||
"topic_b": {
|
||||
"session_id": "sess_topic_b",
|
||||
"origin": {"platform": "telegram", "chat_id": "-1001", "thread_id": "11"},
|
||||
"updated_at": "2026-02-01T00:00:00",
|
||||
},
|
||||
})
|
||||
|
||||
with patch.object(mirror_mod, "_SESSIONS_DIR", sessions_dir), \
|
||||
patch.object(mirror_mod, "_SESSIONS_INDEX", index_file), \
|
||||
patch("gateway.mirror._append_to_sqlite"):
|
||||
result = mirror_to_session("telegram", "-1001", "Hello topic!", source_label="cron", thread_id="10")
|
||||
|
||||
assert result is True
|
||||
assert (sessions_dir / "sess_topic_a.jsonl").exists()
|
||||
assert not (sessions_dir / "sess_topic_b.jsonl").exists()
|
||||
|
||||
def test_no_matching_session(self, tmp_path):
|
||||
sessions_dir, index_file = _setup_sessions(tmp_path, {})
|
||||
|
||||
|
|
|
|||
60
tests/gateway/test_retry_response.py
Normal file
60
tests/gateway/test_retry_response.py
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
"""Regression test: /retry must return the agent response, not None.
|
||||
|
||||
Before the fix in PR #441, _handle_retry_command() called
|
||||
_handle_message(retry_event) but discarded its return value with `return None`,
|
||||
so users never received the final response.
|
||||
"""
|
||||
import pytest
|
||||
from unittest.mock import AsyncMock, MagicMock
|
||||
from gateway.run import GatewayRunner
|
||||
from gateway.platforms.base import MessageEvent, MessageType
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def gateway(tmp_path):
|
||||
config = MagicMock()
|
||||
config.sessions_dir = tmp_path
|
||||
config.max_context_messages = 20
|
||||
gw = GatewayRunner.__new__(GatewayRunner)
|
||||
gw.config = config
|
||||
gw.session_store = MagicMock()
|
||||
return gw
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_retry_returns_response_not_none(gateway):
|
||||
"""_handle_retry_command must return the inner handler response, not None."""
|
||||
gateway.session_store.get_or_create_session.return_value = MagicMock(
|
||||
session_id="test-session"
|
||||
)
|
||||
gateway.session_store.load_transcript.return_value = [
|
||||
{"role": "user", "content": "Hello Hermes"},
|
||||
{"role": "assistant", "content": "Hi there!"},
|
||||
]
|
||||
gateway.session_store.rewrite_transcript = MagicMock()
|
||||
expected_response = "Hi there! (retried)"
|
||||
gateway._handle_message = AsyncMock(return_value=expected_response)
|
||||
event = MessageEvent(
|
||||
text="/retry",
|
||||
message_type=MessageType.TEXT,
|
||||
source=MagicMock(),
|
||||
)
|
||||
result = await gateway._handle_retry_command(event)
|
||||
assert result is not None, "/retry must not return None"
|
||||
assert result == expected_response
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_retry_no_previous_message(gateway):
|
||||
"""If there is no previous user message, return early with a message."""
|
||||
gateway.session_store.get_or_create_session.return_value = MagicMock(
|
||||
session_id="test-session"
|
||||
)
|
||||
gateway.session_store.load_transcript.return_value = []
|
||||
event = MessageEvent(
|
||||
text="/retry",
|
||||
message_type=MessageType.TEXT,
|
||||
source=MagicMock(),
|
||||
)
|
||||
result = await gateway._handle_retry_command(event)
|
||||
assert result == "No previous message to retry."
|
||||
134
tests/gateway/test_run_progress_topics.py
Normal file
134
tests/gateway/test_run_progress_topics.py
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
"""Tests for topic-aware gateway progress updates."""
|
||||
|
||||
import importlib
|
||||
import sys
|
||||
import time
|
||||
import types
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from gateway.config import Platform, PlatformConfig
|
||||
from gateway.platforms.base import BasePlatformAdapter, SendResult
|
||||
from gateway.session import SessionSource
|
||||
|
||||
|
||||
class ProgressCaptureAdapter(BasePlatformAdapter):
|
||||
def __init__(self):
|
||||
super().__init__(PlatformConfig(enabled=True, token="fake-token"), Platform.TELEGRAM)
|
||||
self.sent = []
|
||||
self.edits = []
|
||||
self.typing = []
|
||||
|
||||
async def connect(self) -> bool:
|
||||
return True
|
||||
|
||||
async def disconnect(self) -> None:
|
||||
return None
|
||||
|
||||
async def send(self, chat_id, content, reply_to=None, metadata=None) -> SendResult:
|
||||
self.sent.append(
|
||||
{
|
||||
"chat_id": chat_id,
|
||||
"content": content,
|
||||
"reply_to": reply_to,
|
||||
"metadata": metadata,
|
||||
}
|
||||
)
|
||||
return SendResult(success=True, message_id="progress-1")
|
||||
|
||||
async def edit_message(self, chat_id, message_id, content) -> SendResult:
|
||||
self.edits.append(
|
||||
{
|
||||
"chat_id": chat_id,
|
||||
"message_id": message_id,
|
||||
"content": content,
|
||||
}
|
||||
)
|
||||
return SendResult(success=True, message_id=message_id)
|
||||
|
||||
async def send_typing(self, chat_id, metadata=None) -> None:
|
||||
self.typing.append({"chat_id": chat_id, "metadata": metadata})
|
||||
|
||||
async def get_chat_info(self, chat_id: str):
|
||||
return {"id": chat_id}
|
||||
|
||||
|
||||
class FakeAgent:
|
||||
def __init__(self, **kwargs):
|
||||
self.tool_progress_callback = kwargs["tool_progress_callback"]
|
||||
self.tools = []
|
||||
|
||||
def run_conversation(self, message, conversation_history=None, task_id=None):
|
||||
self.tool_progress_callback("terminal", "pwd")
|
||||
time.sleep(0.35)
|
||||
self.tool_progress_callback("browser_navigate", "https://example.com")
|
||||
time.sleep(0.35)
|
||||
return {
|
||||
"final_response": "done",
|
||||
"messages": [],
|
||||
"api_calls": 1,
|
||||
}
|
||||
|
||||
|
||||
def _make_runner(adapter):
|
||||
gateway_run = importlib.import_module("gateway.run")
|
||||
GatewayRunner = gateway_run.GatewayRunner
|
||||
|
||||
runner = object.__new__(GatewayRunner)
|
||||
runner.adapters = {Platform.TELEGRAM: adapter}
|
||||
runner._prefill_messages = []
|
||||
runner._ephemeral_system_prompt = ""
|
||||
runner._reasoning_config = None
|
||||
runner._provider_routing = {}
|
||||
runner._fallback_model = None
|
||||
runner._session_db = None
|
||||
runner._running_agents = {}
|
||||
runner.hooks = SimpleNamespace(loaded_hooks=False)
|
||||
return runner
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_agent_progress_stays_in_originating_topic(monkeypatch, tmp_path):
|
||||
monkeypatch.setenv("HERMES_TOOL_PROGRESS_MODE", "all")
|
||||
|
||||
fake_dotenv = types.ModuleType("dotenv")
|
||||
fake_dotenv.load_dotenv = lambda *args, **kwargs: None
|
||||
monkeypatch.setitem(sys.modules, "dotenv", fake_dotenv)
|
||||
|
||||
fake_run_agent = types.ModuleType("run_agent")
|
||||
fake_run_agent.AIAgent = FakeAgent
|
||||
monkeypatch.setitem(sys.modules, "run_agent", fake_run_agent)
|
||||
|
||||
adapter = ProgressCaptureAdapter()
|
||||
runner = _make_runner(adapter)
|
||||
gateway_run = importlib.import_module("gateway.run")
|
||||
monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
|
||||
monkeypatch.setattr(gateway_run, "_resolve_runtime_agent_kwargs", lambda: {"api_key": "fake"})
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
chat_id="-1001",
|
||||
chat_type="group",
|
||||
thread_id="17585",
|
||||
)
|
||||
|
||||
result = await runner._run_agent(
|
||||
message="hello",
|
||||
context_prompt="",
|
||||
history=[],
|
||||
source=source,
|
||||
session_id="sess-1",
|
||||
session_key="agent:main:telegram:group:-1001:17585",
|
||||
)
|
||||
|
||||
assert result["final_response"] == "done"
|
||||
assert adapter.sent == [
|
||||
{
|
||||
"chat_id": "-1001",
|
||||
"content": '💻 terminal: "pwd"',
|
||||
"reply_to": None,
|
||||
"metadata": {"thread_id": "17585"},
|
||||
}
|
||||
]
|
||||
assert adapter.edits
|
||||
assert all(call["metadata"] == {"thread_id": "17585"} for call in adapter.typing)
|
||||
|
|
@ -368,6 +368,17 @@ class TestWhatsAppDMSessionKeyConsistency:
|
|||
key = build_session_key(source)
|
||||
assert key == "agent:main:discord:group:guild-123"
|
||||
|
||||
def test_group_thread_includes_thread_id(self):
|
||||
"""Forum-style threads need a distinct session key within one group."""
|
||||
source = SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
chat_id="-1002285219667",
|
||||
chat_type="group",
|
||||
thread_id="17585",
|
||||
)
|
||||
key = build_session_key(source)
|
||||
assert key == "agent:main:telegram:group:-1002285219667:17585"
|
||||
|
||||
|
||||
class TestSessionStoreEntriesAttribute:
|
||||
"""Regression: /reset must access _entries, not _sessions."""
|
||||
|
|
@ -429,3 +440,119 @@ class TestHasAnySessions:
|
|||
|
||||
store._entries = {"key1": MagicMock()}
|
||||
assert store.has_any_sessions() is False
|
||||
|
||||
|
||||
class TestLastPromptTokens:
|
||||
"""Tests for the last_prompt_tokens field — actual API token tracking."""
|
||||
|
||||
def test_session_entry_default(self):
|
||||
"""New sessions should have last_prompt_tokens=0."""
|
||||
from gateway.session import SessionEntry
|
||||
from datetime import datetime
|
||||
entry = SessionEntry(
|
||||
session_key="test",
|
||||
session_id="s1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
)
|
||||
assert entry.last_prompt_tokens == 0
|
||||
|
||||
def test_session_entry_roundtrip(self):
|
||||
"""last_prompt_tokens should survive serialization/deserialization."""
|
||||
from gateway.session import SessionEntry
|
||||
from datetime import datetime
|
||||
entry = SessionEntry(
|
||||
session_key="test",
|
||||
session_id="s1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
last_prompt_tokens=42000,
|
||||
)
|
||||
d = entry.to_dict()
|
||||
assert d["last_prompt_tokens"] == 42000
|
||||
restored = SessionEntry.from_dict(d)
|
||||
assert restored.last_prompt_tokens == 42000
|
||||
|
||||
def test_session_entry_from_old_data(self):
|
||||
"""Old session data without last_prompt_tokens should default to 0."""
|
||||
from gateway.session import SessionEntry
|
||||
data = {
|
||||
"session_key": "test",
|
||||
"session_id": "s1",
|
||||
"created_at": "2025-01-01T00:00:00",
|
||||
"updated_at": "2025-01-01T00:00:00",
|
||||
"input_tokens": 100,
|
||||
"output_tokens": 50,
|
||||
"total_tokens": 150,
|
||||
# No last_prompt_tokens — old format
|
||||
}
|
||||
entry = SessionEntry.from_dict(data)
|
||||
assert entry.last_prompt_tokens == 0
|
||||
|
||||
def test_update_session_sets_last_prompt_tokens(self, tmp_path):
|
||||
"""update_session should store the actual prompt token count."""
|
||||
config = GatewayConfig()
|
||||
with patch("gateway.session.SessionStore._ensure_loaded"):
|
||||
store = SessionStore(sessions_dir=tmp_path, config=config)
|
||||
store._loaded = True
|
||||
store._db = None
|
||||
store._save = MagicMock()
|
||||
|
||||
from gateway.session import SessionEntry
|
||||
from datetime import datetime
|
||||
entry = SessionEntry(
|
||||
session_key="k1",
|
||||
session_id="s1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
)
|
||||
store._entries = {"k1": entry}
|
||||
|
||||
store.update_session("k1", last_prompt_tokens=85000)
|
||||
assert entry.last_prompt_tokens == 85000
|
||||
|
||||
def test_update_session_none_does_not_change(self, tmp_path):
|
||||
"""update_session with default (None) should not change last_prompt_tokens."""
|
||||
config = GatewayConfig()
|
||||
with patch("gateway.session.SessionStore._ensure_loaded"):
|
||||
store = SessionStore(sessions_dir=tmp_path, config=config)
|
||||
store._loaded = True
|
||||
store._db = None
|
||||
store._save = MagicMock()
|
||||
|
||||
from gateway.session import SessionEntry
|
||||
from datetime import datetime
|
||||
entry = SessionEntry(
|
||||
session_key="k1",
|
||||
session_id="s1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
last_prompt_tokens=50000,
|
||||
)
|
||||
store._entries = {"k1": entry}
|
||||
|
||||
store.update_session("k1") # No last_prompt_tokens arg
|
||||
assert entry.last_prompt_tokens == 50000 # unchanged
|
||||
|
||||
def test_update_session_zero_resets(self, tmp_path):
|
||||
"""update_session with last_prompt_tokens=0 should reset the field."""
|
||||
config = GatewayConfig()
|
||||
with patch("gateway.session.SessionStore._ensure_loaded"):
|
||||
store = SessionStore(sessions_dir=tmp_path, config=config)
|
||||
store._loaded = True
|
||||
store._db = None
|
||||
store._save = MagicMock()
|
||||
|
||||
from gateway.session import SessionEntry
|
||||
from datetime import datetime
|
||||
entry = SessionEntry(
|
||||
session_key="k1",
|
||||
session_id="s1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
last_prompt_tokens=85000,
|
||||
)
|
||||
store._entries = {"k1": entry}
|
||||
|
||||
store.update_session("k1", last_prompt_tokens=0)
|
||||
assert entry.last_prompt_tokens == 0
|
||||
|
|
|
|||
|
|
@ -8,9 +8,19 @@ The hygiene system uses the SAME compression config as the agent:
|
|||
so CLI and messaging platforms behave identically.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
import importlib
|
||||
import sys
|
||||
import types
|
||||
from datetime import datetime
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import patch, MagicMock, AsyncMock
|
||||
|
||||
import pytest
|
||||
|
||||
from agent.model_metadata import estimate_messages_tokens_rough
|
||||
from gateway.config import GatewayConfig, Platform, PlatformConfig
|
||||
from gateway.platforms.base import BasePlatformAdapter, MessageEvent, SendResult
|
||||
from gateway.session import SessionEntry, SessionSource
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
|
@ -41,6 +51,32 @@ def _make_large_history_tokens(target_tokens: int) -> list:
|
|||
return _make_history(n_msgs, content_size=content_size)
|
||||
|
||||
|
||||
class HygieneCaptureAdapter(BasePlatformAdapter):
|
||||
def __init__(self):
|
||||
super().__init__(PlatformConfig(enabled=True, token="fake-token"), Platform.TELEGRAM)
|
||||
self.sent = []
|
||||
|
||||
async def connect(self) -> bool:
|
||||
return True
|
||||
|
||||
async def disconnect(self) -> None:
|
||||
return None
|
||||
|
||||
async def send(self, chat_id, content, reply_to=None, metadata=None) -> SendResult:
|
||||
self.sent.append(
|
||||
{
|
||||
"chat_id": chat_id,
|
||||
"content": content,
|
||||
"reply_to": reply_to,
|
||||
"metadata": metadata,
|
||||
}
|
||||
)
|
||||
return SendResult(success=True, message_id="hygiene-1")
|
||||
|
||||
async def get_chat_info(self, chat_id: str):
|
||||
return {"id": chat_id}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Detection threshold tests (model-aware, unified with compression config)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
|
@ -202,3 +238,90 @@ class TestTokenEstimation:
|
|||
# Should be well above the 170K threshold for a 200k model
|
||||
threshold = int(200_000 * 0.85)
|
||||
assert tokens > threshold
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_session_hygiene_messages_stay_in_originating_topic(monkeypatch, tmp_path):
|
||||
fake_dotenv = types.ModuleType("dotenv")
|
||||
fake_dotenv.load_dotenv = lambda *args, **kwargs: None
|
||||
monkeypatch.setitem(sys.modules, "dotenv", fake_dotenv)
|
||||
|
||||
class FakeCompressAgent:
|
||||
def __init__(self, **kwargs):
|
||||
self.model = kwargs.get("model")
|
||||
|
||||
def _compress_context(self, messages, *_args, **_kwargs):
|
||||
return ([{"role": "assistant", "content": "compressed"}], None)
|
||||
|
||||
fake_run_agent = types.ModuleType("run_agent")
|
||||
fake_run_agent.AIAgent = FakeCompressAgent
|
||||
monkeypatch.setitem(sys.modules, "run_agent", fake_run_agent)
|
||||
|
||||
gateway_run = importlib.import_module("gateway.run")
|
||||
GatewayRunner = gateway_run.GatewayRunner
|
||||
|
||||
adapter = HygieneCaptureAdapter()
|
||||
runner = object.__new__(GatewayRunner)
|
||||
runner.config = GatewayConfig(
|
||||
platforms={Platform.TELEGRAM: PlatformConfig(enabled=True, token="fake-token")}
|
||||
)
|
||||
runner.adapters = {Platform.TELEGRAM: adapter}
|
||||
runner.hooks = SimpleNamespace(emit=AsyncMock(), loaded_hooks=False)
|
||||
runner.session_store = MagicMock()
|
||||
runner.session_store.get_or_create_session.return_value = SessionEntry(
|
||||
session_key="agent:main:telegram:group:-1001:17585",
|
||||
session_id="sess-1",
|
||||
created_at=datetime.now(),
|
||||
updated_at=datetime.now(),
|
||||
platform=Platform.TELEGRAM,
|
||||
chat_type="group",
|
||||
)
|
||||
runner.session_store.load_transcript.return_value = _make_history(6, content_size=400)
|
||||
runner.session_store.has_any_sessions.return_value = True
|
||||
runner.session_store.rewrite_transcript = MagicMock()
|
||||
runner.session_store.append_to_transcript = MagicMock()
|
||||
runner._running_agents = {}
|
||||
runner._pending_messages = {}
|
||||
runner._pending_approvals = {}
|
||||
runner._session_db = None
|
||||
runner._is_user_authorized = lambda _source: True
|
||||
runner._set_session_env = lambda _context: None
|
||||
runner._run_agent = AsyncMock(
|
||||
return_value={
|
||||
"final_response": "ok",
|
||||
"messages": [],
|
||||
"tools": [],
|
||||
"history_offset": 0,
|
||||
"last_prompt_tokens": 0,
|
||||
}
|
||||
)
|
||||
|
||||
monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
|
||||
monkeypatch.setattr(gateway_run, "_resolve_runtime_agent_kwargs", lambda: {"api_key": "fake"})
|
||||
monkeypatch.setattr(
|
||||
"agent.model_metadata.get_model_context_length",
|
||||
lambda *_args, **_kwargs: 100,
|
||||
)
|
||||
monkeypatch.setenv("TELEGRAM_HOME_CHANNEL", "795544298")
|
||||
|
||||
event = MessageEvent(
|
||||
text="hello",
|
||||
source=SessionSource(
|
||||
platform=Platform.TELEGRAM,
|
||||
chat_id="-1001",
|
||||
chat_type="group",
|
||||
thread_id="17585",
|
||||
),
|
||||
message_id="1",
|
||||
)
|
||||
|
||||
result = await runner._handle_message(event)
|
||||
|
||||
assert result == "ok"
|
||||
assert len(adapter.sent) == 2
|
||||
assert adapter.sent[0]["chat_id"] == "-1001"
|
||||
assert "Session is large" in adapter.sent[0]["content"]
|
||||
assert adapter.sent[0]["metadata"] == {"thread_id": "17585"}
|
||||
assert adapter.sent[1]["chat_id"] == "-1001"
|
||||
assert "Compressed:" in adapter.sent[1]["content"]
|
||||
assert adapter.sent[1]["metadata"] == {"thread_id": "17585"}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ from gateway.config import Platform, PlatformConfig
|
|||
from gateway.platforms.base import (
|
||||
MessageEvent,
|
||||
MessageType,
|
||||
SendResult,
|
||||
SUPPORTED_DOCUMENT_TYPES,
|
||||
)
|
||||
|
||||
|
|
@ -336,3 +337,203 @@ class TestDocumentDownloadBlock:
|
|||
await adapter._handle_media_message(update, MagicMock())
|
||||
# handle_message should still be called (the handler catches the exception)
|
||||
adapter.handle_message.assert_called_once()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestSendDocument — outbound file attachment delivery
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSendDocument:
|
||||
"""Tests for TelegramAdapter.send_document() — sending files to users."""
|
||||
|
||||
@pytest.fixture()
|
||||
def connected_adapter(self, adapter):
|
||||
"""Adapter with a mock bot attached."""
|
||||
bot = AsyncMock()
|
||||
adapter._bot = bot
|
||||
return adapter
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_success(self, connected_adapter, tmp_path):
|
||||
"""A local file is sent via bot.send_document and returns success."""
|
||||
# Create a real temp file
|
||||
test_file = tmp_path / "report.pdf"
|
||||
test_file.write_bytes(b"%PDF-1.4 fake content")
|
||||
|
||||
mock_msg = MagicMock()
|
||||
mock_msg.message_id = 99
|
||||
connected_adapter._bot.send_document = AsyncMock(return_value=mock_msg)
|
||||
|
||||
result = await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path=str(test_file),
|
||||
caption="Here's the report",
|
||||
)
|
||||
|
||||
assert result.success is True
|
||||
assert result.message_id == "99"
|
||||
connected_adapter._bot.send_document.assert_called_once()
|
||||
call_kwargs = connected_adapter._bot.send_document.call_args[1]
|
||||
assert call_kwargs["chat_id"] == 12345
|
||||
assert call_kwargs["filename"] == "report.pdf"
|
||||
assert call_kwargs["caption"] == "Here's the report"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_custom_filename(self, connected_adapter, tmp_path):
|
||||
"""The file_name parameter overrides the basename for display."""
|
||||
test_file = tmp_path / "doc_abc123_ugly.csv"
|
||||
test_file.write_bytes(b"a,b,c\n1,2,3")
|
||||
|
||||
mock_msg = MagicMock()
|
||||
mock_msg.message_id = 100
|
||||
connected_adapter._bot.send_document = AsyncMock(return_value=mock_msg)
|
||||
|
||||
result = await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path=str(test_file),
|
||||
file_name="clean_data.csv",
|
||||
)
|
||||
|
||||
assert result.success is True
|
||||
call_kwargs = connected_adapter._bot.send_document.call_args[1]
|
||||
assert call_kwargs["filename"] == "clean_data.csv"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_file_not_found(self, connected_adapter):
|
||||
"""Missing file returns error without calling Telegram API."""
|
||||
result = await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path="/nonexistent/file.pdf",
|
||||
)
|
||||
|
||||
assert result.success is False
|
||||
assert "not found" in result.error.lower()
|
||||
connected_adapter._bot.send_document.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_not_connected(self, adapter):
|
||||
"""If bot is None, returns not connected error."""
|
||||
result = await adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path="/some/file.pdf",
|
||||
)
|
||||
|
||||
assert result.success is False
|
||||
assert "Not connected" in result.error
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_caption_truncated(self, connected_adapter, tmp_path):
|
||||
"""Captions longer than 1024 chars are truncated."""
|
||||
test_file = tmp_path / "data.json"
|
||||
test_file.write_bytes(b"{}")
|
||||
|
||||
mock_msg = MagicMock()
|
||||
mock_msg.message_id = 101
|
||||
connected_adapter._bot.send_document = AsyncMock(return_value=mock_msg)
|
||||
|
||||
long_caption = "x" * 2000
|
||||
await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path=str(test_file),
|
||||
caption=long_caption,
|
||||
)
|
||||
|
||||
call_kwargs = connected_adapter._bot.send_document.call_args[1]
|
||||
assert len(call_kwargs["caption"]) == 1024
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_api_error_falls_back(self, connected_adapter, tmp_path):
|
||||
"""If Telegram API raises, falls back to base class text message."""
|
||||
test_file = tmp_path / "file.pdf"
|
||||
test_file.write_bytes(b"data")
|
||||
|
||||
connected_adapter._bot.send_document = AsyncMock(
|
||||
side_effect=RuntimeError("Telegram API error")
|
||||
)
|
||||
|
||||
# The base fallback calls self.send() which is also on _bot, so mock it
|
||||
# to avoid cascading errors.
|
||||
connected_adapter.send = AsyncMock(
|
||||
return_value=SendResult(success=True, message_id="fallback")
|
||||
)
|
||||
|
||||
result = await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path=str(test_file),
|
||||
)
|
||||
|
||||
# Should have fallen back to base class
|
||||
assert result.success is True
|
||||
assert result.message_id == "fallback"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_document_reply_to(self, connected_adapter, tmp_path):
|
||||
"""reply_to parameter is forwarded as reply_to_message_id."""
|
||||
test_file = tmp_path / "spec.md"
|
||||
test_file.write_bytes(b"# Spec")
|
||||
|
||||
mock_msg = MagicMock()
|
||||
mock_msg.message_id = 102
|
||||
connected_adapter._bot.send_document = AsyncMock(return_value=mock_msg)
|
||||
|
||||
await connected_adapter.send_document(
|
||||
chat_id="12345",
|
||||
file_path=str(test_file),
|
||||
reply_to="50",
|
||||
)
|
||||
|
||||
call_kwargs = connected_adapter._bot.send_document.call_args[1]
|
||||
assert call_kwargs["reply_to_message_id"] == 50
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestSendVideo — outbound video delivery
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSendVideo:
|
||||
"""Tests for TelegramAdapter.send_video() — sending videos to users."""
|
||||
|
||||
@pytest.fixture()
|
||||
def connected_adapter(self, adapter):
|
||||
bot = AsyncMock()
|
||||
adapter._bot = bot
|
||||
return adapter
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_video_success(self, connected_adapter, tmp_path):
|
||||
test_file = tmp_path / "clip.mp4"
|
||||
test_file.write_bytes(b"\x00\x00\x00\x1c" + b"ftyp" + b"\x00" * 100)
|
||||
|
||||
mock_msg = MagicMock()
|
||||
mock_msg.message_id = 200
|
||||
connected_adapter._bot.send_video = AsyncMock(return_value=mock_msg)
|
||||
|
||||
result = await connected_adapter.send_video(
|
||||
chat_id="12345",
|
||||
video_path=str(test_file),
|
||||
caption="Check this out",
|
||||
)
|
||||
|
||||
assert result.success is True
|
||||
assert result.message_id == "200"
|
||||
connected_adapter._bot.send_video.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_video_file_not_found(self, connected_adapter):
|
||||
result = await connected_adapter.send_video(
|
||||
chat_id="12345",
|
||||
video_path="/nonexistent/video.mp4",
|
||||
)
|
||||
|
||||
assert result.success is False
|
||||
assert "not found" in result.error.lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_send_video_not_connected(self, adapter):
|
||||
result = await adapter.send_video(
|
||||
chat_id="12345",
|
||||
video_path="/some/video.mp4",
|
||||
)
|
||||
|
||||
assert result.success is False
|
||||
assert "Not connected" in result.error
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue