116 lines
5.4 KiB
Python
116 lines
5.4 KiB
Python
"""Test-only in-memory stub connector implementing RelayTransport.
|
|
|
|
MUST stay under tests/ — never under plugins/ or gateway/ (a CI guard in
|
|
test_no_stub_leak.py asserts this). It lets Phase 1 prove the gateway side of
|
|
the relay end-to-end with zero dependency on the real (Node) connector.
|
|
|
|
The stub:
|
|
- hands back a fixed CapabilityDescriptor at handshake,
|
|
- lets a test push synthetic inbound MessageEvents (push_inbound),
|
|
- records every outbound action (sent/interrupts) for assertions,
|
|
- answers get_chat_info from a small fixture map.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from gateway.platforms.base import MessageEvent
|
|
from gateway.relay.descriptor import CapabilityDescriptor
|
|
from gateway.relay.transport import InboundHandler
|
|
|
|
|
|
class StubConnector:
|
|
"""In-memory RelayTransport for tests."""
|
|
|
|
def __init__(self, descriptor: CapabilityDescriptor) -> None:
|
|
self._descriptor = descriptor
|
|
self._inbound: Optional[InboundHandler] = None
|
|
self._interrupt_inbound: Optional[Any] = None
|
|
self._passthrough: Optional[Any] = None
|
|
self.connected = False
|
|
self.sent: List[Dict[str, Any]] = []
|
|
# Per-frame egress platform recorded alongside each sent action (Phase 1.5).
|
|
self.sent_platforms: List[Optional[str]] = []
|
|
self.interrupts: List[Dict[str, Any]] = []
|
|
self.follow_ups: List[Dict[str, Any]] = []
|
|
self.follow_up_platforms: List[Optional[str]] = []
|
|
# The fronted (platform, bot_id) identity set (Phase 1.5). Mirrors the real
|
|
# transport's _identities so RelayAdapter._platform_is_fronted resolves; a
|
|
# single-identity default keeps existing tests' behaviour unchanged.
|
|
self._identities: List[tuple] = [(descriptor.platform, "")]
|
|
self.chat_info: Dict[str, Dict[str, Any]] = {}
|
|
# Canned result for the next send_outbound (override per-test).
|
|
self.next_send_result: Dict[str, Any] = {"success": True, "message_id": "m1"}
|
|
# Canned result for the next send_follow_up (override per-test). Default
|
|
# mimics a resolved capability egress; set success=False to simulate an
|
|
# absent/expired capability or a tenant mismatch on the connector side.
|
|
self.next_follow_up_result: Dict[str, Any] = {"success": True, "message_id": "f1"}
|
|
|
|
async def connect(self, *, is_reconnect: bool = False) -> bool:
|
|
self.connected = True
|
|
return True
|
|
|
|
async def disconnect(self) -> None:
|
|
self.connected = False
|
|
|
|
async def handshake(self) -> CapabilityDescriptor:
|
|
return self._descriptor
|
|
|
|
def set_inbound_handler(self, handler: InboundHandler) -> None:
|
|
self._inbound = handler
|
|
|
|
def set_interrupt_inbound_handler(self, handler: Any) -> None:
|
|
"""Mirror the real WS transport: the adapter registers its interrupt
|
|
bridge here so connector→gateway interrupt_inbound frames route to it."""
|
|
self._interrupt_inbound = handler
|
|
|
|
def set_passthrough_handler(self, handler: Any) -> None:
|
|
"""Mirror the real WS transport: the adapter registers its passthrough
|
|
bridge here so connector→gateway passthrough_forward frames route to it
|
|
(Phase 5 §5.1)."""
|
|
self._passthrough = handler
|
|
|
|
async def send_outbound(
|
|
self, action: Dict[str, Any], *, platform: Optional[str] = None
|
|
) -> Dict[str, Any]:
|
|
# Record the per-frame egress platform (Phase 1.5) alongside the action so
|
|
# tests can assert which platform a reply was tagged for.
|
|
self.sent.append(action)
|
|
self.sent_platforms.append(platform)
|
|
if action.get("op") == "send":
|
|
return dict(self.next_send_result)
|
|
return {"success": True}
|
|
|
|
async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
|
|
return self.chat_info.get(chat_id, {"name": chat_id, "type": "dm"})
|
|
|
|
async def send_interrupt(self, session_key: str, reason: Optional[str] = None) -> None:
|
|
self.interrupts.append({"session_key": session_key, "reason": reason})
|
|
|
|
async def send_follow_up(
|
|
self, action: Dict[str, Any], *, platform: Optional[str] = None
|
|
) -> Dict[str, Any]:
|
|
self.follow_ups.append(action)
|
|
self.follow_up_platforms.append(platform)
|
|
return dict(self.next_follow_up_result)
|
|
|
|
# ── test driver ──────────────────────────────────────────────────────
|
|
async def push_inbound(self, event: MessageEvent) -> None:
|
|
"""Simulate the connector delivering a normalized inbound event."""
|
|
if self._inbound is None:
|
|
raise RuntimeError("no inbound handler registered (call adapter.connect first)")
|
|
await self._inbound(event)
|
|
|
|
async def push_interrupt(self, session_key: str, chat_id: str) -> None:
|
|
"""Simulate the connector delivering an interrupt_inbound over the WS."""
|
|
if self._interrupt_inbound is None:
|
|
raise RuntimeError("no interrupt_inbound handler registered (call adapter.connect first)")
|
|
await self._interrupt_inbound(session_key, chat_id)
|
|
|
|
async def push_passthrough(self, forward: Any, buffer_id: Optional[str] = None) -> None:
|
|
"""Simulate the connector forwarding a passthrough request over the WS (§5.1)."""
|
|
if self._passthrough is None:
|
|
raise RuntimeError("no passthrough handler registered (call adapter.connect first)")
|
|
await self._passthrough(forward, buffer_id)
|