_send_via_adapter's standalone fallback read the platform registry without running plugin discovery. BlueBubbles left the dedicated routes in this branch and falls through to it, so a direct _send_to_platform from a fresh process returned "No live adapter for platform 'bluebubbles'" where main reached the sender. The shipped entry points (the tool, cron) discover first, so this was latent. The fallback now uses _plugin_standalone_sender, which discovers (idempotent). Live: fresh-process send against a fake BlueBubbles server, 0 sends before, 1 after. Also point ADDING_A_PLATFORM.md at the plugin paths of the Telegram and Discord reference adapters. Found by @unsupportedpastels' review of this PR.
1693 lines
66 KiB
Python
1693 lines
66 KiB
Python
"""Tests for tools/send_message_tool.py."""
|
|
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import sys
|
|
from types import ModuleType, SimpleNamespace
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
# python-telegram-bot is an optional dep — skip the entire module when
|
|
# it isn't installed (e.g. CI bare env). Tests that patch telegram.Bot
|
|
# or call _send_telegram need it; tests for other platforms don't but
|
|
# keeping the whole file consistent is simpler.
|
|
_HAS_TELEGRAM = pytest.importorskip("telegram", reason="python-telegram-bot not installed") is not None
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _reset_signal_scheduler():
|
|
"""Drop the process-wide attachment scheduler so each test gets a
|
|
fresh token bucket."""
|
|
from plugins.platforms.signal.signal_rate_limit import _reset_scheduler
|
|
_reset_scheduler()
|
|
yield
|
|
_reset_scheduler()
|
|
|
|
from gateway.config import Platform
|
|
from tools.send_message_tool import (
|
|
_resolve_slack_user_target,
|
|
_send_matrix_via_adapter,
|
|
_send_telegram,
|
|
_send_to_platform,
|
|
send_message_tool,
|
|
)
|
|
from tools.send_message_targets import _parse_target_ref
|
|
from plugins.platforms.signal.standalone import _send_signal
|
|
# Discord helpers moved to the plugin in #24325. Import from the new path
|
|
# and provide a thin ``_send_discord(token, ...)`` shim that mirrors the
|
|
# pre-migration signature so the existing test bodies keep working.
|
|
from plugins.platforms.discord.adapter import (
|
|
_DISCORD_STANDALONE_JSON_BODY_LIMIT_BYTES,
|
|
_derive_forum_thread_name,
|
|
_standalone_send,
|
|
)
|
|
|
|
|
|
async def _send_discord(
|
|
token,
|
|
chat_id,
|
|
message,
|
|
*,
|
|
thread_id=None,
|
|
media_files=None,
|
|
):
|
|
"""Pre-migration ``(token, chat_id, message, …)`` adapter around the
|
|
plugin's ``_standalone_send(pconfig, …)``. Lets test bodies continue
|
|
to call ``_send_discord("tok", ...)`` without rewriting every signature.
|
|
"""
|
|
pconfig = SimpleNamespace(token=token, extra={})
|
|
return await _standalone_send(
|
|
pconfig,
|
|
chat_id,
|
|
message,
|
|
thread_id=thread_id,
|
|
media_files=media_files,
|
|
)
|
|
|
|
|
|
class _StreamingAiohttpContent:
|
|
def __init__(self, body: bytes):
|
|
self._body = body
|
|
self.read_sizes = []
|
|
|
|
async def read(self, size=-1):
|
|
self.read_sizes.append(size)
|
|
if not self._body:
|
|
return b""
|
|
if size is None or size < 0:
|
|
chunk = self._body
|
|
self._body = b""
|
|
return chunk
|
|
chunk = self._body[:size]
|
|
self._body = self._body[size:]
|
|
return chunk
|
|
|
|
|
|
class _StreamingAiohttpResponse:
|
|
def __init__(self, status: int, body: bytes):
|
|
self.status = status
|
|
self.content = _StreamingAiohttpContent(body)
|
|
self.closed = False
|
|
self.json = AsyncMock(side_effect=AssertionError("resp.json() should not be used"))
|
|
self.text = AsyncMock(side_effect=AssertionError("resp.text() should not be used"))
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *_args):
|
|
return None
|
|
|
|
def close(self):
|
|
self.closed = True
|
|
|
|
|
|
class _StreamingAiohttpSession:
|
|
def __init__(self, response: _StreamingAiohttpResponse):
|
|
self.response = response
|
|
self.post = MagicMock(return_value=response)
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *_args):
|
|
return None
|
|
|
|
|
|
def _discord_entry():
|
|
"""Return the live Discord PlatformEntry, importing lazily so plugin
|
|
discovery is forced exactly once and patches survive across tests."""
|
|
from hermes_cli.plugins import discover_plugins
|
|
from gateway.platform_registry import platform_registry
|
|
discover_plugins()
|
|
return platform_registry.get("discord")
|
|
|
|
|
|
class _patch_discord_sender:
|
|
"""Patch the Discord registry entry's ``standalone_sender_fn`` with the
|
|
given mock and translate the production ``(pconfig, ...)`` call shape
|
|
back to the pre-migration ``(token, ...)`` shape the test mocks expect.
|
|
|
|
Use as a context manager:
|
|
|
|
send_mock = AsyncMock(return_value={...})
|
|
with _patch_discord_sender(send_mock):
|
|
asyncio.run(_send_to_platform(Platform.DISCORD, ...))
|
|
send_mock.assert_awaited_once_with("tok", "chat", "msg",
|
|
thread_id=None, media_files=[])
|
|
"""
|
|
|
|
def __init__(self, mock):
|
|
self._mock = mock
|
|
self._entry = None
|
|
self._original = None
|
|
|
|
async def _adapter(self, pconfig, chat_id, message, *, thread_id=None, media_files=None, caption=None):
|
|
token = getattr(pconfig, "token", None)
|
|
# Only forward caption= when set, so mocks written against the
|
|
# pre-caption signature (no caption kwarg) keep working.
|
|
extra = {"caption": caption} if caption is not None else {}
|
|
return await self._mock(
|
|
token, chat_id, message,
|
|
thread_id=thread_id, media_files=media_files, **extra,
|
|
)
|
|
|
|
def __enter__(self):
|
|
self._entry = _discord_entry()
|
|
self._original = self._entry.standalone_sender_fn
|
|
self._entry.standalone_sender_fn = self._adapter
|
|
return self._mock
|
|
|
|
def __exit__(self, exc_type, exc, tb):
|
|
if self._entry is not None:
|
|
self._entry.standalone_sender_fn = self._original
|
|
return False
|
|
|
|
|
|
def _slack_entry():
|
|
"""Return the live Slack PlatformEntry, importing lazily so plugin
|
|
discovery is forced exactly once and patches survive across tests."""
|
|
from hermes_cli.plugins import discover_plugins
|
|
from gateway.platform_registry import platform_registry
|
|
discover_plugins()
|
|
return platform_registry.get("slack")
|
|
|
|
|
|
def _make_recording_slack_sender():
|
|
"""Return a plain AsyncMock used to record the formatted Slack text.
|
|
|
|
Paired with ``_patch_slack_standalone_sender``, which wraps it so the
|
|
production ``(pconfig, chat_id, raw_text, thread_id=...)`` call is
|
|
translated into the pre-migration ``(token, chat_id, formatted_text,
|
|
thread_ts=...)`` shape — applying ``SlackAdapter.format_message`` exactly
|
|
as the real plugin ``_standalone_send`` does. Tests can then assert on
|
|
``send.await_args.args[2]`` (the formatted mrkdwn) as before.
|
|
"""
|
|
return AsyncMock(return_value={"success": True, "platform": "slack", "message_id": "1"})
|
|
|
|
|
|
class _patch_slack_standalone_sender:
|
|
"""Patch the Slack registry entry's ``standalone_sender_fn`` with a wrapper
|
|
that replicates the plugin's mrkdwn formatting then delegates to the given
|
|
mock in the pre-migration call shape. Mirrors ``_patch_discord_sender``.
|
|
|
|
Slack mrkdwn formatting moved INTO the plugin's ``_standalone_send`` when
|
|
the adapter migrated (#41112) — previously ``_send_to_platform`` formatted
|
|
the message before calling the old ``_send_slack`` helper. This wrapper
|
|
keeps the "markdown → Slack mrkdwn reaches the wire" behavior tests valid.
|
|
"""
|
|
|
|
def __init__(self, mock):
|
|
self._mock = mock
|
|
self._entry = None
|
|
self._original = None
|
|
|
|
async def _adapter(self, pconfig, chat_id, message, *, thread_id=None, **_kw):
|
|
from plugins.platforms.slack.adapter import SlackAdapter
|
|
formatted = message
|
|
if message:
|
|
try:
|
|
formatted = SlackAdapter.__new__(SlackAdapter).format_message(message)
|
|
except Exception:
|
|
pass
|
|
token = getattr(pconfig, "token", None)
|
|
return await self._mock(token, chat_id, formatted, thread_ts=thread_id)
|
|
|
|
def __enter__(self):
|
|
self._entry = _slack_entry()
|
|
self._original = self._entry.standalone_sender_fn
|
|
self._entry.standalone_sender_fn = self._adapter
|
|
return self._mock
|
|
|
|
def __exit__(self, exc_type, exc, tb):
|
|
if self._entry is not None:
|
|
self._entry.standalone_sender_fn = self._original
|
|
return False
|
|
|
|
|
|
def _run_async_immediately(coro):
|
|
return asyncio.run(coro)
|
|
|
|
|
|
def _make_config():
|
|
telegram_cfg = SimpleNamespace(enabled=True, token="***", extra={})
|
|
return SimpleNamespace(
|
|
platforms={Platform.TELEGRAM: telegram_cfg},
|
|
get_home_channel=lambda _platform: None,
|
|
), telegram_cfg
|
|
|
|
|
|
def _install_telegram_mock(monkeypatch, bot):
|
|
parse_mode = SimpleNamespace(MARKDOWN_V2="MarkdownV2", HTML="HTML")
|
|
constants_mod = SimpleNamespace(ParseMode=parse_mode)
|
|
# MessageEntity needed by #27865 mention-detection path; tests don't
|
|
# inspect it but the import must succeed.
|
|
_MessageEntity = lambda **_kw: SimpleNamespace(**_kw)
|
|
telegram_mod = SimpleNamespace(Bot=lambda token: bot, MessageEntity=_MessageEntity, constants=constants_mod)
|
|
monkeypatch.setitem(sys.modules, "telegram", telegram_mod)
|
|
monkeypatch.setitem(sys.modules, "telegram.constants", constants_mod)
|
|
|
|
|
|
def _ensure_slack_mock(monkeypatch):
|
|
if "slack_bolt" in sys.modules and hasattr(sys.modules["slack_bolt"], "__file__"):
|
|
return
|
|
|
|
slack_bolt = MagicMock()
|
|
slack_bolt.async_app.AsyncApp = MagicMock
|
|
slack_bolt.adapter.socket_mode.async_handler.AsyncSocketModeHandler = MagicMock
|
|
|
|
slack_sdk = MagicMock()
|
|
slack_sdk.web.async_client.AsyncWebClient = MagicMock
|
|
|
|
for name, mod in [
|
|
("slack_bolt", slack_bolt),
|
|
("slack_bolt.async_app", slack_bolt.async_app),
|
|
("slack_bolt.adapter", slack_bolt.adapter),
|
|
("slack_bolt.adapter.socket_mode", slack_bolt.adapter.socket_mode),
|
|
("slack_bolt.adapter.socket_mode.async_handler", slack_bolt.adapter.socket_mode.async_handler),
|
|
("slack_sdk", slack_sdk),
|
|
("slack_sdk.web", slack_sdk.web),
|
|
("slack_sdk.web.async_client", slack_sdk.web.async_client),
|
|
]:
|
|
monkeypatch.setitem(sys.modules, name, mod)
|
|
|
|
|
|
class TestSendMessageTool:
|
|
def test_ntfy_topic_target_is_explicit(self):
|
|
chat_id, thread_id, is_explicit = _parse_target_ref("ntfy", "alerts-channel")
|
|
|
|
assert chat_id == "alerts-channel"
|
|
assert thread_id is None
|
|
assert is_explicit is True
|
|
|
|
def test_ntfy_topic_target_bypasses_channel_directory(self):
|
|
ntfy_platform = Platform("ntfy")
|
|
ntfy_cfg = SimpleNamespace(enabled=True, token=None, extra={"topic": "hermes-in"})
|
|
config = SimpleNamespace(
|
|
platforms={ntfy_platform: ntfy_cfg},
|
|
get_home_channel=lambda _platform: None,
|
|
)
|
|
|
|
with patch("gateway.config.load_gateway_config", return_value=config), \
|
|
patch("tools.interrupt.is_interrupted", return_value=False), \
|
|
patch("gateway.channel_directory.resolve_channel_name", side_effect=AssertionError("should not resolve ntfy topics")), \
|
|
patch("model_tools._run_async", side_effect=_run_async_immediately), \
|
|
patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
|
|
patch("gateway.mirror.mirror_to_session", return_value=True):
|
|
result = json.loads(
|
|
send_message_tool(
|
|
{
|
|
"action": "send",
|
|
"target": "ntfy:alerts-channel",
|
|
"message": "done",
|
|
}
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
send_mock.assert_awaited_once_with(
|
|
ntfy_platform,
|
|
ntfy_cfg,
|
|
"alerts-channel",
|
|
"done",
|
|
thread_id=None,
|
|
media_files=[],
|
|
force_document=False,
|
|
)
|
|
|
|
|
|
def test_media_tag_outside_allowed_roots_is_not_sent(self, tmp_path, monkeypatch):
|
|
# This test exercises the strict-allowlist path; force strict mode on
|
|
# and disable recency trust so the freshly-written tmp_path file is
|
|
# not auto-accepted by the trust window. (Recency trust is covered
|
|
# in test_platform_base.py. The public default flipped to non-strict
|
|
# in 2026-05; this test pins strict on explicitly.)
|
|
monkeypatch.setenv("HERMES_MEDIA_DELIVERY_STRICT", "1")
|
|
monkeypatch.setenv("HERMES_MEDIA_TRUST_RECENT_FILES", "0")
|
|
config, telegram_cfg = _make_config()
|
|
secret = tmp_path / "secret.pdf"
|
|
secret.write_bytes(b"%PDF secret")
|
|
|
|
with patch("gateway.config.load_gateway_config", return_value=config), \
|
|
patch("tools.interrupt.is_interrupted", return_value=False), \
|
|
patch("model_tools._run_async", side_effect=_run_async_immediately), \
|
|
patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
|
|
patch("gateway.mirror.mirror_to_session", return_value=True):
|
|
result = json.loads(
|
|
send_message_tool(
|
|
{
|
|
"action": "send",
|
|
"target": "telegram:12345",
|
|
"message": f"hello\nMEDIA:{secret}",
|
|
}
|
|
)
|
|
)
|
|
|
|
# The text still goes out without the attachment, but the caller is told (#115908).
|
|
assert result["success"] is False
|
|
assert result["partial_success"] is True
|
|
assert result["media_dropped"] == [{"path": str(secret), "reason": "denied by the delivery policy"}]
|
|
send_mock.assert_awaited_once_with(
|
|
Platform.TELEGRAM,
|
|
telegram_cfg,
|
|
"12345",
|
|
"hello",
|
|
thread_id=None,
|
|
media_files=[],
|
|
force_document=False,
|
|
)
|
|
|
|
def test_missing_media_is_reported_to_the_caller_and_hermes_send_exits_nonzero(self, tmp_path, monkeypatch):
|
|
"""#115908: a MEDIA path that does not exist on the host was dropped with only a host-side
|
|
warning while ``hermes send`` printed success:true and exited 0. The surviving attachment is
|
|
still sent; the payload names the drop and the CLI exit code follows it."""
|
|
from hermes_cli.send_cmd import _emit_result
|
|
|
|
monkeypatch.setenv("HERMES_MEDIA_DELIVERY_STRICT", "0")
|
|
config, telegram_cfg = _make_config()
|
|
report = tmp_path / "report.pdf"
|
|
report.write_bytes(b"%PDF report")
|
|
missing = tmp_path / "missing.pdf"
|
|
|
|
with patch("gateway.config.load_gateway_config", return_value=config), \
|
|
patch("tools.interrupt.is_interrupted", return_value=False), \
|
|
patch("model_tools._run_async", side_effect=_run_async_immediately), \
|
|
patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
|
|
patch("gateway.mirror.mirror_to_session", return_value=True):
|
|
raw = send_message_tool({
|
|
"action": "send",
|
|
"target": "telegram:12345",
|
|
"message": f"report\nMEDIA:{report}\nMEDIA:{missing}",
|
|
})
|
|
|
|
result = json.loads(raw)
|
|
assert result["success"] is False
|
|
assert result["partial_success"] is True
|
|
assert result["media_dropped"] == [{"path": str(missing), "reason": "not found on this host"}]
|
|
assert result["error"]
|
|
send_mock.assert_awaited_once_with(
|
|
Platform.TELEGRAM, telegram_cfg, "12345", "report", thread_id=None,
|
|
media_files=[(str(report.resolve()), False)], force_document=False,
|
|
)
|
|
assert _emit_result(raw, json_mode=True, quiet=True) != 0
|
|
|
|
def test_top_level_send_failure_redacts_query_token(self):
|
|
config, _telegram_cfg = _make_config()
|
|
leaked = "very-secret-query-token-123456"
|
|
|
|
def _raise_and_close(coro):
|
|
coro.close()
|
|
raise RuntimeError(
|
|
f"transport error: https://api.example.com/send?access_token={leaked}"
|
|
)
|
|
|
|
with patch("gateway.config.load_gateway_config", return_value=config), \
|
|
patch("tools.interrupt.is_interrupted", return_value=False), \
|
|
patch("model_tools._run_async", side_effect=_raise_and_close):
|
|
result = json.loads(
|
|
send_message_tool(
|
|
{
|
|
"action": "send",
|
|
"target": "telegram:-1001",
|
|
"message": "hello",
|
|
}
|
|
)
|
|
)
|
|
|
|
assert "error" in result
|
|
assert leaked not in result["error"]
|
|
assert "access_token=***" in result["error"]
|
|
|
|
|
|
class TestSendTelegramMediaDelivery:
|
|
def test_sends_photo_with_caption_for_media_tag(self, tmp_path, monkeypatch):
|
|
# A single captionable image + short text now rides as the photo's
|
|
# native caption (MEDIA:<path> caption), not a separate text message.
|
|
image_path = tmp_path / "photo.png"
|
|
image_path.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 32)
|
|
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock(return_value=SimpleNamespace(message_id=1))
|
|
bot.send_photo = AsyncMock(return_value=SimpleNamespace(message_id=2))
|
|
bot.send_video = AsyncMock()
|
|
bot.send_voice = AsyncMock()
|
|
bot.send_audio = AsyncMock()
|
|
bot.send_document = AsyncMock()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
result = asyncio.run(
|
|
_send_telegram(
|
|
"token",
|
|
"12345",
|
|
"Hello there",
|
|
media_files=[(str(image_path), False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["message_id"] == "2"
|
|
# No separate text send — the caption rides the photo bubble.
|
|
bot.send_message.assert_not_awaited()
|
|
bot.send_photo.assert_awaited_once()
|
|
assert bot.send_photo.await_args.kwargs.get("caption") == "Hello there"
|
|
|
|
def test_sends_voice_for_ogg_with_voice_directive(self, tmp_path, monkeypatch):
|
|
voice_path = tmp_path / "voice.ogg"
|
|
voice_path.write_bytes(b"OggS" + b"\x00" * 32)
|
|
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock()
|
|
bot.send_photo = AsyncMock()
|
|
bot.send_video = AsyncMock()
|
|
bot.send_voice = AsyncMock(return_value=SimpleNamespace(message_id=7))
|
|
bot.send_audio = AsyncMock()
|
|
bot.send_document = AsyncMock()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
result = asyncio.run(
|
|
_send_telegram(
|
|
"token",
|
|
"12345",
|
|
"",
|
|
media_files=[(str(voice_path), True)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
bot.send_voice.assert_awaited_once()
|
|
bot.send_audio.assert_not_awaited()
|
|
bot.send_message.assert_not_awaited()
|
|
|
|
def test_missing_media_returns_error_without_leaking_raw_tag(self, monkeypatch):
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock()
|
|
bot.send_photo = AsyncMock()
|
|
bot.send_video = AsyncMock()
|
|
bot.send_voice = AsyncMock()
|
|
bot.send_audio = AsyncMock()
|
|
bot.send_document = AsyncMock()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
result = asyncio.run(
|
|
_send_telegram(
|
|
"token",
|
|
"12345",
|
|
"",
|
|
media_files=[("/tmp/does-not-exist.png", False)],
|
|
)
|
|
)
|
|
|
|
assert "error" in result
|
|
bot.send_message.assert_not_awaited()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Regression: long messages are chunked before platform dispatch
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestSendToPlatformChunking:
|
|
def test_long_message_is_chunked(self):
|
|
"""Messages exceeding the platform limit are split into multiple sends."""
|
|
send = AsyncMock(return_value={"success": True, "message_id": "1"})
|
|
long_msg = "word " * 1000 # ~5000 chars, well over Discord's 2000 limit
|
|
with _patch_discord_sender(send):
|
|
result = asyncio.run(
|
|
_send_to_platform(
|
|
Platform.DISCORD,
|
|
SimpleNamespace(enabled=True, token="***", extra={}),
|
|
"ch", long_msg,
|
|
)
|
|
)
|
|
assert result["success"] is True
|
|
assert send.await_count >= 3
|
|
for call in send.await_args_list:
|
|
assert len(call.args[2]) <= 2020 # each chunk fits the limit
|
|
|
|
def test_signal_long_message_is_chunked(self, monkeypatch):
|
|
"""Standalone Signal sends split at the adapter's 8000-char limit.
|
|
|
|
The standalone path (hermes send / cron / MCP) speaks raw JSON-RPC via
|
|
_send_signal and bypasses SignalAdapter.send(), so the shared
|
|
truncate_message() pass in _send_to_platform must know Signal's limit
|
|
(regression for #67279 / #57929 — long sends were rejected whole).
|
|
"""
|
|
from plugins.platforms.signal.adapter import MAX_MESSAGE_LENGTH as SIGNAL_MAX
|
|
from hermes_cli.plugins import discover_plugins
|
|
from gateway.platform_registry import platform_registry
|
|
|
|
sent = []
|
|
|
|
async def fake_send_signal(pconfig, chat_id, chunk, *, thread_id=None, media_files=None,
|
|
force_document=False):
|
|
sent.append(chunk)
|
|
return {"success": True, "platform": "signal", "chat_id": chat_id}
|
|
|
|
discover_plugins()
|
|
monkeypatch.setattr(platform_registry.get("signal"), "standalone_sender_fn", fake_send_signal)
|
|
|
|
long_msg = "word " * ((SIGNAL_MAX // 5) + 500) # comfortably over limit
|
|
result = asyncio.run(
|
|
_send_to_platform(
|
|
Platform.SIGNAL,
|
|
SimpleNamespace(enabled=True, token=None,
|
|
extra={"http_url": "http://localhost:8080",
|
|
"account": "+15551234567"}),
|
|
"+15557654321", long_msg,
|
|
)
|
|
)
|
|
assert result["success"] is True
|
|
assert len(sent) >= 2, "long Signal message must be split, not sent whole"
|
|
assert all(len(chunk) <= SIGNAL_MAX for chunk in sent)
|
|
# No truncation footer — content is delivered in full across chunks
|
|
assert all("truncated, full output saved to" not in c for c in sent)
|
|
|
|
|
|
def test_slack_pre_escaped_entities_not_double_escaped(self, monkeypatch):
|
|
"""Pre-escaped HTML entities survive tool-layer formatting without double-escaping."""
|
|
_ensure_slack_mock(monkeypatch)
|
|
import plugins.platforms.slack.adapter as slack_mod
|
|
monkeypatch.setattr(slack_mod, "SLACK_AVAILABLE", True)
|
|
send = _make_recording_slack_sender()
|
|
with _patch_slack_standalone_sender(send):
|
|
result = asyncio.run(
|
|
_send_to_platform(
|
|
Platform.SLACK,
|
|
SimpleNamespace(enabled=True, token="***", extra={}),
|
|
"C123",
|
|
"AT&T <tag> test",
|
|
)
|
|
)
|
|
assert result["success"] is True
|
|
sent_text = send.await_args.args[2]
|
|
assert "&amp;" not in sent_text
|
|
assert "&lt;" not in sent_text
|
|
assert "AT&T" in sent_text
|
|
|
|
def test_telegram_markdown_expansion_is_chunked_before_send(self, monkeypatch):
|
|
"""Telegram chunking must account for MarkdownV2 escaping expansion.
|
|
|
|
A raw message under 4096 UTF-16 units can inflate past the limit once
|
|
MarkdownV2-escaped (each `!`/`.`/`-` becomes `\\!`/`\\.`/`\\-`). The
|
|
send path must chunk the *formatted* text so no single send exceeds
|
|
4096 (issue #28557).
|
|
"""
|
|
from gateway.platforms.base import utf16_len
|
|
|
|
send_lengths = []
|
|
|
|
async def fake_send_message(**kwargs):
|
|
text = kwargs["text"]
|
|
send_lengths.append(utf16_len(text))
|
|
if utf16_len(text) > 4096:
|
|
raise Exception("Message is too long")
|
|
return SimpleNamespace(message_id=len(send_lengths))
|
|
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock(side_effect=fake_send_message)
|
|
bot.send_photo = AsyncMock()
|
|
bot.send_video = AsyncMock()
|
|
bot.send_voice = AsyncMock()
|
|
bot.send_audio = AsyncMock()
|
|
bot.send_document = AsyncMock()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
result = asyncio.run(
|
|
_send_to_platform(
|
|
Platform.TELEGRAM,
|
|
SimpleNamespace(enabled=True, token="tok", extra={}),
|
|
"123",
|
|
"!" * 4096, # raw 4096 -> ~8192 after MarkdownV2 escaping
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert bot.send_message.await_count >= 2
|
|
assert max(send_lengths) <= 4096
|
|
|
|
|
|
|
|
class TestMatrixMediaLiveAdapterReuse:
|
|
"""Verify _send_matrix_via_adapter reuses the live gateway adapter
|
|
when available, avoiding per-message E2EE re-init storms (#46310)."""
|
|
|
|
def test_live_adapter_skips_connect_disconnect(self, tmp_path):
|
|
"""When a live gateway adapter exists, no connect() or disconnect()
|
|
should be called — the persistent E2EE session is reused."""
|
|
img_path = tmp_path / "photo.png"
|
|
img_path.write_bytes(b"\x89PNG\r\n")
|
|
|
|
calls = []
|
|
|
|
class LiveAdapter:
|
|
async def send(self, chat_id, message, metadata=None):
|
|
calls.append(("send", chat_id, message))
|
|
return SimpleNamespace(success=True, message_id="$text")
|
|
|
|
async def send_image_file(self, chat_id, path, metadata=None):
|
|
calls.append(("send_image_file", chat_id, path))
|
|
return SimpleNamespace(success=True, message_id="$img")
|
|
|
|
live_adapter = LiveAdapter()
|
|
fake_runner = SimpleNamespace(
|
|
adapters={Platform.MATRIX: live_adapter}
|
|
)
|
|
|
|
with patch(
|
|
"gateway.run._gateway_runner_ref",
|
|
return_value=fake_runner,
|
|
), patch.dict(
|
|
sys.modules, {"plugins.platforms.matrix.adapter": SimpleNamespace()}
|
|
):
|
|
result = asyncio.run(
|
|
_send_matrix_via_adapter(
|
|
SimpleNamespace(enabled=True, token="tok", extra={}),
|
|
"!room:example.com",
|
|
"here is an image",
|
|
media_files=[(str(img_path), False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["message_id"] == "$img"
|
|
# Only send + send_image_file; no connect / disconnect
|
|
assert calls == [
|
|
("send", "!room:example.com", "here is an image"),
|
|
("send_image_file", "!room:example.com", str(img_path)),
|
|
]
|
|
|
|
def test_live_adapter_not_available_falls_back_to_ephemeral(self, tmp_path):
|
|
"""When _gateway_runner_ref returns None, the ephemeral adapter
|
|
path (connect + disconnect) is used as before."""
|
|
doc_path = tmp_path / "doc.pdf"
|
|
doc_path.write_bytes(b"%PDF-1.4")
|
|
|
|
calls = []
|
|
|
|
class EphemeralAdapter:
|
|
def __init__(self, _config):
|
|
pass
|
|
|
|
async def connect(self):
|
|
calls.append(("connect",))
|
|
return True
|
|
|
|
async def send(self, chat_id, message, metadata=None):
|
|
calls.append(("send", chat_id, message))
|
|
return SimpleNamespace(success=True, message_id="$txt")
|
|
|
|
async def send_document(self, chat_id, path, metadata=None):
|
|
calls.append(("send_document", chat_id, path))
|
|
return SimpleNamespace(success=True, message_id="$doc")
|
|
|
|
async def disconnect(self):
|
|
calls.append(("disconnect",))
|
|
|
|
fake_module = SimpleNamespace(MatrixAdapter=EphemeralAdapter)
|
|
|
|
with patch(
|
|
"gateway.run._gateway_runner_ref", return_value=None
|
|
), patch.dict(sys.modules, {"plugins.platforms.matrix.adapter": fake_module}):
|
|
result = asyncio.run(
|
|
_send_matrix_via_adapter(
|
|
SimpleNamespace(enabled=True, token="tok", extra={}),
|
|
"!room:example.com",
|
|
"report attached",
|
|
media_files=[(str(doc_path), False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert calls == [
|
|
("connect",),
|
|
("send", "!room:example.com", "report attached"),
|
|
("send_document", "!room:example.com", str(doc_path)),
|
|
("disconnect",),
|
|
]
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# HTML auto-detection in Telegram send
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
class TestSendTelegramHtmlDetection:
|
|
"""Verify that messages containing HTML tags are sent with parse_mode=HTML
|
|
and that plain / markdown messages use MarkdownV2."""
|
|
|
|
def _make_bot(self):
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock(return_value=SimpleNamespace(message_id=1))
|
|
bot.send_photo = AsyncMock()
|
|
bot.send_video = AsyncMock()
|
|
bot.send_voice = AsyncMock()
|
|
bot.send_audio = AsyncMock()
|
|
bot.send_document = AsyncMock()
|
|
return bot
|
|
|
|
def test_html_message_uses_html_parse_mode(self, monkeypatch):
|
|
bot = self._make_bot()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
asyncio.run(
|
|
_send_telegram("tok", "123", "<b>Hello</b> world")
|
|
)
|
|
|
|
bot.send_message.assert_awaited_once()
|
|
kwargs = bot.send_message.await_args.kwargs
|
|
assert kwargs["parse_mode"] == "HTML"
|
|
assert kwargs["text"] == "<b>Hello</b> world"
|
|
|
|
|
|
def test_transient_bad_gateway_retries_text_send(self, monkeypatch):
|
|
bot = self._make_bot()
|
|
bot.send_message = AsyncMock(
|
|
side_effect=[
|
|
Exception("502 Bad Gateway"),
|
|
SimpleNamespace(message_id=2),
|
|
]
|
|
)
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
with patch("asyncio.sleep", new=AsyncMock()) as sleep_mock:
|
|
result = asyncio.run(_send_telegram("tok", "123", "hello"))
|
|
|
|
assert result["success"] is True
|
|
assert bot.send_message.await_count == 2
|
|
sleep_mock.assert_awaited_once()
|
|
|
|
|
|
class TestSendTelegramThreadIdMapping:
|
|
"""General-topic mapping in _send_telegram (issue #22267).
|
|
|
|
Telegram forum supergroups address the General topic as
|
|
``message_thread_id="1"`` on incoming updates, but the Bot API rejects
|
|
sends with ``message_thread_id=1`` ("Message thread not found"). The
|
|
gateway adapter's ``_message_thread_id_for_send`` helper maps "1" to
|
|
``None`` for that reason; the standalone ``_send_telegram`` helper used
|
|
by the ``send_message`` tool needs the same mapping.
|
|
"""
|
|
|
|
def _make_bot(self):
|
|
bot = MagicMock()
|
|
bot.send_message = AsyncMock(return_value=SimpleNamespace(message_id=1))
|
|
return bot
|
|
|
|
def test_general_topic_thread_id_omitted(self, monkeypatch):
|
|
"""thread_id="1" must be dropped before calling the Bot API."""
|
|
bot = self._make_bot()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
asyncio.run(_send_telegram("tok", "-1001234567890", "hello", thread_id="1"))
|
|
|
|
bot.send_message.assert_awaited_once()
|
|
kwargs = bot.send_message.await_args.kwargs
|
|
assert "message_thread_id" not in kwargs
|
|
|
|
def test_non_general_topic_thread_id_preserved(self, monkeypatch):
|
|
"""Real forum-topic thread ids (>1) still pass through as ints."""
|
|
bot = self._make_bot()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
asyncio.run(_send_telegram("tok", "-1001234567890", "hello", thread_id="17585"))
|
|
|
|
kwargs = bot.send_message.await_args.kwargs
|
|
assert kwargs["message_thread_id"] == 17585
|
|
|
|
def test_thread_not_found_retries_without_message_thread_id(self, monkeypatch):
|
|
"""When send_message raises "thread not found", retry without thread_id (#27012)."""
|
|
bot = self._make_bot()
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
# First call raises thread-not-found, second succeeds
|
|
bot.send_message = AsyncMock(side_effect=[
|
|
Exception("Bad Request: message thread not found"),
|
|
SimpleNamespace(message_id=2),
|
|
])
|
|
|
|
asyncio.run(
|
|
_send_telegram("tok", "-1001234567890", "hello", thread_id="17585")
|
|
)
|
|
|
|
assert bot.send_message.await_count == 2
|
|
# First call: should include message_thread_id=17585
|
|
call1_kwargs = bot.send_message.await_args_list[0].kwargs
|
|
assert call1_kwargs["message_thread_id"] == 17585
|
|
# Second call (retry): should NOT include message_thread_id
|
|
call2_kwargs = bot.send_message.await_args_list[1].kwargs
|
|
assert "message_thread_id" not in call2_kwargs
|
|
|
|
def test_thread_not_found_for_media_retries_without_message_thread_id(self, monkeypatch, tmp_path):
|
|
"""Media send with stale thread_id retries without it (#27012)."""
|
|
bot = self._make_bot()
|
|
# Mock send_document to fail with thread-not-found, then succeed
|
|
bot.send_document = AsyncMock(side_effect=[
|
|
Exception("Bad Request: message thread not found"),
|
|
SimpleNamespace(message_id=3),
|
|
])
|
|
_install_telegram_mock(monkeypatch, bot)
|
|
|
|
# Create a test file
|
|
test_file = tmp_path / "doc.txt"
|
|
test_file.write_text("test content")
|
|
|
|
asyncio.run(
|
|
_send_telegram(
|
|
"tok", "-1001234567890", "",
|
|
media_files=[(str(test_file), False)],
|
|
thread_id="17585",
|
|
)
|
|
)
|
|
|
|
assert bot.send_document.await_count == 2
|
|
# First call: should include message_thread_id=17585
|
|
call1_kwargs = bot.send_document.await_args_list[0].kwargs
|
|
assert call1_kwargs["message_thread_id"] == 17585
|
|
# Second call (retry): should NOT include message_thread_id
|
|
call2_kwargs = bot.send_document.await_args_list[1].kwargs
|
|
assert "message_thread_id" not in call2_kwargs
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for Discord thread_id support
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestParseTargetRef:
|
|
"""_parse_target_ref extracts (chat_id, thread_id, is_explicit) per platform.
|
|
|
|
The tables below cover every explicit target form each platform accepts,
|
|
the forms that must fall through to directory resolution, and the
|
|
cross-platform scoping guards (a Slack ID is not a Discord target, a
|
|
WhatsApp JID is not a Signal target, ...).
|
|
"""
|
|
|
|
def test_explicit_targets_round_trip_chat_and_thread(self):
|
|
cases = [
|
|
# Discord: snowflake, optional :thread, surrounding whitespace
|
|
("discord", "-1001234567890:17585", "-1001234567890", "17585"),
|
|
("discord", "1003724596514", "1003724596514", None),
|
|
("discord", " 123456:789 ", "123456", "789"),
|
|
# Matrix: room id, room:thread-event, user MXID
|
|
("matrix", "!HLOQwxYGgFPMPJUSNR:matrix.org:$thread123:matrix.org",
|
|
"!HLOQwxYGgFPMPJUSNR:matrix.org", "$thread123:matrix.org"),
|
|
("matrix", "!HLOQwxYGgFPMPJUSNR:matrix.org",
|
|
"!HLOQwxYGgFPMPJUSNR:matrix.org", None),
|
|
("matrix", "@hermes:matrix.org", "@hermes:matrix.org", None),
|
|
# Phone platforms: E.164 keeps its '+' for signal-cli; groups and
|
|
# bare digits also resolve.
|
|
("signal", "+41791234567", "+41791234567", None),
|
|
("signal", " group:abc123 ", "group:abc123", None),
|
|
("signal", "15551234567", "15551234567", None),
|
|
("sms", "+15551234567", "+15551234567", None),
|
|
("whatsapp", "+15551234567", "+15551234567", None),
|
|
("photon", "+15551234567", "+15551234567", None),
|
|
# WhatsApp native JIDs. Regression: group (@g.us) and linked-identity
|
|
# (@lid) JIDs matched no branch and silently fell through to the
|
|
# configured home DM instead of the requested group.
|
|
("whatsapp", "120363408391911677@g.us", "120363408391911677@g.us", None),
|
|
("whatsapp", "19255551234@s.whatsapp.net", "19255551234@s.whatsapp.net", None),
|
|
("whatsapp", "149606612619433@lid", "149606612619433@lid", None),
|
|
("whatsapp", "status@broadcast", "status@broadcast", None),
|
|
("whatsapp", "120363000000000000@newsletter",
|
|
"120363000000000000@newsletter", None),
|
|
# Slack: channel/group/DM ids, thread ts, and user targets that the
|
|
# caller must open as a DM.
|
|
("slack", "C0B0QV5434G:171.000001", "C0B0QV5434G", "171.000001"),
|
|
("slack", "C0B0QV5434G", "C0B0QV5434G", None),
|
|
("slack", "G123ABCDEF", "G123ABCDEF", None),
|
|
("slack", "D123ABCDEF", "D123ABCDEF", None),
|
|
("slack", "U123ABCDEF", "user:U123ABCDEF", None),
|
|
("slack", "@alice", "user_name:alice", None),
|
|
("slack", " C0B0QV5434G ", "C0B0QV5434G", None),
|
|
# Email
|
|
("email", "user@example.com", "user@example.com", None),
|
|
("email", "first.last@example.co.uk", "first.last@example.co.uk", None),
|
|
("email", "user+tag@gmail.com", "user+tag@gmail.com", None),
|
|
("email", " user@example.com ", "user@example.com", None),
|
|
]
|
|
for platform, target, expected_chat, expected_thread in cases:
|
|
chat_id, thread_id, is_explicit = _parse_target_ref(platform, target)
|
|
label = f"{platform}:{target}"
|
|
assert is_explicit is True, label
|
|
assert chat_id == expected_chat, label
|
|
assert thread_id == expected_thread, label
|
|
|
|
def test_non_explicit_targets_fall_through_to_resolution(self):
|
|
cases = [
|
|
("matrix", "#general:matrix.org"), # alias needs resolution
|
|
("signal", " group: "), # empty group id
|
|
("signal", "+123"), # E.164 too short
|
|
("signal", "+1234567890123456"), # E.164 too long
|
|
("signal", "+12abc4567890"), # non-numeric
|
|
("signal", "+"),
|
|
("whatsapp", "general"), # friendly name, not a JID
|
|
("slack", "W123ABCDEF"), # workspace id is not sendable
|
|
("slack", "c0b0qv5434g"), # lowercase
|
|
("slack", "C123"), # too short
|
|
("slack", "X0B0QV5434G"), # unknown prefix
|
|
("email", "not-an-email"),
|
|
("email", "@example.com"),
|
|
("email", "user@"),
|
|
("email", "user@.com"),
|
|
]
|
|
for platform, target in cases:
|
|
_chat_id, _, is_explicit = _parse_target_ref(platform, target)
|
|
assert is_explicit is False, f"{platform}:{target}"
|
|
|
|
def test_prefixes_and_suffixes_are_platform_scoped(self):
|
|
"""A form that is explicit on one platform must not leak to another."""
|
|
cases = [
|
|
("telegram", "!something"),
|
|
("discord", "@someone"),
|
|
("telegram", "+15551234567"),
|
|
("discord", "+15551234567"),
|
|
("matrix", "+15551234567"),
|
|
("telegram", "120363408391911677@g.us"),
|
|
("signal", "149606612619433@lid"),
|
|
("discord", "C0B0QV5434G"),
|
|
("telegram", "C0B0QV5434G"),
|
|
("telegram", "user@example.com"),
|
|
("discord", "user@example.com"),
|
|
("slack", "user@example.com"),
|
|
]
|
|
for platform, target in cases:
|
|
assert _parse_target_ref(platform, target)[2] is False, f"{platform}:{target}"
|
|
|
|
|
|
class TestEmailHomeChannelErrorHint:
|
|
"""The no-home-channel error for email points at the real env var.
|
|
|
|
Email reads its home channel from EMAIL_HOME_ADDRESS (gateway/config.py),
|
|
not the generic EMAIL_HOME_CHANNEL. The error guidance must name the
|
|
variable that is actually consulted so users who follow it succeed.
|
|
"""
|
|
|
|
def test_email_error_names_email_home_address(self):
|
|
email_cfg = SimpleNamespace(enabled=True, token="", extra={})
|
|
config = SimpleNamespace(
|
|
platforms={Platform.EMAIL: email_cfg},
|
|
get_home_channel=lambda _platform: None,
|
|
)
|
|
with patch("gateway.config.load_gateway_config", return_value=config), \
|
|
patch("tools.interrupt.is_interrupted", return_value=False):
|
|
result = json.loads(
|
|
send_message_tool(
|
|
{
|
|
"action": "send",
|
|
"target": "email",
|
|
"message": "hi",
|
|
}
|
|
)
|
|
)
|
|
assert "EMAIL_HOME_ADDRESS" in result["error"]
|
|
assert "EMAIL_HOME_CHANNEL" not in result["error"]
|
|
|
|
class TestResolveSlackUserTargets:
|
|
"""_resolve_slack_user_target opens user targets as DMs before sending.
|
|
|
|
Adapted from #19237's ``_send_slack`` tests: main moved Slack delivery to
|
|
the plugin's ``_standalone_send`` (#41112), so the salvaged DM-open logic
|
|
lives in a resolution helper that runs before any send path.
|
|
"""
|
|
|
|
@staticmethod
|
|
def _mock_response(data):
|
|
response = MagicMock()
|
|
response.json = AsyncMock(return_value=data)
|
|
response.__aenter__ = AsyncMock(return_value=response)
|
|
response.__aexit__ = AsyncMock(return_value=None)
|
|
return response
|
|
|
|
@staticmethod
|
|
def _mock_session(*responses):
|
|
session = MagicMock()
|
|
session.__aenter__ = AsyncMock(return_value=session)
|
|
session.__aexit__ = AsyncMock(return_value=None)
|
|
session.post = MagicMock(side_effect=responses)
|
|
return session
|
|
|
|
def test_conversation_ids_pass_through_without_api_calls(self):
|
|
for cid in ("C0B0QV5434G", "G123ABCDEF", "D123ABCDEF"):
|
|
chat_id, err = asyncio.run(_resolve_slack_user_target("tok", cid))
|
|
assert chat_id == cid
|
|
assert err is None
|
|
|
|
|
|
def test_conversations_open_failure_surfaces_error(self):
|
|
session = self._mock_session(
|
|
self._mock_response({"ok": False, "error": "missing_scope"}),
|
|
)
|
|
|
|
with patch("aiohttp.ClientSession", return_value=session):
|
|
chat_id, err = asyncio.run(
|
|
_resolve_slack_user_target("tok", "user:U123ABCDEF")
|
|
)
|
|
|
|
assert chat_id is None
|
|
assert "missing_scope" in err["error"]
|
|
assert "im:write" in err["error"]
|
|
|
|
|
|
class TestSendDiscordThreadId:
|
|
"""_send_discord uses thread_id when provided."""
|
|
|
|
@staticmethod
|
|
def _build_mock(response_status, response_data=None, response_text="error body"):
|
|
"""Build a properly-structured aiohttp mock chain.
|
|
|
|
session.post() returns a context manager yielding mock_resp.
|
|
"""
|
|
mock_resp = MagicMock()
|
|
mock_resp.status = response_status
|
|
mock_resp.json = AsyncMock(return_value=response_data or {"id": "msg123"})
|
|
mock_resp.text = AsyncMock(return_value=response_text)
|
|
|
|
# mock_resp as async context manager (for "async with session.post(...) as resp")
|
|
mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
|
|
mock_resp.__aexit__ = AsyncMock(return_value=None)
|
|
|
|
mock_session = MagicMock()
|
|
mock_session.__aenter__ = AsyncMock(return_value=mock_session)
|
|
mock_session.__aexit__ = AsyncMock(return_value=None)
|
|
mock_session.post = MagicMock(return_value=mock_resp)
|
|
|
|
return mock_session, mock_resp
|
|
|
|
def _run(self, token, chat_id, message, thread_id=None):
|
|
return asyncio.run(_send_discord(token, chat_id, message, thread_id=thread_id))
|
|
|
|
def test_with_thread_id_uses_thread_endpoint(self):
|
|
"""When thread_id is provided, sends to /channels/{thread_id}/messages."""
|
|
mock_session, _ = self._build_mock(200)
|
|
with patch("aiohttp.ClientSession", return_value=mock_session):
|
|
self._run("tok", "999888777", "hello from thread", thread_id="555444333")
|
|
call_url = mock_session.post.call_args.args[0]
|
|
assert call_url == "https://discord.com/api/v10/channels/555444333/messages"
|
|
|
|
|
|
def test_success_response_json_read_is_bounded(self):
|
|
"""Standalone Discord sends parse success JSON through the bounded reader."""
|
|
body = b'{"id":"bounded-json"}'
|
|
response = _StreamingAiohttpResponse(200, body)
|
|
session = _StreamingAiohttpSession(response)
|
|
|
|
with patch("aiohttp.ClientSession", return_value=session):
|
|
result = self._run("tok", "111", "hi", thread_id="999")
|
|
|
|
assert result["success"] is True
|
|
assert result["message_id"] == "bounded-json"
|
|
assert response.content.read_sizes[0] == _DISCORD_STANDALONE_JSON_BODY_LIMIT_BYTES + 1
|
|
response.json.assert_not_awaited()
|
|
response.text.assert_not_awaited()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Discord media attachment support
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestSendDiscordMedia:
|
|
"""_send_discord uploads media files via multipart/form-data."""
|
|
|
|
@staticmethod
|
|
def _build_mock(response_status, response_data=None, response_text="error body"):
|
|
"""Build a properly-structured aiohttp mock chain."""
|
|
mock_resp = MagicMock()
|
|
mock_resp.status = response_status
|
|
mock_resp.json = AsyncMock(return_value=response_data or {"id": "msg123"})
|
|
mock_resp.text = AsyncMock(return_value=response_text)
|
|
mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
|
|
mock_resp.__aexit__ = AsyncMock(return_value=None)
|
|
|
|
mock_session = MagicMock()
|
|
mock_session.__aenter__ = AsyncMock(return_value=mock_session)
|
|
mock_session.__aexit__ = AsyncMock(return_value=None)
|
|
mock_session.post = MagicMock(return_value=mock_resp)
|
|
|
|
return mock_session, mock_resp
|
|
|
|
def test_text_and_media_sends_both(self, tmp_path):
|
|
"""Text message is sent first, then each media file as multipart."""
|
|
img = tmp_path / "photo.png"
|
|
img.write_bytes(b"\x89PNG fake image data")
|
|
|
|
mock_session, _ = self._build_mock(200, {"id": "msg999"})
|
|
with patch("aiohttp.ClientSession", return_value=mock_session):
|
|
result = asyncio.run(
|
|
_send_discord("tok", "111", "hello", media_files=[(str(img), False)])
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["message_id"] == "msg999"
|
|
# Two POSTs: one text JSON, one multipart upload
|
|
assert mock_session.post.call_count == 2
|
|
|
|
|
|
|
|
class TestSendToPlatformDiscordMedia:
|
|
"""_send_to_platform routes Discord media correctly."""
|
|
|
|
def test_media_files_passed_on_last_chunk_only(self):
|
|
"""Discord media_files are only passed on the final chunk."""
|
|
call_log = []
|
|
|
|
async def mock_send_discord(token, chat_id, message, thread_id=None, media_files=None):
|
|
call_log.append({"message": message, "media_files": media_files or []})
|
|
return {"success": True, "platform": "discord", "chat_id": chat_id, "message_id": "1"}
|
|
|
|
# A message long enough to get chunked (Discord limit is 2000)
|
|
long_msg = "A" * 1900 + " " + "B" * 1900
|
|
|
|
with _patch_discord_sender(AsyncMock(side_effect=mock_send_discord)):
|
|
result = asyncio.run(
|
|
_send_to_platform(
|
|
Platform.DISCORD,
|
|
SimpleNamespace(enabled=True, token="tok", extra={}),
|
|
"999",
|
|
long_msg,
|
|
media_files=[("/fake/img.png", False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert len(call_log) == 2 # Message was chunked
|
|
assert call_log[0]["media_files"] == [] # First chunk: no media
|
|
assert call_log[1]["media_files"] == [("/fake/img.png", False)] # Last chunk: media attached
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for _derive_forum_thread_name
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestDeriveForumThreadName:
|
|
def test_first_line_heading_and_fallback_handling(self):
|
|
cases = [
|
|
("Hello world", "Hello world"),
|
|
("First line\nSecond line", "First line"),
|
|
(" Title \nBody", "Title"),
|
|
("## My Heading", "My Heading"),
|
|
("### Deep heading", "Deep heading"),
|
|
("", "New Post"),
|
|
(" \n ", "New Post"),
|
|
("###", "New Post"),
|
|
]
|
|
for message, expected in cases:
|
|
assert _derive_forum_thread_name(message) == expected, repr(message)
|
|
|
|
# Titles are capped at Discord's 100-char thread-name limit.
|
|
assert len(_derive_forum_thread_name("A" * 200)) == 100
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for _send_discord with forum channel support
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestSendDiscordForum:
|
|
"""_send_discord creates thread posts for forum channels."""
|
|
|
|
@staticmethod
|
|
def _build_mock(response_status, response_data=None, response_text="error body"):
|
|
mock_resp = MagicMock()
|
|
mock_resp.status = response_status
|
|
mock_resp.json = AsyncMock(return_value=response_data or {})
|
|
mock_resp.text = AsyncMock(return_value=response_text)
|
|
mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
|
|
mock_resp.__aexit__ = AsyncMock(return_value=None)
|
|
|
|
mock_session = MagicMock()
|
|
mock_session.__aenter__ = AsyncMock(return_value=mock_session)
|
|
mock_session.__aexit__ = AsyncMock(return_value=None)
|
|
mock_session.post = MagicMock(return_value=mock_resp)
|
|
mock_session.get = MagicMock(return_value=mock_resp)
|
|
|
|
return mock_session, mock_resp
|
|
|
|
def test_directory_forum_creates_thread(self):
|
|
"""Directory says 'forum' — creates a thread post."""
|
|
thread_data = {
|
|
"id": "t123",
|
|
"message": {"id": "m456"},
|
|
}
|
|
mock_session, _ = self._build_mock(200, response_data=thread_data)
|
|
|
|
with patch("aiohttp.ClientSession", return_value=mock_session), \
|
|
patch("gateway.channel_directory.lookup_channel_type", return_value="forum"):
|
|
result = asyncio.run(
|
|
_send_discord("tok", "forum_ch", "Hello forum")
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["thread_id"] == "t123"
|
|
assert result["message_id"] == "m456"
|
|
# Should POST to threads endpoint, not messages
|
|
call_url = mock_session.post.call_args.args[0]
|
|
assert "/threads" in call_url
|
|
assert "/messages" not in call_url
|
|
|
|
|
|
def test_forum_thread_creation_error(self):
|
|
"""Forum thread creation returning non-200/201 returns an error dict."""
|
|
mock_session, _ = self._build_mock(403, response_text="Forbidden")
|
|
|
|
with patch("aiohttp.ClientSession", return_value=mock_session), \
|
|
patch("gateway.channel_directory.lookup_channel_type", return_value="forum"):
|
|
result = asyncio.run(
|
|
_send_discord("tok", "forum_ch", "Hello")
|
|
)
|
|
|
|
assert "error" in result
|
|
assert "403" in result["error"]
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for _send_discord forum + media multipart upload
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestSendDiscordForumMedia:
|
|
"""_send_discord uploads media as part of the starter message when the target is a forum."""
|
|
|
|
@staticmethod
|
|
def _build_thread_resp(thread_id="th_999", msg_id="msg_500"):
|
|
resp = MagicMock()
|
|
resp.status = 201
|
|
resp.json = AsyncMock(return_value={"id": thread_id, "message": {"id": msg_id}})
|
|
resp.text = AsyncMock(return_value="")
|
|
resp.__aenter__ = AsyncMock(return_value=resp)
|
|
resp.__aexit__ = AsyncMock(return_value=None)
|
|
return resp
|
|
|
|
def test_forum_with_media_uses_multipart(self, tmp_path, monkeypatch):
|
|
"""Forum + media → single multipart POST to /threads carrying the starter + files."""
|
|
from tools import send_message_tool as smt
|
|
|
|
img = tmp_path / "photo.png"
|
|
img.write_bytes(b"\x89PNGbytes")
|
|
|
|
monkeypatch.setattr(smt, "lookup_channel_type", lambda p, cid: "forum", raising=False)
|
|
monkeypatch.setattr(
|
|
"gateway.channel_directory.lookup_channel_type", lambda p, cid: "forum"
|
|
)
|
|
|
|
thread_resp = self._build_thread_resp()
|
|
session = MagicMock()
|
|
session.__aenter__ = AsyncMock(return_value=session)
|
|
session.__aexit__ = AsyncMock(return_value=None)
|
|
session.post = MagicMock(return_value=thread_resp)
|
|
|
|
post_calls = []
|
|
|
|
def track_post(url, **kwargs):
|
|
post_calls.append({"url": url, "kwargs": kwargs})
|
|
return thread_resp
|
|
|
|
session.post = MagicMock(side_effect=track_post)
|
|
|
|
with patch("aiohttp.ClientSession", return_value=session):
|
|
result = asyncio.run(
|
|
_send_discord("tok", "forum_ch", "Thread title\nbody", media_files=[(str(img), False)])
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["thread_id"] == "th_999"
|
|
assert result["message_id"] == "msg_500"
|
|
# Exactly one POST — the combined thread-creation + attachments call
|
|
assert len(post_calls) == 1
|
|
assert post_calls[0]["url"].endswith("/threads")
|
|
# Multipart form, not JSON
|
|
assert post_calls[0]["kwargs"].get("data") is not None
|
|
assert post_calls[0]["kwargs"].get("json") is None
|
|
|
|
def test_forum_missing_media_file_collected_as_warning(self, tmp_path, monkeypatch):
|
|
"""Missing media files produce warnings but the thread is still created."""
|
|
monkeypatch.setattr(
|
|
"gateway.channel_directory.lookup_channel_type", lambda p, cid: "forum"
|
|
)
|
|
|
|
thread_resp = self._build_thread_resp()
|
|
session = MagicMock()
|
|
session.__aenter__ = AsyncMock(return_value=session)
|
|
session.__aexit__ = AsyncMock(return_value=None)
|
|
session.post = MagicMock(return_value=thread_resp)
|
|
|
|
with patch("aiohttp.ClientSession", return_value=session):
|
|
result = asyncio.run(
|
|
_send_discord(
|
|
"tok", "forum_ch", "hi",
|
|
media_files=[("/nonexistent/does-not-exist.png", False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert "warnings" in result
|
|
assert any("not found" in w for w in result["warnings"])
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for the process-local forum-probe cache
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
# Only one session opened (thread creation) — no probe session this time
|
|
# (verified by not raising from our side_effect exhaustion)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _send_signal — chunking + 429 retry (mirrors gateway adapter behavior)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class _FakeSignalHttp:
|
|
"""Stand-in for httpx.AsyncClient used as an async context manager.
|
|
|
|
Pops a response from the queue per `post` call. Each entry is either
|
|
a dict (returned from .json()) or an exception instance (raised).
|
|
Captures (url, payload) per call.
|
|
"""
|
|
|
|
def __init__(self, responses):
|
|
self.responses = list(responses)
|
|
self.calls = []
|
|
|
|
def __call__(self, *_a, **_kw):
|
|
return self
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *_a):
|
|
return False
|
|
|
|
async def post(self, url, json=None):
|
|
self.calls.append({"url": url, "payload": json})
|
|
if not self.responses:
|
|
raise AssertionError("Unexpected extra POST")
|
|
item = self.responses.pop(0)
|
|
if isinstance(item, BaseException):
|
|
raise item
|
|
resp = SimpleNamespace(
|
|
raise_for_status=lambda: None,
|
|
json=lambda data=item: data,
|
|
)
|
|
return resp
|
|
|
|
|
|
def _install_signal_http(monkeypatch, fake):
|
|
"""Patch httpx.AsyncClient at the module level so the lazy import in
|
|
_send_signal picks it up.
|
|
"""
|
|
import httpx
|
|
monkeypatch.setattr(httpx, "AsyncClient", fake)
|
|
|
|
|
|
def _patch_sendmsg_sleep_and_time(monkeypatch, capture: list):
|
|
"""Mock asyncio.sleep + time.monotonic in the signal_rate_limit
|
|
module so the scheduler's acquire loop sees synthetic time advancing
|
|
during sleep calls, and report_rpc_duration sees the same clock.
|
|
|
|
Zero-second sleeps (event-loop yields from fake HTTP posts) are
|
|
delegated to the real asyncio.sleep so they don't pollute the
|
|
capture list.
|
|
"""
|
|
import asyncio as _aio
|
|
_real_sleep = _aio.sleep
|
|
offset = [0.0]
|
|
|
|
async def fake_sleep(seconds):
|
|
if seconds > 0:
|
|
capture.append(seconds)
|
|
offset[0] += seconds
|
|
else:
|
|
await _real_sleep(0)
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.platforms.signal.signal_rate_limit.asyncio.sleep", fake_sleep
|
|
)
|
|
monkeypatch.setattr(
|
|
"plugins.platforms.signal.signal_rate_limit.time.monotonic", lambda: offset[0]
|
|
)
|
|
|
|
|
|
class TestSendSignalChunking:
|
|
def test_text_only_single_rpc(self, monkeypatch):
|
|
fake = _FakeSignalHttp([{"result": {"timestamp": 1}}])
|
|
_install_signal_http(monkeypatch, fake)
|
|
|
|
result = asyncio.run(
|
|
_send_signal(
|
|
{"http_url": "http://localhost:8080", "account": "+15551234567"},
|
|
"+15557654321",
|
|
"hello",
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["platform"] == "signal"
|
|
assert result["chat_id"].endswith("4321")
|
|
assert len(fake.calls) == 1
|
|
params = fake.calls[0]["payload"]["params"]
|
|
assert params["message"] == "hello"
|
|
assert "attachments" not in params
|
|
assert "textStyle" not in params
|
|
assert "textStyles" not in params
|
|
|
|
|
|
def test_skipped_missing_files_reported_in_warnings(self, tmp_path, monkeypatch):
|
|
good = tmp_path / "ok.png"
|
|
good.write_bytes(b"\x89PNG" + b"\x00" * 16)
|
|
|
|
fake = _FakeSignalHttp([{"result": {"timestamp": 1}}])
|
|
_install_signal_http(monkeypatch, fake)
|
|
|
|
result = asyncio.run(
|
|
_send_signal(
|
|
{"http_url": "http://localhost:8080", "account": "+15551234567"},
|
|
"+15557654321",
|
|
"msg",
|
|
media_files=[(str(good), False), (str(tmp_path / "missing.png"), False)],
|
|
)
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert "warnings" in result
|
|
# Only the existing file made it into the RPC
|
|
params = fake.calls[0]["payload"]["params"]
|
|
assert len(params["attachments"]) == 1
|
|
|
|
|
|
# ── _send_via_adapter standalone fallback ────────────────────────────────
|
|
|
|
|
|
class _FakePlatform:
|
|
"""Stand-in for the gateway.config.Platform enum. Holds the .value
|
|
attribute consulted by ``_send_via_adapter`` for registry lookups."""
|
|
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
|
|
class TestSendViaAdapterStandaloneFallback:
|
|
"""Coverage for the out-of-process plugin-platform send path.
|
|
|
|
When the gateway runner is not in this process (e.g. ``hermes cron``
|
|
runs separately from ``hermes gateway``), ``_send_via_adapter`` should
|
|
fall through to the plugin's ``standalone_sender_fn`` registered on
|
|
its ``PlatformEntry``. Without the hook, the existing error string
|
|
is returned (with a more helpful tail).
|
|
"""
|
|
|
|
@staticmethod
|
|
def _make_entry(send_fn):
|
|
from gateway.platform_registry import PlatformEntry
|
|
|
|
return PlatformEntry(
|
|
name="fakeplatform",
|
|
label="Fake",
|
|
adapter_factory=lambda cfg: None,
|
|
check_fn=lambda: True,
|
|
standalone_sender_fn=send_fn,
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_live_ntfy_adapter_receives_explicit_publish_topic(self, monkeypatch):
|
|
from tools.send_message_tool import _send_via_adapter
|
|
|
|
platform = Platform("ntfy")
|
|
recorded = {}
|
|
|
|
class Adapter:
|
|
async def send(self, *, chat_id, content, metadata=None):
|
|
recorded["chat_id"] = chat_id
|
|
recorded["content"] = content
|
|
recorded["metadata"] = metadata
|
|
return SimpleNamespace(success=True, message_id="ntfy-id")
|
|
|
|
runner = SimpleNamespace(adapters={platform: Adapter()})
|
|
fake_gateway_run = ModuleType("gateway.run")
|
|
fake_gateway_run._gateway_runner_ref = lambda: runner
|
|
monkeypatch.setitem(sys.modules, "gateway.run", fake_gateway_run)
|
|
|
|
result = await _send_via_adapter(
|
|
platform,
|
|
SimpleNamespace(extra={"publish_topic": "configured-topic"}),
|
|
"alerts-channel",
|
|
"done",
|
|
)
|
|
|
|
assert result == {"success": True, "message_id": "ntfy-id"}
|
|
assert recorded["chat_id"] == "alerts-channel"
|
|
assert recorded["content"] == "done"
|
|
assert recorded["metadata"] == {"publish_topic": "alerts-channel"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_standalone_sender_fn_raises_is_caught_and_formatted(self, monkeypatch):
|
|
"""Hook raises: error dict has 'Plugin standalone send failed: ...'"""
|
|
from tools.send_message_tool import _send_via_adapter
|
|
from gateway.platform_registry import platform_registry
|
|
|
|
async def boom(pconfig, chat_id, message, **kwargs):
|
|
raise ValueError("boom!")
|
|
|
|
platform_registry.register(self._make_entry(boom))
|
|
try:
|
|
monkeypatch.setattr("gateway.run._gateway_runner_ref", lambda: None)
|
|
|
|
result = await _send_via_adapter(
|
|
_FakePlatform("fakeplatform"),
|
|
SimpleNamespace(extra={}),
|
|
"chat-1",
|
|
"hi",
|
|
)
|
|
finally:
|
|
platform_registry.unregister("fakeplatform")
|
|
|
|
assert set(result) == {"error"}
|
|
assert "boom!" in result["error"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_fresh_process_discovers_plugins_before_the_fallback(self, monkeypatch):
|
|
"""No gateway and nothing registered yet (cron/CLI process): the fallback runs plugin
|
|
discovery, so a platform without a dedicated route still reaches its standalone sender."""
|
|
from tools.send_message_tool import _send_via_adapter
|
|
from gateway.platform_registry import platform_registry
|
|
|
|
sent = []
|
|
|
|
async def send(pconfig, chat_id, message, **kwargs):
|
|
sent.append((chat_id, message))
|
|
return {"success": True, "platform": "fakeplatform", "chat_id": chat_id}
|
|
|
|
monkeypatch.setattr("gateway.run._gateway_runner_ref", lambda: None)
|
|
monkeypatch.setattr("hermes_cli.plugins.discover_plugins",
|
|
lambda *a, **k: platform_registry.register(self._make_entry(send)))
|
|
try:
|
|
result = await _send_via_adapter(_FakePlatform("fakeplatform"), SimpleNamespace(extra={}), "chat-1", "hi")
|
|
finally:
|
|
platform_registry.unregister("fakeplatform")
|
|
|
|
assert result["success"] is True and sent == [("chat-1", "hi")]
|
|
|
|
class TestSendTelegramThreadNotFoundRetry:
|
|
"""Tests for thread-not-found retry behaviour in _send_telegram (#27012)."""
|
|
|
|
|
|
def test_disable_web_page_preview_not_leaked_to_media_sends(self):
|
|
"""disable_web_page_preview must never leak into a media send.
|
|
|
|
A single captionable file + short text now rides as the document's
|
|
caption (no separate text send), so the invariant to protect is that
|
|
the captioned send_document does not inherit disable_web_page_preview
|
|
(valid only for send_message).
|
|
"""
|
|
media_kwargs_seen = []
|
|
|
|
class FakeBot:
|
|
async def send_message(self, **kwargs):
|
|
return SimpleNamespace(message_id=1)
|
|
|
|
async def send_document(self, **kwargs):
|
|
media_kwargs_seen.append(kwargs)
|
|
return SimpleNamespace(message_id=2)
|
|
|
|
import tempfile
|
|
media_path = None
|
|
try:
|
|
with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tf:
|
|
tf.write(b"%PDF-1.4 test content")
|
|
media_path = tf.name
|
|
|
|
async def run_test():
|
|
with patch("telegram.Bot", return_value=FakeBot()):
|
|
return await _send_telegram(
|
|
"fake-token", "-100123", "check preview",
|
|
media_files=[(media_path, False)],
|
|
disable_link_previews=True,
|
|
)
|
|
|
|
result = asyncio.run(run_test())
|
|
assert result["success"] is True
|
|
# Caption rides the document bubble.
|
|
assert media_kwargs_seen[0].get("caption") == "check preview"
|
|
# Media send must NOT carry disable_web_page_preview.
|
|
assert "disable_web_page_preview" not in media_kwargs_seen[0], \
|
|
"disable_web_page_preview leaked into send_document kwargs"
|
|
finally:
|
|
if media_path and os.path.exists(media_path):
|
|
os.unlink(media_path)
|
|
|
|
|
|
def test_not_configured_error_names_resolved_home_and_consulted_sources(tmp_path, monkeypatch):
|
|
"""The 'not configured' error names the files this process actually read (resolved home, not a
|
|
hardcoded ``~/.hermes``) and what each source held, so a Windows/profile home user can fix the right file."""
|
|
from gateway.config import GatewayConfig
|
|
from tools.send_message_tool import _resolve_platform_config
|
|
|
|
home = tmp_path / "AppData" / "Local" / "hermes"
|
|
home.mkdir(parents=True)
|
|
(home / ".env").write_text("FIRECRAWL_API_KEY=x\n", encoding="utf-8")
|
|
(home / "config.yaml").write_text("platforms:\n discord:\n enabled: false\n", encoding="utf-8")
|
|
monkeypatch.setenv("HERMES_HOME", str(home))
|
|
monkeypatch.delenv("DISCORD_BOT_TOKEN", raising=False)
|
|
|
|
_, _, _, err = _resolve_platform_config("discord", GatewayConfig())
|
|
|
|
assert "~/.hermes" not in err
|
|
assert str(home / ".env") in err
|
|
assert str(home / "config.yaml") in err
|
|
|
|
|
|
def test_not_configured_error_names_default_root_gateway_and_secret_sources(tmp_path, monkeypatch):
|
|
"""Under ``HERMES_HOME=<root>/profiles/<p>`` the error says a live gateway from the default root has the
|
|
platform connected (its credentials never came from this profile's ``.env``) and lists external secret
|
|
sources by name only (#114272 step 5)."""
|
|
import json
|
|
import os
|
|
|
|
from gateway.config import GatewayConfig
|
|
from tools.send_message_tool import _resolve_platform_config
|
|
|
|
root = tmp_path / "hermes"
|
|
profile = root / "profiles" / "coder"
|
|
profile.mkdir(parents=True)
|
|
(root / "gateway_state.json").write_text(
|
|
json.dumps({"pid": os.getpid(), "platforms": {"discord": {"state": "connected"}}}), encoding="utf-8")
|
|
(profile / ".env").write_text("FIRECRAWL_API_KEY=x\n", encoding="utf-8")
|
|
(profile / "config.yaml").write_text(
|
|
"secrets:\n bitwarden:\n enabled: false\n session_token: SECRET-VALUE\n", encoding="utf-8")
|
|
monkeypatch.setenv("HERMES_HOME", str(profile))
|
|
monkeypatch.delenv("DISCORD_BOT_TOKEN", raising=False)
|
|
|
|
_, _, _, err = _resolve_platform_config("discord", GatewayConfig())
|
|
|
|
assert str(os.getpid()) in err and str(profile) in err
|
|
assert "bitwarden" in err
|
|
assert "SECRET-VALUE" not in err
|