Skip to content

Self-improving AI Employees for everyone

test(scaling): wire harness services onto container + retarget trigger patches

trohitg2d6ffdb0a5be
diff --git a/server/tests/conftest.py b/server/tests/conftest.py
index 0a80d3ae..692e76da 100644
--- a/server/tests/conftest.py
+++ b/server/tests/conftest.py
@@ -119,7 +119,35 @@ async def harness():
Imported lazily so the conftest stubs above land before NodeExecutor pulls
in its handler chain.
+
+ Side-effects:
+ - Registers the harness's service mocks (ai, android, maps, text) in the
+ active-services registry so any `patched_container(...)` call the test
+ makes also wires those onto `core.container.container`. Scaling-branch
+ plugins resolve services via `container.X()` rather than
+ NodeExecutor-injected services, so without this the harness's
+ `execute_chat` / `execute_action` mocks would be orphaned.
+ - Installs a baseline `patched_container()` for the life of the fixture
+ so tests that don't explicitly patch the container still see wired
+ services (and callers of `ApiKeyCredential.resolve()` can fail cleanly
+ with PermissionError instead of calling the real credentials db).
"""
from tests.nodes._harness import NodeTestHarness
+ from tests.nodes._mocks import (
+ register_harness_services,
+ clear_harness_services,
+ patched_container,
+ )
- return NodeTestHarness()
+ h = NodeTestHarness()
+ register_harness_services(
+ ai_service=h.ai_service,
+ android_service=h.android_service,
+ maps_service=h.maps_service,
+ text_service=h.text_service,
+ )
+ try:
+ with patched_container():
+ yield h
+ finally:
+ clear_harness_services()
diff --git a/server/tests/nodes/_mocks.py b/server/tests/nodes/_mocks.py
index cd9d576f..ba7cad98 100644
--- a/server/tests/nodes/_mocks.py
+++ b/server/tests/nodes/_mocks.py
@@ -12,6 +12,32 @@ from typing import Any, Dict, Iterator, Optional
from unittest.mock import AsyncMock, MagicMock, patch
+# ---------------------- harness service registry ---------------------- #
+#
+# Tests commonly set `harness.ai_service.execute_chat = AsyncMock(...)` then
+# call `harness.execute("..." )`. On the plugin-refactored scaling branch
+# the plugin reaches `container.ai_service()` instead of the harness's
+# injected service, so without wiring the harness mocks onto the container
+# the assignment is a no-op.
+#
+# The `harness` fixture registers its services here; every `patched_container`
+# call auto-wires them onto the container unless the test passes its own
+# service instance. This keeps existing `patched_container(auth_api_keys=...)`
+# call sites working without editing per-test files.
+_ACTIVE_HARNESS_SERVICES: Dict[str, Any] = {}
+
+
+def register_harness_services(**services: Any) -> None:
+ """Install service mocks from the active harness for `patched_container`
+ to pick up. Called by the `harness` fixture."""
+ _ACTIVE_HARNESS_SERVICES.clear()
+ _ACTIVE_HARNESS_SERVICES.update({k: v for k, v in services.items() if v is not None})
+
+
+def clear_harness_services() -> None:
+ _ACTIVE_HARNESS_SERVICES.clear()
+
+
# ---------------------- container patches ---------------------- #
@@ -71,14 +97,21 @@ def patched_container(
container_mock.auth_service = MagicMock(return_value=auth_service)
container_mock.database = MagicMock(return_value=db_mock)
- if ai_service is not None:
- container_mock.ai_service = MagicMock(return_value=ai_service)
- if android_service is not None:
- container_mock.android_service = MagicMock(return_value=android_service)
- if maps_service is not None:
- container_mock.maps_service = MagicMock(return_value=maps_service)
- if text_service is not None:
- container_mock.text_service = MagicMock(return_value=text_service)
+ # Explicit kwargs win; otherwise fall back to the active harness registry
+ # so tests that only pass `auth_api_keys=` still see their services wired.
+ effective_ai = ai_service if ai_service is not None else _ACTIVE_HARNESS_SERVICES.get("ai_service")
+ effective_android = android_service if android_service is not None else _ACTIVE_HARNESS_SERVICES.get("android_service")
+ effective_maps = maps_service if maps_service is not None else _ACTIVE_HARNESS_SERVICES.get("maps_service")
+ effective_text = text_service if text_service is not None else _ACTIVE_HARNESS_SERVICES.get("text_service")
+
+ if effective_ai is not None:
+ container_mock.ai_service = MagicMock(return_value=effective_ai)
+ if effective_android is not None:
+ container_mock.android_service = MagicMock(return_value=effective_android)
+ if effective_maps is not None:
+ container_mock.maps_service = MagicMock(return_value=effective_maps)
+ if effective_text is not None:
+ container_mock.text_service = MagicMock(return_value=effective_text)
with patch("core.container.container", container_mock):
yield container_mock
diff --git a/server/tests/nodes/test_telegram_social.py b/server/tests/nodes/test_telegram_social.py
index aa376930..bbe8f942 100644
--- a/server/tests/nodes/test_telegram_social.py
+++ b/server/tests/nodes/test_telegram_social.py
@@ -226,10 +226,26 @@ class TestTelegramSend:
# ============================================================================
-def _make_waiter_stub(*, canned_event=None, is_trigger=True):
- """Fake event_waiter module with just the methods the trigger path calls."""
+def _make_waiter_stub(*, canned_event=None, is_trigger=True, wait_side_effect=None):
+ """Fake event_waiter module with just the methods the trigger path calls.
+
+ Scaling-branch plugin trigger does `waiter = event_waiter.register(...)`
+ (sync) and then `await waiter.future`, so `register` is a sync MagicMock
+ and `waiter.future` is a pre-resolved asyncio.Future (or raises the
+ side-effect exception when awaited).
+ """
+ import asyncio
+
+ loop = asyncio.get_event_loop()
+ future = loop.create_future()
+ if wait_side_effect is not None:
+ future.set_exception(wait_side_effect)
+ else:
+ future.set_result(canned_event or {})
+
waiter_obj = MagicMock(name="Waiter")
waiter_obj.id = "waiter-test-id"
+ waiter_obj.future = future
stub = MagicMock(name="event_waiter_module")
stub.is_trigger_node = MagicMock(return_value=is_trigger)
@@ -240,8 +256,12 @@ def _make_waiter_stub(*, canned_event=None, is_trigger=True):
display_name="Telegram Message",
)
)
- stub.register = AsyncMock(return_value=waiter_obj)
- stub.wait_for_event = AsyncMock(return_value=canned_event or {})
+ stub.register = MagicMock(return_value=waiter_obj)
+ # Kept for back-compat with tests still asserting wait_for_event calls.
+ if wait_side_effect is not None:
+ stub.wait_for_event = AsyncMock(side_effect=wait_side_effect)
+ else:
+ stub.wait_for_event = AsyncMock(return_value=canned_event or {})
stub.get_backend_mode = MagicMock(return_value="asyncio.Future")
stub.cancel = MagicMock(return_value=True)
stub.dispatch = MagicMock(return_value=1)
@@ -270,8 +290,8 @@ class TestTelegramReceive:
waiter = _make_waiter_stub(canned_event=self.CANNED)
with _patch_telegram_service(svc), patched_broadcaster(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"telegramReceive",
{"senderFilter": "all", "contentTypeFilter": "all"},
@@ -280,16 +300,16 @@ class TestTelegramReceive:
harness.assert_envelope(result, success=True)
assert result["result"]["text"] == "hello from alice"
assert result["result"]["chat_id"] == 555
- waiter.register.assert_awaited_once()
- waiter.wait_for_event.assert_awaited_once()
+ # Plugin trigger calls register synchronously and awaits waiter.future.
+ waiter.register.assert_called_once()
async def test_bot_not_connected_returns_error(self, harness):
svc = _make_telegram_service(connected=False)
waiter = _make_waiter_stub(canned_event=self.CANNED)
with _patch_telegram_service(svc), patched_broadcaster(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"telegramReceive",
{"senderFilter": "all"},
@@ -297,19 +317,18 @@ class TestTelegramReceive:
harness.assert_envelope(result, success=False)
assert "not connected" in result["error"].lower()
- # Must NOT have registered a waiter when bot is offline
- waiter.register.assert_not_awaited()
+ # Must NOT have registered a waiter when bot is offline (sync call).
+ waiter.register.assert_not_called()
async def test_cancellation_propagates_as_error(self, harness):
import asyncio
svc = _make_telegram_service(connected=True, owner_chat_id=1)
- waiter = _make_waiter_stub()
- waiter.wait_for_event = AsyncMock(side_effect=asyncio.CancelledError())
+ waiter = _make_waiter_stub(wait_side_effect=asyncio.CancelledError())
with _patch_telegram_service(svc), patched_broadcaster(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"telegramReceive",
{"senderFilter": "all"},
@@ -330,7 +349,7 @@ class TestSocialSend:
return_value={"success": True, "message_id": "wamid.xyz"}
)
- with patch("routers.whatsapp.handle_whatsapp_send", whatsapp_send):
+ with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
result = await harness.execute(
"socialSend",
{
@@ -360,7 +379,7 @@ class TestSocialSend:
# recipientType=phone but no phone param -> ValueError inside handler
whatsapp_send = AsyncMock()
- with patch("routers.whatsapp.handle_whatsapp_send", whatsapp_send):
+ with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
result = await harness.execute(
"socialSend",
{
@@ -379,7 +398,7 @@ class TestSocialSend:
# Any non-whatsapp channel should surface as a failed envelope.
whatsapp_send = AsyncMock()
- with patch("routers.whatsapp.handle_whatsapp_send", whatsapp_send):
+ with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
result = await harness.execute(
"socialSend",
{
@@ -400,7 +419,7 @@ class TestSocialSend:
return_value={"success": False, "error": "rpc boom"}
)
- with patch("routers.whatsapp.handle_whatsapp_send", whatsapp_send):
+ with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
result = await harness.execute(
"socialSend",
{
diff --git a/server/tests/nodes/test_whatsapp.py b/server/tests/nodes/test_whatsapp.py
index 0e7c5865..f1a84cf2 100644
--- a/server/tests/nodes/test_whatsapp.py
+++ b/server/tests/nodes/test_whatsapp.py
@@ -5,9 +5,9 @@ These tests freeze the input -> output behaviour documented in
to the Go `whatsapp-rpc` service via a WebSocket RPC client in
`routers/whatsapp.py`. We patch the two entry points the handlers use:
- - `routers.whatsapp.handle_whatsapp_send` - sending messages
- - `routers.whatsapp.whatsapp_rpc_call` - generic RPC calls
- - `routers.whatsapp.handle_whatsapp_chat_history` - chat history RPC
+ - `services.whatsapp_service.handle_whatsapp_send` - sending messages
+ - `services.whatsapp_service.whatsapp_rpc_call` - generic RPC calls
+ - `services.whatsapp_service.handle_whatsapp_chat_history` - chat history RPC
For `whatsappReceive` we use the same event-waiter stub pattern as
`test_telegram_social.py` - patching the module reference imported by both
@@ -32,15 +32,15 @@ pytestmark = pytest.mark.node_contract
def _patch_whatsapp_send(return_value):
- """Patch routers.whatsapp.handle_whatsapp_send at the import site."""
+ """Patch services.whatsapp_service.handle_whatsapp_send at the import site."""
return patch(
- "routers.whatsapp.handle_whatsapp_send",
+ "services.whatsapp_service.handle_whatsapp_send",
new=AsyncMock(return_value=return_value),
)
def _patch_rpc_call(return_value=None, *, side_effect=None):
- """Patch routers.whatsapp.whatsapp_rpc_call.
+ """Patch services.whatsapp_service.whatsapp_rpc_call.
``return_value`` may be a dict or list. ``side_effect`` may be a callable
for per-method routing.
@@ -50,12 +50,12 @@ def _patch_rpc_call(return_value=None, *, side_effect=None):
kwargs["side_effect"] = side_effect
else:
kwargs["return_value"] = return_value if return_value is not None else {}
- return patch("routers.whatsapp.whatsapp_rpc_call", new=AsyncMock(**kwargs))
+ return patch("services.whatsapp_service.whatsapp_rpc_call", new=AsyncMock(**kwargs))
def _patch_chat_history_handler(return_value):
return patch(
- "routers.whatsapp.handle_whatsapp_chat_history",
+ "services.whatsapp_service.handle_whatsapp_chat_history",
new=AsyncMock(return_value=return_value),
)
@@ -95,7 +95,7 @@ class TestWhatsappSend:
return {"success": True}
with patch(
- "routers.whatsapp.handle_whatsapp_send",
+ "services.whatsapp_service.handle_whatsapp_send",
new=AsyncMock(side_effect=fake_send),
), patch(
"services.markdown_formatter.to_whatsapp",
@@ -325,9 +325,28 @@ class TestWhatsappDb:
def _make_waiter_stub(*, canned_event=None, is_trigger=True, wait_side_effect=None):
- """Fake event_waiter module stub for the generic trigger path."""
+ """Fake event_waiter module stub for the generic trigger path.
+
+ Scaling-branch plugin trigger does::
+
+ waiter = event_waiter.register(...) # sync
+ event_data = await waiter.future # awaitable
+
+ So `register` is a sync MagicMock and `waiter_obj.future` is a
+ pre-resolved asyncio.Future (or raises the side-effect exception).
+ """
+ import asyncio
+
+ loop = asyncio.get_event_loop()
+ future = loop.create_future()
+ if wait_side_effect is not None:
+ future.set_exception(wait_side_effect)
+ else:
+ future.set_result(canned_event or {})
+
waiter_obj = MagicMock(name="Waiter")
waiter_obj.id = "waiter-test-id"
+ waiter_obj.future = future
stub = MagicMock(name="event_waiter_module")
stub.is_trigger_node = MagicMock(return_value=is_trigger)
@@ -338,7 +357,8 @@ def _make_waiter_stub(*, canned_event=None, is_trigger=True, wait_side_effect=No
display_name="WhatsApp Message",
)
)
- stub.register = AsyncMock(return_value=waiter_obj)
+ stub.register = MagicMock(return_value=waiter_obj)
+ # Kept for back-compat with tests still asserting wait_for_event calls.
if wait_side_effect is not None:
stub.wait_for_event = AsyncMock(side_effect=wait_side_effect)
else:
@@ -368,8 +388,8 @@ class TestWhatsappReceive:
waiter = _make_waiter_stub(canned_event=self.CANNED)
with patched_broadcaster(), patched_container(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"whatsappReceive",
{
@@ -383,8 +403,8 @@ class TestWhatsappReceive:
payload = result["result"]
assert payload["text"] == "hello there"
assert payload["sender_phone"] == "15551234567"
- waiter.register.assert_awaited_once()
- waiter.wait_for_event.assert_awaited_once()
+ # Plugin trigger calls register synchronously; waiter.future is awaited.
+ waiter.register.assert_called_once()
async def test_cancellation_propagates_as_error(self, harness):
import asyncio
@@ -392,8 +412,8 @@ class TestWhatsappReceive:
waiter = _make_waiter_stub(wait_side_effect=asyncio.CancelledError())
with patched_broadcaster(), patched_container(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"whatsappReceive",
{"filter": "all"},
@@ -406,8 +426,8 @@ class TestWhatsappReceive:
waiter = _make_waiter_stub(wait_side_effect=RuntimeError("redis stream down"))
with patched_broadcaster(), patched_container(), patch(
- "services.node_executor.event_waiter", waiter
- ), patch("services.handlers.triggers.event_waiter", waiter):
+ "services.event_waiter", waiter
+ ):
result = await harness.execute(
"whatsappReceive",
{"filter": "keywords", "keywords": "urgent,fire"},