mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-27 17:58:07 +00:00
384b0a0b5b
Surface a user-visible delivery notice when non-streaming media dispatch gets success=False after MEDIA tags were stripped, and validate forum starter-message attachments the same way as direct channel sends (#66797).
722 lines
26 KiB
Python
722 lines
26 KiB
Python
import asyncio
|
|
import sys
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
from gateway.config import PlatformConfig
|
|
|
|
|
|
def _ensure_discord_mock():
|
|
if "discord" in sys.modules and hasattr(sys.modules["discord"], "__file__"):
|
|
return
|
|
|
|
discord_mod = MagicMock()
|
|
discord_mod.Intents.default.return_value = MagicMock()
|
|
discord_mod.Client = MagicMock
|
|
discord_mod.File = MagicMock
|
|
discord_mod.DMChannel = type("DMChannel", (), {})
|
|
discord_mod.Thread = type("Thread", (), {})
|
|
discord_mod.ForumChannel = type("ForumChannel", (), {})
|
|
discord_mod.ui = SimpleNamespace(View=object, button=lambda *a, **k: (lambda fn: fn), Button=object)
|
|
discord_mod.ButtonStyle = SimpleNamespace(success=1, primary=2, secondary=2, danger=3, green=1, grey=2, blurple=2, red=3)
|
|
discord_mod.Color = SimpleNamespace(orange=lambda: 1, green=lambda: 2, blue=lambda: 3, red=lambda: 4, purple=lambda: 5)
|
|
discord_mod.Interaction = object
|
|
discord_mod.Embed = MagicMock
|
|
discord_mod.app_commands = SimpleNamespace(
|
|
describe=lambda **kwargs: (lambda fn: fn),
|
|
choices=lambda **kwargs: (lambda fn: fn),
|
|
Choice=lambda **kwargs: SimpleNamespace(**kwargs),
|
|
)
|
|
|
|
ext_mod = MagicMock()
|
|
commands_mod = MagicMock()
|
|
commands_mod.Bot = MagicMock
|
|
ext_mod.commands = commands_mod
|
|
|
|
sys.modules.setdefault("discord", discord_mod)
|
|
sys.modules.setdefault("discord.ext", ext_mod)
|
|
sys.modules.setdefault("discord.ext.commands", commands_mod)
|
|
|
|
|
|
_ensure_discord_mock()
|
|
|
|
from plugins.platforms.discord.adapter import DiscordAdapter # noqa: E402
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_retries_without_reference_when_reply_target_is_system_message():
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
reference_obj = object()
|
|
ref_msg = SimpleNamespace(id=99, to_reference=MagicMock(return_value=reference_obj))
|
|
sent_msg = SimpleNamespace(id=1234)
|
|
send_calls = []
|
|
|
|
async def fake_send(*, content, reference=None):
|
|
send_calls.append({"content": content, "reference": reference})
|
|
if len(send_calls) == 1:
|
|
raise RuntimeError(
|
|
"400 Bad Request (error code: 50035): Invalid Form Body\n"
|
|
"In message_reference: Cannot reply to a system message"
|
|
)
|
|
return sent_msg
|
|
|
|
channel = SimpleNamespace(
|
|
fetch_message=AsyncMock(return_value=ref_msg),
|
|
send=AsyncMock(side_effect=fake_send),
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
result = await adapter.send("555", "hello", reply_to="99")
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "1234"
|
|
assert channel.fetch_message.await_count == 1
|
|
assert channel.send.await_count == 2
|
|
ref_msg.to_reference.assert_called_once_with(fail_if_not_exists=False)
|
|
assert send_calls[0]["reference"] is reference_obj
|
|
assert send_calls[1]["reference"] is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_retries_without_reference_when_reply_target_is_deleted():
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
reference_obj = object()
|
|
ref_msg = SimpleNamespace(id=99, to_reference=MagicMock(return_value=reference_obj))
|
|
sent_msgs = [SimpleNamespace(id=1001), SimpleNamespace(id=1002)]
|
|
send_calls = []
|
|
|
|
async def fake_send(*, content, reference=None):
|
|
send_calls.append({"content": content, "reference": reference})
|
|
if len(send_calls) == 1:
|
|
raise RuntimeError(
|
|
"400 Bad Request (error code: 10008): Unknown Message"
|
|
)
|
|
return sent_msgs[len(send_calls) - 2]
|
|
|
|
channel = SimpleNamespace(
|
|
fetch_message=AsyncMock(return_value=ref_msg),
|
|
send=AsyncMock(side_effect=fake_send),
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
long_text = "A" * (adapter.MAX_MESSAGE_LENGTH + 50)
|
|
result = await adapter.send("555", long_text, reply_to="99")
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "1001"
|
|
assert channel.fetch_message.await_count == 1
|
|
assert channel.send.await_count == 3
|
|
ref_msg.to_reference.assert_called_once_with(fail_if_not_exists=False)
|
|
assert send_calls[0]["reference"] is reference_obj
|
|
assert send_calls[1]["reference"] is None
|
|
assert send_calls[2]["reference"] is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_does_not_retry_on_unrelated_errors():
|
|
"""Regression guard: errors unrelated to the reply reference (e.g. 50013
|
|
Missing Permissions) must NOT trigger the no-reference retry path — they
|
|
should propagate out of the per-chunk loop and surface as a failed
|
|
SendResult so the caller sees the real problem instead of a silent retry.
|
|
"""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
reference_obj = object()
|
|
ref_msg = SimpleNamespace(id=99, to_reference=MagicMock(return_value=reference_obj))
|
|
send_calls = []
|
|
|
|
async def fake_send(*, content, reference=None):
|
|
send_calls.append({"content": content, "reference": reference})
|
|
raise RuntimeError(
|
|
"403 Forbidden (error code: 50013): Missing Permissions"
|
|
)
|
|
|
|
channel = SimpleNamespace(
|
|
fetch_message=AsyncMock(return_value=ref_msg),
|
|
send=AsyncMock(side_effect=fake_send),
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
result = await adapter.send("555", "hello", reply_to="99")
|
|
|
|
# Outer except in adapter.send() wraps propagated errors as SendResult.
|
|
assert result.success is False
|
|
assert "50013" in (result.error or "")
|
|
# Only the first attempt happens — no reference-retry replay.
|
|
assert channel.send.await_count == 1
|
|
assert send_calls[0]["reference"] is reference_obj
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Forum channel tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
import discord as _discord_mod # noqa: E402 — imported after _ensure_discord_mock
|
|
|
|
|
|
class TestIsForumParent:
|
|
def test_none_returns_false(self):
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
assert adapter._is_forum_parent(None) is False
|
|
|
|
def test_forum_channel_class_instance(self):
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
forum_cls = getattr(_discord_mod, "ForumChannel", None)
|
|
if forum_cls is None:
|
|
# Re-create a type for the mock
|
|
forum_cls = type("ForumChannel", (), {})
|
|
_discord_mod.ForumChannel = forum_cls
|
|
ch = forum_cls()
|
|
assert adapter._is_forum_parent(ch) is True
|
|
|
|
def test_type_value_15(self):
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
ch = SimpleNamespace(type=15)
|
|
assert adapter._is_forum_parent(ch) is True
|
|
|
|
def test_regular_channel_returns_false(self):
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
ch = SimpleNamespace(type=0)
|
|
assert adapter._is_forum_parent(ch) is False
|
|
|
|
def test_thread_returns_false(self):
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
ch = SimpleNamespace(type=11) # public thread
|
|
assert adapter._is_forum_parent(ch) is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_to_forum_creates_thread_post():
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
# thread object has no 'send' so _send_to_forum uses thread.thread
|
|
thread_ch = SimpleNamespace(id=555, send=AsyncMock(return_value=SimpleNamespace(id=600)))
|
|
thread = SimpleNamespace(
|
|
id=555,
|
|
message=SimpleNamespace(id=500),
|
|
thread=thread_ch,
|
|
)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.name = "ideas"
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
result = await adapter.send("999", "Hello forum!")
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "500"
|
|
forum_channel.create_thread.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_to_forum_sends_remaining_chunks():
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
# Force a small max message length so the message splits
|
|
adapter.MAX_MESSAGE_LENGTH = 20
|
|
|
|
chunk_msg_1 = SimpleNamespace(id=500)
|
|
chunk_msg_2 = SimpleNamespace(id=501)
|
|
thread_ch = SimpleNamespace(
|
|
id=555,
|
|
send=AsyncMock(return_value=chunk_msg_2),
|
|
)
|
|
# thread object has no 'send' so _send_to_forum uses thread.thread
|
|
thread = SimpleNamespace(
|
|
id=555,
|
|
message=chunk_msg_1,
|
|
thread=thread_ch,
|
|
)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.name = "ideas"
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
result = await adapter.send("999", "A" * 50)
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "500"
|
|
# Should have sent at least one follow-up chunk
|
|
assert thread_ch.send.await_count >= 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_to_forum_create_thread_failure():
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.name = "ideas"
|
|
forum_channel.create_thread = AsyncMock(side_effect=Exception("rate limited"))
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
result = await adapter.send("999", "Hello forum!")
|
|
|
|
assert result.success is False
|
|
assert "rate limited" in result.error
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Forum follow-up chunk failure reporting + media on forum paths
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_to_forum_follow_up_chunk_failures_collected_as_warnings():
|
|
"""Partial-send chunk failures surface in raw_response['warnings']."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
adapter.MAX_MESSAGE_LENGTH = 20
|
|
|
|
chunk_msg_1 = SimpleNamespace(id=500)
|
|
# Every follow-up chunk fails — we should collect a warning per failure
|
|
thread_ch = SimpleNamespace(
|
|
id=555,
|
|
send=AsyncMock(side_effect=Exception("rate limited")),
|
|
)
|
|
thread = SimpleNamespace(id=555, message=chunk_msg_1, thread=thread_ch)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.name = "ideas"
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
|
|
# Long enough to produce multiple chunks
|
|
result = await adapter.send("999", "A" * 60)
|
|
|
|
# Starter message (first chunk) was delivered via create_thread, so send is
|
|
# successful overall — but follow-up chunks all failed and are reported.
|
|
assert result.success is True
|
|
assert result.message_id == "500"
|
|
warnings = (result.raw_response or {}).get("warnings") or []
|
|
assert len(warnings) >= 1
|
|
assert all("rate limited" in w for w in warnings)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_forum_post_file_creates_thread_with_attachment():
|
|
"""_forum_post_file routes file-bearing sends to create_thread with file kwarg."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
thread_ch = SimpleNamespace(id=777, send=AsyncMock())
|
|
thread = SimpleNamespace(
|
|
id=777,
|
|
message=SimpleNamespace(
|
|
id=800,
|
|
attachments=[SimpleNamespace(filename="photo.png")],
|
|
),
|
|
thread=thread_ch,
|
|
)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.name = "ideas"
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
|
|
# discord.File is a real class; build a MagicMock that looks like one
|
|
fake_file = SimpleNamespace(filename="photo.png")
|
|
|
|
result = await adapter._forum_post_file(
|
|
forum_channel,
|
|
content="here is a photo",
|
|
file=fake_file,
|
|
)
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "800"
|
|
forum_channel.create_thread.assert_awaited_once()
|
|
call_kwargs = forum_channel.create_thread.await_args.kwargs
|
|
assert call_kwargs["file"] is fake_file
|
|
assert call_kwargs["content"] == "here is a photo"
|
|
# Thread name derived from content's first line
|
|
assert call_kwargs["name"] == "here is a photo"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_forum_post_file_uses_filename_when_no_content():
|
|
"""Thread name falls back to file.filename when no content is provided."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
thread = SimpleNamespace(
|
|
id=1,
|
|
message=SimpleNamespace(
|
|
id=2,
|
|
attachments=[SimpleNamespace(filename="voice-message.ogg")],
|
|
),
|
|
thread=SimpleNamespace(id=1, send=AsyncMock()),
|
|
)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 10
|
|
forum_channel.name = "forum"
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
|
|
fake_file = SimpleNamespace(filename="voice-message.ogg")
|
|
result = await adapter._forum_post_file(forum_channel, content="", file=fake_file)
|
|
|
|
assert result.success is True
|
|
call_kwargs = forum_channel.create_thread.await_args.kwargs
|
|
# Content was empty → thread name derived from filename
|
|
assert call_kwargs["name"] == "voice-message.ogg"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_forum_post_file_creation_failure():
|
|
"""_forum_post_file returns a failed SendResult when create_thread raises."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.create_thread = AsyncMock(side_effect=Exception("missing perms"))
|
|
|
|
result = await adapter._forum_post_file(
|
|
forum_channel,
|
|
content="hi",
|
|
file=SimpleNamespace(filename="x.png"),
|
|
)
|
|
|
|
assert result.success is False
|
|
assert "missing perms" in (result.error or "")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_forum_post_file_fails_when_starter_has_no_attachments():
|
|
"""Forum create_thread can succeed yet return an attachmentless starter (#66797)."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
|
|
thread = SimpleNamespace(
|
|
id=7,
|
|
message=SimpleNamespace(id=8, attachments=[]),
|
|
thread=SimpleNamespace(id=7, send=AsyncMock()),
|
|
)
|
|
forum_channel = _discord_mod.ForumChannel()
|
|
forum_channel.id = 999
|
|
forum_channel.create_thread = AsyncMock(return_value=thread)
|
|
|
|
fake_file = SimpleNamespace(filename="clip.mp4")
|
|
result = await adapter._forum_post_file(
|
|
forum_channel,
|
|
content="video clip",
|
|
files=[fake_file],
|
|
)
|
|
|
|
assert result.success is False
|
|
assert "no files" in (result.error or "").lower()
|
|
forum_channel.create_thread.assert_awaited_once()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Typing indicator task lifecycle
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_typing_task_removed_after_api_error():
|
|
"""When typing API call fails, stale task must be removed so typing can restart."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
adapter._client = MagicMock()
|
|
adapter._client.http = MagicMock()
|
|
adapter._client.http.request = AsyncMock(side_effect=Exception("rate limited"))
|
|
adapter._typing_tasks = {}
|
|
|
|
await adapter.send_typing("12345")
|
|
await asyncio.sleep(0.1)
|
|
|
|
assert "12345" not in adapter._typing_tasks, \
|
|
"Stale task should be removed after API error"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_typing_restartable_after_error():
|
|
"""After a typing error, send_typing should start a new task (not blocked by stale entry)."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
adapter._client = MagicMock()
|
|
adapter._client.http = MagicMock()
|
|
adapter._typing_tasks = {}
|
|
|
|
# First call fails
|
|
adapter._client.http.request = AsyncMock(side_effect=Exception("503"))
|
|
await adapter.send_typing("12345")
|
|
await asyncio.sleep(0.1)
|
|
|
|
# Second call should work
|
|
adapter._client.http.request = AsyncMock()
|
|
await adapter.send_typing("12345")
|
|
|
|
assert "12345" in adapter._typing_tasks, \
|
|
"Should restart typing after previous failure"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_typing_stop_cleans_up():
|
|
"""stop_typing should remove the task from _typing_tasks."""
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
adapter._client = MagicMock()
|
|
adapter._client.http = MagicMock()
|
|
adapter._client.http.request = AsyncMock()
|
|
adapter._typing_tasks = {}
|
|
|
|
await adapter.send_typing("12345")
|
|
assert "12345" in adapter._typing_tasks
|
|
|
|
await adapter.stop_typing("12345")
|
|
assert "12345" not in adapter._typing_tasks
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# #66797 — outbound MEDIA video must reach channel.send as a real attachment
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_video_uses_path_based_files_kwarg(tmp_path, monkeypatch):
|
|
"""Regression for #66797: video MEDIA delivery must use path-based
|
|
``discord.File`` via ``files=[...]`` (same pattern as image batching).
|
|
|
|
The previous open-handle + singular ``file=`` form could return a successful
|
|
message with zero attachments after an earlier image batch on the same
|
|
channel — silent drop from the user's perspective.
|
|
"""
|
|
import plugins.platforms.discord.adapter as discord_platform
|
|
|
|
video = tmp_path / "clip.mp4"
|
|
video.write_bytes(b"\x00\x00\x00\x18ftypmp42fake")
|
|
|
|
captured = {}
|
|
|
|
class _FakeFile:
|
|
def __init__(self, fp, filename=None, **kwargs):
|
|
captured["fp"] = fp
|
|
captured["filename"] = filename
|
|
|
|
monkeypatch.setattr(discord_platform.discord, "File", _FakeFile)
|
|
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
sent_msg = SimpleNamespace(
|
|
id=4242,
|
|
attachments=[SimpleNamespace(filename="clip.mp4", url="https://cdn.example/clip.mp4")],
|
|
)
|
|
channel = SimpleNamespace(
|
|
send=AsyncMock(return_value=sent_msg),
|
|
type=0,
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: False)
|
|
|
|
result = await adapter.send_video("555", str(video))
|
|
|
|
assert result.success is True
|
|
assert result.message_id == "4242"
|
|
assert captured["fp"] == str(video)
|
|
assert captured["filename"] == "clip.mp4"
|
|
channel.send.assert_awaited_once()
|
|
send_kwargs = channel.send.await_args.kwargs
|
|
assert send_kwargs.get("file") is None
|
|
assert isinstance(send_kwargs.get("files"), list) and len(send_kwargs["files"]) == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_video_fails_loud_when_message_has_no_attachments(tmp_path, monkeypatch):
|
|
"""If Discord accepts the message but attaches nothing, fail loud (#66797)."""
|
|
import plugins.platforms.discord.adapter as discord_platform
|
|
|
|
video = tmp_path / "clip.mp4"
|
|
video.write_bytes(b"fake-mp4")
|
|
|
|
monkeypatch.setattr(
|
|
discord_platform.discord,
|
|
"File",
|
|
lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename),
|
|
)
|
|
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
# Message id present, but no attachments — the silent-drop failure mode.
|
|
sent_msg = SimpleNamespace(id=99, attachments=[])
|
|
channel = SimpleNamespace(send=AsyncMock(return_value=sent_msg), type=0)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: False)
|
|
|
|
result = await adapter.send_video("555", str(video))
|
|
|
|
assert result.success is False
|
|
assert "no files" in (result.error or "").lower()
|
|
channel.send.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deliver_media_from_response_routes_mp4_to_send_video(tmp_path, monkeypatch):
|
|
"""Streaming/post-stream dispatch must call send_video for MEDIA:.mp4."""
|
|
from gateway.platforms.base import BasePlatformAdapter, SendResult
|
|
from gateway.run import GatewayRunner
|
|
|
|
video = tmp_path / "clip.mp4"
|
|
video.write_bytes(b"fake-mp4")
|
|
image = tmp_path / "figure.png"
|
|
image.write_bytes(b"fake-png")
|
|
|
|
# Allow delivery from tmp_path in non-strict mode (default).
|
|
monkeypatch.chdir(tmp_path)
|
|
|
|
adapter = SimpleNamespace(
|
|
name="Discord",
|
|
extract_media=BasePlatformAdapter.extract_media,
|
|
extract_images=BasePlatformAdapter.extract_images,
|
|
extract_local_files=BasePlatformAdapter.extract_local_files,
|
|
send_voice=AsyncMock(return_value=SendResult(success=True, message_id="v")),
|
|
send_document=AsyncMock(return_value=SendResult(success=True, message_id="d")),
|
|
send_image_file=AsyncMock(return_value=SendResult(success=True, message_id="i")),
|
|
send_video=AsyncMock(return_value=SendResult(success=True, message_id="vid")),
|
|
send_multiple_images=AsyncMock(),
|
|
)
|
|
event = SimpleNamespace(
|
|
source=SimpleNamespace(
|
|
platform="discord",
|
|
chat_id="chat-1",
|
|
thread_id=None,
|
|
)
|
|
)
|
|
runner = SimpleNamespace(
|
|
_thread_metadata_for_source=lambda source, anchor=None: {},
|
|
_reply_anchor_for_event=lambda event: None,
|
|
)
|
|
response = (
|
|
f"Here is the figure:\n\nMEDIA:{image}\n\n"
|
|
f"And the clip:\n\nMEDIA:{video}\n"
|
|
)
|
|
|
|
await GatewayRunner._deliver_media_from_response(runner, response, event, adapter)
|
|
|
|
adapter.send_video.assert_awaited_once()
|
|
sent_path = adapter.send_video.await_args.kwargs["video_path"]
|
|
assert Path(sent_path).resolve() == video.resolve()
|
|
adapter.send_multiple_images.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_video_missing_file_fails_fast_without_touching_channel():
|
|
"""A missing MEDIA path must fail loud before any Discord I/O (#66797).
|
|
|
|
The pre-flight ``os.path.isfile`` guard turns a would-be crash inside
|
|
``discord.File`` into an actionable ``File not found`` result, and must
|
|
short-circuit before the channel is ever resolved.
|
|
"""
|
|
def _boom(*_args, **_kwargs):
|
|
raise AssertionError("channel must not be resolved for a missing file")
|
|
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
adapter._client = SimpleNamespace(get_channel=_boom, fetch_channel=AsyncMock(side_effect=_boom))
|
|
|
|
result = await adapter.send_video("555", "/no/such/clip.mp4")
|
|
|
|
assert result.success is False
|
|
assert "not found" in (result.error or "").lower()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_file_attachment_forum_uses_files_kwarg(tmp_path, monkeypatch):
|
|
"""Forum-parent delivery must also route the path-based file through the
|
|
plural ``files=[...]`` kwarg (#66797), so the create_thread starter message
|
|
carries the attachment rather than silently dropping it."""
|
|
import plugins.platforms.discord.adapter as discord_platform
|
|
|
|
video = tmp_path / "clip.mp4"
|
|
video.write_bytes(b"fake-mp4")
|
|
|
|
monkeypatch.setattr(
|
|
discord_platform.discord,
|
|
"File",
|
|
lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename),
|
|
)
|
|
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
created_thread = SimpleNamespace(
|
|
id=7,
|
|
message=SimpleNamespace(
|
|
id=8,
|
|
attachments=[SimpleNamespace(filename="clip.mp4")],
|
|
),
|
|
)
|
|
forum_channel = SimpleNamespace(
|
|
id=7,
|
|
create_thread=AsyncMock(return_value=created_thread),
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: True)
|
|
|
|
result = await adapter.send_video("555", str(video))
|
|
|
|
assert result.success is True
|
|
forum_channel.create_thread.assert_awaited_once()
|
|
thread_kwargs = forum_channel.create_thread.await_args.kwargs
|
|
assert thread_kwargs.get("file") is None
|
|
assert isinstance(thread_kwargs.get("files"), list) and len(thread_kwargs["files"]) == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_forum_send_video_fails_loud_when_starter_has_no_attachments(tmp_path, monkeypatch):
|
|
"""Forum-parent send_video must fail loud when the starter message drops attachments."""
|
|
import plugins.platforms.discord.adapter as discord_platform
|
|
|
|
video = tmp_path / "clip.mp4"
|
|
video.write_bytes(b"fake-mp4")
|
|
|
|
monkeypatch.setattr(
|
|
discord_platform.discord,
|
|
"File",
|
|
lambda fp, filename=None, **kwargs: SimpleNamespace(fp=fp, filename=filename),
|
|
)
|
|
|
|
adapter = DiscordAdapter(PlatformConfig(enabled=True, token="***"))
|
|
created_thread = SimpleNamespace(
|
|
id=7,
|
|
message=SimpleNamespace(id=8, attachments=[]),
|
|
)
|
|
forum_channel = SimpleNamespace(
|
|
id=7,
|
|
create_thread=AsyncMock(return_value=created_thread),
|
|
)
|
|
adapter._client = SimpleNamespace(
|
|
get_channel=lambda _chat_id: forum_channel,
|
|
fetch_channel=AsyncMock(),
|
|
)
|
|
monkeypatch.setattr(adapter, "_is_forum_parent", lambda _ch: True)
|
|
|
|
result = await adapter.send_video("555", str(video))
|
|
|
|
assert result.success is False
|
|
assert "no files" in (result.error or "").lower()
|
|
forum_channel.create_thread.assert_awaited_once()
|