"""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)