Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
test(bridge): cover the app sender whose first post is always dropped
Louis Amaudruz6f0d23c13cd7
diff --git a/core/tests/switch_core/bridges/collaboration/test_bridge_unknown_member_first_message.py b/core/tests/switch_core/bridges/collaboration/test_bridge_unknown_member_first_message.pyindex 7cf01da09..0f02719df 100644--- a/core/tests/switch_core/bridges/collaboration/test_bridge_unknown_member_first_message.py+++ b/core/tests/switch_core/bridges/collaboration/test_bridge_unknown_member_first_message.py@@ -15,9 +15,20 @@ from switch_core.bridges.collaboration.models import InboundMessage# that join is rejected by the homeserver, so the triggering message vanishes.# _ensure_user_in_matrix_room must therefore block until the join is observed,# and must refuse to hand back a puppet that never joined.+#+# For a Slack app the same drop is not a race but a certainty. Joins are keyed on+# the `user` of a member_joined_channel event, whereas an app posting without a+# `user` is keyed on its `bot_id` (see SlackAdapter._handle_message_event). A+# `B…` id therefore never matches a join-time identity, so an app is never+# pre-warmed and always arrives here unknown — its first post hits the unjoined+# window every single time.MATRIX_ROOM_ID = "!matrix:switch.local"+# Slack bot id of a third-party app, as the adapter reports it for a post with no+# `user` field.+APP_SENDER_ID = "BDATADOG"+class _FakePuppet:"""Stands in for a ClientBase puppet whose join lands after the invite."""@@ -50,15 +61,28 @@ class _FakePuppet:return "$event-1"-def _bridge(puppet: _FakePuppet) -> SimpleNamespace:+def _bridge(+ puppet: _FakePuppet, *, known_puppets: dict[str, str] | None = None+) -> SimpleNamespace:async def _ensure_client_in_room(room_id: str, client_id: str) -> None:return None # invite only — the join is asynchronous, as in production- return SimpleNamespace(- _user_puppets={"ext-alice": "client-1"},+ created: list[tuple[str, str]] = []++ async def _create_puppet(external_user_id: str, external_username: str) -> str:+ created.append((external_user_id, external_username))+ return "client-new"++ bridge = SimpleNamespace(+ _user_puppets={"ext-alice": "client-1"}+ if known_puppets is None+ else known_puppets,_client_lifecycle=SimpleNamespace(get=lambda _id: puppet),_room_service=SimpleNamespace(ensure_client_in_room=_ensure_client_in_room),+ _create_puppet=_create_puppet,)+ bridge.created_puppets = created+ return bridgeasync def test_waits_for_puppet_join_before_returning() -> None:@@ -105,6 +129,82 @@ async def test_returns_none_when_join_never_lands(assert result is None+async def test_app_sender_puppet_is_provisioned_then_awaited() -> None:+ # An app is never pre-warmed by a join, so it always arrives with no puppet:+ # the provisioning branch runs, and the join must still be awaited before the+ # puppet is handed back. Without the wait this returns a puppet that is only+ # invited, and the app's very first post is lost — every time, not sometimes.+ puppet = _FakePuppet()+ bridge = _bridge(puppet, known_puppets={})++ task = asyncio.create_task(+ BridgeCore._ensure_user_in_matrix_room(+ bridge,+ external_user_id=APP_SENDER_ID,+ external_username="Datadog",+ room_id="room-uuid",+ matrix_room_id=MATRIX_ROOM_ID,+ )+ )+ await asyncio.sleep(0)++ assert bridge.created_puppets == [(APP_SENDER_ID, "Datadog")]+ assert not task.done()++ puppet.complete_join()+ assert await task is puppet+ assert puppet.wait_joined_calls == [+ (MATRIX_ROOM_ID, bridge_core_module.PUPPET_JOIN_TIMEOUT)+ ]+++async def test_first_message_from_app_sender_is_relayed() -> None:+ # End-to-end for the guaranteed case: a third-party app posts into a channel+ # for the first time (bot-id sender, no puppet anywhere) and the post must+ # land in the room rather than being swallowed.+ puppet = _FakePuppet()+ relayed: list[tuple[str, str]] = []++ async def _is_registered_agent(_name: str) -> bool:+ return False++ async def _record_message_map(**kwargs: str) -> None:+ relayed.append((kwargs["matrix_event_id"], kwargs["external_post_id"]))++ inner = _bridge(puppet, known_puppets={})++ async def _ensure_user_in_matrix_room(**kwargs: object) -> object:+ # Complete the join as the real invite/join round-trip would, so the+ # relay below exercises the post-join send rather than a stubbed one.+ asyncio.get_running_loop().call_soon(puppet.complete_join)+ return await BridgeCore._ensure_user_in_matrix_room(inner, **kwargs) # type: ignore[arg-type]++ bridge = SimpleNamespace(+ _is_registered_agent=_is_registered_agent,+ _ensure_user_in_matrix_room=_ensure_user_in_matrix_room,+ _record_message_map=_record_message_map,+ _adapter=SimpleNamespace(translate_inbound=lambda text: text),+ _channel_to_room={"chan-1": ("room-uuid", MATRIX_ROOM_ID)},+ _channel_locks={},+ )++ await BridgeCore._handle_inbound_message(+ bridge,+ InboundMessage(+ channel_id="chan-1",+ channel_type="channel_public",+ sender_id=APP_SENDER_ID,+ sender_name="Datadog",+ content="Triggered: container restart spike",+ message_ref="slack-post-1",+ ),+ )++ assert inner.created_puppets == [(APP_SENDER_ID, "Datadog")]+ assert puppet.sent == [(MATRIX_ROOM_ID, "Triggered: container restart spike")]+ assert relayed == [("$event-1", "slack-post-1")]++async def test_first_message_from_unknown_member_is_relayed() -> None:puppet = _FakePuppet()relayed: list[tuple[str, str]] = []