3db9b3e616
The relay outbound surface had send/edit/typing but no way to act on a SHARED-identity capability (e.g. a Discord interaction follow-up token, ~15min) that the connector captured + stripped at the edge. Under A2 that credential never reaches the gateway, so the gateway can't just 'send with the token' — it needs a semantic op naming the session it's already in. Adds the follow_up op end to end on the gateway side: - RelayTransport.send_follow_up(action): protocol method. Action carries op='follow_up' + session_key + kind + content (+ metadata) and NO token. - RelayAdapter.send_follow_up(session_key, kind, content, metadata): builds that action and returns a SendResult. The connector resolves the real capability (its resolveOutboundCapability), enforces the tenant match so tenant B can't wield tenant A's capability, and egresses; success=False when the capability is absent/expired/mismatched (nothing to retry — a leaked gateway holds zero capability material). - StubConnector records follow_ups + a canned next_follow_up_result. Tests: round-trips without a token; the wire action carries only session refs (no credential value field — the 'kind' string is a type ref, not the secret); failure surfaces when the connector can't resolve; no-transport fails cleanly. 55 passed. §4 doc entry follows in the contract-rewrite commit.
76 lines
3.2 KiB
Python
76 lines
3.2 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.connected = False
|
|
self.sent: List[Dict[str, Any]] = []
|
|
self.interrupts: List[Dict[str, Any]] = []
|
|
self.follow_ups: List[Dict[str, Any]] = []
|
|
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) -> 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
|
|
|
|
async def send_outbound(self, action: Dict[str, Any]) -> Dict[str, Any]:
|
|
self.sent.append(action)
|
|
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]) -> Dict[str, Any]:
|
|
self.follow_ups.append(action)
|
|
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)
|