diff --git a/src/agenthub/channels/wecom_ws.py b/src/agenthub/channels/wecom_ws.py index 3b652b7..3fb34d0 100644 --- a/src/agenthub/channels/wecom_ws.py +++ b/src/agenthub/channels/wecom_ws.py @@ -31,6 +31,7 @@ log = logging.getLogger("agenthub.wecom.ws") WS_URL = "wss://openws.work.weixin.qq.com" HEARTBEAT_S = 30 +_EOF = object() # queue sentinel: connection ended class AibotWSAdapter: @@ -66,13 +67,21 @@ class AibotWSAdapter: fut.result(timeout=self.connect_timeout + 15) # raises on auth failure def recv(self, timeout: float = 1.0) -> str | None: + """Return a raw frame, None on idle timeout, raise ConnectionError on EOF. + + Raising (rather than returning None) on EOF is what makes the channel's + outer loop see an exception and run its reconnect/backoff path. + """ if self._loop is None: - return None + raise ConnectionError("ws loop not running") fut = asyncio.run_coroutine_threadsafe(self._queue_get(timeout), self._loop) try: - return fut.result(timeout=timeout + 2) + item = fut.result(timeout=timeout + 2) except TimeoutError: return None + if item is _EOF: + raise ConnectionError("websocket closed by peer") + return item def send(self, raw: str) -> None: if self._loop is None or self._ws is None: @@ -80,8 +89,13 @@ class AibotWSAdapter: asyncio.run_coroutine_threadsafe(self._ws.send(raw), self._loop).result(timeout=10) def close(self) -> None: - if self._loop is not None: - asyncio.run_coroutine_threadsafe(self._shutdown(), self._loop).result(timeout=10) + loop = self._loop + if loop is None or loop.is_closed(): + return + try: + asyncio.run_coroutine_threadsafe(self._shutdown(), loop).result(timeout=8) + except Exception: # noqa: BLE001 + pass # best-effort; the reader thread will die with the process # -- asyncio side --------------------------------------------------------- def _run_loop(self) -> None: @@ -94,7 +108,8 @@ class AibotWSAdapter: try: return await asyncio.wait_for(self._queue.get(), timeout=timeout) except asyncio.TimeoutError: - return None + return None # idle: caller treats as "no message" + async def _connect_and_subscribe(self) -> None: import websockets @@ -139,7 +154,7 @@ class AibotWSAdapter: except Exception as e: # noqa: BLE001 log.warning("[aibot-ws] reader ended: %s", e) finally: - await self._queue.put(None) # EOF marker -> channel recv returns None, triggers reconnect + await self._queue.put(_EOF) # signals recv() to raise -> channel reconnects async def _shutdown(self) -> None: self._stop_ev.set() @@ -147,11 +162,14 @@ class AibotWSAdapter: self._hb_task.cancel() if self._ws is not None: try: - await self._ws.close() + await asyncio.wait_for(self._ws.close(), timeout=3) except Exception: # noqa: BLE001 pass self._ws = None - await self._queue.put(None) + try: + await asyncio.wait_for(self._queue.put(_EOF), timeout=1) + except Exception: # noqa: BLE001 + pass def make_ws_factory(**extra: Any) -> Callable[[dict[str, Any]], AibotWSAdapter]: diff --git a/tests/test_wecom_ws.py b/tests/test_wecom_ws.py new file mode 100644 index 0000000..dadf684 --- /dev/null +++ b/tests/test_wecom_ws.py @@ -0,0 +1,140 @@ +"""Tests for the real aibot WebSocket transport (wecom_ws.AibotWSAdapter). + +Spins a local websockets server that mimics the WeCom aibot gateway: + - expects aibot_subscribe, replies errcode 0 + - pushes an aibot_msg_callback + - records outbound frames (aibot_respond_msg stream) + - answers ping with errcode 0 +""" + +from __future__ import annotations + +import asyncio +import json +import os +import sys +import threading +import time + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) + +websockets = pytest.importorskip("websockets") + +from agenthub.channels.wecom_ws import AibotWSAdapter # noqa: E402 + + +class FakeAibotServer: + def __init__(self): + self.received: list[dict] = [] + self.port: int | None = None + self._loop: asyncio.AbstractEventLoop | None = None + self._thread: threading.Thread | None = None + self._ready = threading.Event() + self._stop = threading.Event() + + def start(self): + self._thread = threading.Thread(target=self._run, daemon=True) + self._thread.start() + assert self._ready.wait(10), "fake server did not start" + + def _run(self): + self._loop = asyncio.new_event_loop() + asyncio.set_event_loop(self._loop) + self._loop.run_until_complete(self._serve()) + + async def _serve(self): + async def handler(ws): + try: + async for raw in ws: + msg = json.loads(raw) + self.received.append(msg) + cmd = msg.get("cmd") + if cmd == "aibot_subscribe": + await ws.send(json.dumps({"headers": msg["headers"], "errcode": 0, "errmsg": "ok"})) + # push a user message right after subscribing + await asyncio.sleep(0.1) + await ws.send(json.dumps({ + "cmd": "aibot_msg_callback", + "headers": {"req_id": "seed-req"}, + "body": {"msgid": "m1", "chatid": "chatA", "chattype": "single", + "msgtype": "text", "from": {"userid": "userA"}, + "text": {"content": "hello"}}, + })) + elif cmd == "ping": + await ws.send(json.dumps({"headers": msg["headers"], "errcode": 0, "errmsg": "ok"})) + except Exception: + pass + + async with websockets.serve(handler, "127.0.0.1", 0) as server: + self.port = server.sockets[0].getsockname()[1] + self._ready.set() + await asyncio.get_running_loop().create_future() # run forever + + def stop(self): + if self._loop: + self._loop.call_soon_threadsafe(self._loop.stop) + + +def test_adapter_subscribe_receive_and_reply(): + srv = FakeAibotServer() + srv.start() + adapter = AibotWSAdapter({"bot_id": "bot1", "secret": "sec1", + "ws_url": f"ws://127.0.0.1:{srv.port}"}) + adapter.connect() + + # first outbound frame must be the subscribe with credentials + assert srv.received[0]["cmd"] == "aibot_subscribe" + assert srv.received[0]["body"] == {"bot_id": "bot1", "secret": "sec1"} + + # inbound callback should come through recv() + raw = adapter.recv(timeout=5) + assert raw is not None + frame = json.loads(raw) + assert frame["cmd"] == "aibot_msg_callback" + assert frame["body"]["text"]["content"] == "hello" + + # send a streaming reply; server must see it with the callback's req_id + adapter.send(json.dumps({ + "cmd": "aibot_respond_msg", + "headers": {"req_id": "seed-req"}, + "body": {"msgtype": "stream", "stream": {"id": "s1", "finish": False, "content": "partial"}}, + })) + deadline = time.time() + 5 + while time.time() < deadline: + if any(m.get("cmd") == "aibot_respond_msg" for m in srv.received): + break + time.sleep(0.05) + replies = [m for m in srv.received if m.get("cmd") == "aibot_respond_msg"] + assert replies and replies[0]["headers"]["req_id"] == "seed-req" + assert replies[0]["body"]["stream"]["content"] == "partial" + + adapter.close() + srv.stop() + + +def test_adapter_auth_failure_raises(): + class BadServer(FakeAibotServer): + async def _serve(self): + async def handler(ws): + async for raw in ws: + msg = json.loads(raw) + await ws.send(json.dumps({"headers": msg.get("headers", {}), "errcode": 40001, + "errmsg": "invalid secret"})) + + async with websockets.serve(handler, "127.0.0.1", 0) as server: + self.port = server.sockets[0].getsockname()[1] + self._ready.set() + await asyncio.get_running_loop().create_future() + + srv = BadServer() + srv.start() + adapter = AibotWSAdapter({"bot_id": "b", "secret": "bad", "ws_url": f"ws://127.0.0.1:{srv.port}"}) + try: + adapter.connect() + assert False, "connect() should raise on subscribe failure" + except PermissionError as e: + assert "40001" in str(e) or "subscribe failed" in str(e) + finally: + srv.stop()