Files
bot042/tests/test_channels.py
T
openbot fbb01c4c83 feat: 重构为 agent / channels / flows / db 分层架构
- agent: 新增 base.py 执行基类、execution.py 执行器、web.py 网络工具,
  middlewares/steering.py 中间件;移除旧的 agent.py
- channels: 新增 ChannelManager、registry、models 与 IM 渠道(企业微信),
  扩展 base.py
- flows: 新增 agent_task / bus / cron / scheduler / service / stream / rpc /
  processor / tasks / model_settings / builtin;移除旧的 task.py
- db: 新增 sqlite schema 与 repo 层
- docs: 新增架构说明、Channel × EventBus 设计、任务编写教程
- 依赖新增 aiosqlite / httpx / langgraph / primp / pydantic / ripgrep /
  wecom-aibot-sdk;新增 bot 命令入口
- 测试:232 passed
2026-11-09 20:32:25 +08:00

313 lines
10 KiB
Python

"""channels 协议对象与 BaseChannel 模板测试。"""
from __future__ import annotations
import asyncio
import base64
from typing import Any
import pytest
from bot042.channels.base import (
ERROR_FALLBACK_TEXT,
BaseChannel,
ChannelCredentialsError,
)
from bot042.channels.models import (
ChannelConfig,
ChannelRuntimeStatus,
ChannelSubject,
ImageContent,
InboundMessage,
MessageEvent,
MessageEventType,
TextContent,
)
class DummyChannel(BaseChannel):
channel_type = "dummy"
def __init__(self, **kwargs: Any) -> None:
super().__init__(**kwargs)
self.sent: list[tuple[str, str]] = []
async def start(self) -> None:
pass
async def stop(self) -> None:
pass
def parse_inbound(self, raw_payload: Any) -> InboundMessage:
if isinstance(raw_payload, InboundMessage):
return raw_payload
return InboundMessage(
channel_id=self.channel_id,
content=[TextContent(text=str(raw_payload))],
channel_subject=ChannelSubject(subject_id="u1"),
)
async def _send_text(self, subject: ChannelSubject, text: str) -> None:
self.sent.append(("text", text))
async def _send_content(self, subject: ChannelSubject, parts: list) -> None:
self.sent.append(("content", str(len(parts))))
async def _send_media(self, subject: ChannelSubject, media: Any) -> None:
self.sent.append(("media", media.type))
def _message(text: str = "hi") -> InboundMessage:
return InboundMessage(
channel_id="dummy",
content=[TextContent(text=text)],
channel_subject=ChannelSubject(subject_id="u1", display_name="U"),
)
# --------------------------------------------------------------------- models
def test_inbound_message_text_and_media() -> None:
msg = InboundMessage(
channel_id="c1",
content=[TextContent(text="hi"), TextContent(text="there"), ImageContent(url="u")],
)
assert msg.text == "hi\nthere"
assert msg.has_media is True
def test_message_event_factories() -> None:
assert MessageEvent.text("x").type == MessageEventType.MESSAGE
assert MessageEvent.delta("x").type == MessageEventType.DELTA
assert MessageEvent.typing().type == MessageEventType.TYPING
assert MessageEvent.flush().type == MessageEventType.FLUSH
assert MessageEvent.thinking("t").type == MessageEventType.THINKING
assert MessageEvent.thinking_delta("t").type == MessageEventType.THINKING_DELTA
assert MessageEvent.tool_start("t").metadata["tool_name"] == "t"
assert MessageEvent.tool_end("t").metadata["tool_name"] == "t"
assert MessageEvent.completed().type == MessageEventType.COMPLETED
assert MessageEvent.error_event("boom").error == "boom"
def test_channel_config_from_dict_and_credentials() -> None:
class DemoConfig(ChannelConfig):
api_key: str = ""
required_credentials = ("api_key",)
cfg = DemoConfig.from_dict({"api_key": " k ", "unknown": 1})
assert cfg.api_key == "k"
assert cfg.missing_credentials() == []
assert DemoConfig().missing_credentials() == ["api_key"]
def test_credentials_error_fields() -> None:
exc = ChannelCredentialsError("wecom", ["bot_id", "secret"])
assert exc.kind == "wecom"
assert exc.missing == ["bot_id", "secret"]
assert isinstance(exc, ValueError)
def test_runtime_status_defaults() -> None:
st = ChannelRuntimeStatus()
assert st.connected is False
assert st.reason is None
# ----------------------------------------------------------------- BaseChannel
def test_handle_inbound_accumulates_deltas() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.delta("Hello ")
yield MessageEvent.delta("World")
yield MessageEvent.completed()
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [("text", "Hello World")]
assert channel.get_subject("u1") is not None
def test_handle_inbound_flush_splits_messages() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.delta("part1")
yield MessageEvent.flush()
yield MessageEvent.delta("part2")
yield MessageEvent.completed()
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [("text", "part1"), ("text", "part2")]
def test_handle_inbound_message_event_immediate() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.delta("buffered")
yield MessageEvent.text("now")
yield MessageEvent.completed()
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [("text", "buffered"), ("text", "now")]
def test_handle_inbound_thinking_gated_by_config() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.thinking("why")
yield MessageEvent.thinking_delta("why2")
yield MessageEvent.text("answer")
yield MessageEvent.completed()
hidden = DummyChannel(processor=processor)
asyncio.run(hidden.handle_inbound(_message()))
assert hidden.sent == [("text", "answer")]
shown = DummyChannel(processor=processor, config=ChannelConfig(show_thinking=True))
asyncio.run(shown.handle_inbound(_message()))
assert ("text", "[思考] why") in shown.sent
assert ("text", "[思考] why2") in shown.sent
def test_handle_inbound_tool_hints() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.tool_start("t1")
yield MessageEvent.tool_end("t1")
yield MessageEvent.completed()
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [("text", "[工具] t1 开始执行"), ("text", "[工具] t1 执行完成")]
def test_handle_inbound_error_event_stops_stream() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.delta("leftover")
yield MessageEvent.error_event("出错了")
yield MessageEvent.text("never")
yield MessageEvent.completed()
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [("text", "leftover"), ("text", "出错了")]
def test_handle_inbound_processor_exception_falls_back() -> None:
async def processor(msg: InboundMessage):
yield MessageEvent.delta("partial")
raise RuntimeError("boom")
channel = DummyChannel(processor=processor)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent == [
("text", "partial"),
("text", "处理消息时出错,请稍后再试。"),
]
def test_handle_inbound_requires_processor() -> None:
channel = DummyChannel()
with pytest.raises(RuntimeError, match="未配置消息处理器"):
asyncio.run(channel.handle_inbound(_message()))
def test_merge_inbound_and_session_key() -> None:
channel = DummyChannel()
m1 = InboundMessage(
channel_id="d",
content=[TextContent(text="a")],
channel_subject=ChannelSubject(subject_id="u1"),
)
m2 = InboundMessage(
channel_id="d",
content=[TextContent(text="b")],
channel_subject=ChannelSubject(subject_id="u1"),
)
merged = channel.merge_inbound([m1, m2])
assert merged.text == "a\nb"
assert channel.get_session_key(m1) == "u1"
assert channel.should_batch_inbound(m1) is True
def test_merge_inbound_keeps_runtime_metadata_by_reference() -> None:
"""合批不能深拷贝 metadata:里面可能挂着不可拷贝的渠道运行时对象。"""
channel = DummyChannel()
class LiveClient:
def __deepcopy__(self, memo: dict) -> LiveClient:
raise TypeError("live client cannot be deep-copied")
client = LiveClient()
m1 = InboundMessage(
channel_id="d",
content=[TextContent(text="a")],
channel_subject=ChannelSubject(subject_id="u1"),
metadata={"client": client},
timestamp=2.0,
)
m2 = InboundMessage(
channel_id="d",
content=[TextContent(text="b")],
channel_subject=ChannelSubject(subject_id="u1"),
timestamp=1.0,
)
merged = channel.merge_inbound([m1, m2])
assert merged.text == "a\nb"
assert merged.timestamp == 1.0
assert merged.metadata["client"] is client # 运行时对象按引用保留
assert merged.metadata is not m1.metadata # 映射本身独立,改合批结果不影响原消息
def test_load_media_bytes_priority(tmp_path) -> None:
channel = DummyChannel()
inline = ImageContent(data=base64.b64encode(b"img-bytes").decode(), mime_type="image/png")
raw, mime = asyncio.run(channel.load_media_bytes(inline))
assert raw == b"img-bytes"
assert mime == "image/png"
file_part = ImageContent(local_path=str(tmp_path / "x.png"))
(tmp_path / "x.png").write_bytes(b"file-bytes")
raw, _mime = asyncio.run(channel.load_media_bytes(file_part))
assert raw == b"file-bytes"
with pytest.raises(ValueError, match="data/local_path/url"):
asyncio.run(channel.load_media_bytes(ImageContent()))
def test_push_subject_merges_known_metadata() -> None:
channel = DummyChannel()
known = ChannelSubject(subject_id="u1", display_name="U", chat_type="direct", metadata={"k": "v"})
channel._known_subjects["u1"] = known
resolved = channel.resolve_push_subject(ChannelSubject(subject_id="u1"))
assert resolved.metadata["k"] == "v"
assert resolved.display_name == "U"
assert resolved.chat_type == "direct"
def test_notify_closed_wakes_waiters() -> None:
channel = DummyChannel()
async def _run() -> bool:
waiter = asyncio.create_task(channel.wait_closed())
channel.notify_closed()
await asyncio.wait_for(waiter, timeout=1)
return True
assert asyncio.run(_run()) is True
def test_process_inbound_tolerates_sync_processor_error() -> None:
"""处理器同步抛出:走统一兜底(不发散异常),并给出兜底提示。"""
def boom(_msg: InboundMessage):
raise RuntimeError("boom")
channel = DummyChannel(typing_keepalive_interval=0.01)
channel.attach(lambda payload: None, processor=boom)
asyncio.run(channel.handle_inbound(_message()))
assert channel.sent[-1] == ("text", ERROR_FALLBACK_TEXT)