mirror of
https://github.com/openswarm-ai/openswarm.git
synced 2026-08-17 18:25:42 +02:00
216 lines
7.8 KiB
Python
216 lines
7.8 KiB
Python
"""Service-sync compatibility tests.
|
|
|
|
Verifies the legacy compatibility helpers on backend/apps/service/client.py
|
|
(record, submit_event, submit_session_close, etc.) still produce the right
|
|
opaque payload through the unified sync() entry point. Forward-looking
|
|
contract tests live in test_service.py; this file covers the legacy shim
|
|
surface so it can be deprecated cleanly later.
|
|
|
|
Run with:
|
|
cd backend && python -m pytest tests/test_service_legacy.py -v
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import tempfile
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
# Sandbox the data dir before any module import touches settings on disk.
|
|
p_tmpdir = tempfile.mkdtemp()
|
|
os.environ.setdefault("OPENSWARM_DATA_DIR", p_tmpdir)
|
|
|
|
# Captured syncs from this test run.
|
|
p_captured_syncs: list[dict] = []
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def reset_captured_syncs():
|
|
p_captured_syncs.clear()
|
|
yield
|
|
p_captured_syncs.clear()
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def install_sync_sink():
|
|
"""Install a service-sync sink and decode the opaque payload back into
|
|
a structured shape for assertions. The sink translates the new shape
|
|
{client_state, d, t} into a legacy-compatible {kind, distinct_id, props}
|
|
bag so existing tests can keep their assertions terse."""
|
|
import backend.apps.service.client as svc_client
|
|
|
|
def p_sink(label: str, body: dict):
|
|
cs = body.get("client_state") or {}
|
|
payload = body.get("d") or body.get("payload") or {}
|
|
|
|
# Infer a synthetic kind from payload shape, same dispatch logic as the cloud uses in production.
|
|
if "status" in payload and "messages" in payload:
|
|
status = payload.get("status", "unknown")
|
|
kind = f"session.{status}" if status != "unknown" else "session.completed"
|
|
props = dict(payload)
|
|
elif "identity" in payload:
|
|
kind = "state.update"
|
|
props = dict(payload)
|
|
elif "diagnostic" in payload:
|
|
kind = "diagnostic.fired"
|
|
props = dict(payload)
|
|
elif "s" in payload and "a" in payload:
|
|
kind = f"{payload['s']}.{payload['a']}"
|
|
props = dict(payload.get("p") or {})
|
|
elif "surface" in payload:
|
|
surface = payload.get("surface", "")
|
|
action = payload.get("action", "fired")
|
|
kind = f"{surface}.{action}"
|
|
props = dict(payload.get("props") or {})
|
|
else:
|
|
kind = "state.update"
|
|
props = dict(payload)
|
|
|
|
if payload.get("session_id"):
|
|
props["session_id"] = payload["session_id"]
|
|
if payload.get("dashboard_id"):
|
|
props["dashboard_id"] = payload["dashboard_id"]
|
|
props.setdefault("os", cs.get("os", ""))
|
|
props.setdefault("platform", cs.get("os", ""))
|
|
|
|
p_captured_syncs.append({
|
|
"kind": kind,
|
|
"distinct_id": cs.get("install_id", ""),
|
|
"properties": props,
|
|
})
|
|
|
|
old_sink = svc_client.test_sink
|
|
old_iid = svc_client.install_id
|
|
svc_client.set_test_sink(p_sink)
|
|
svc_client.install_id = "test-install-id"
|
|
yield
|
|
svc_client.set_test_sink(old_sink)
|
|
svc_client.install_id = old_iid
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def mock_settings(tmp_path):
|
|
"""Sandbox settings so tests don't read or write the real config."""
|
|
settings_file = tmp_path / "settings.json"
|
|
settings_file.write_text(json.dumps({
|
|
"service_diagnostics_mode": "standard",
|
|
"installation_id": "test-install-id",
|
|
}))
|
|
|
|
import backend.apps.settings.store as settings_mod
|
|
old_file = settings_mod.SETTINGS_FILE
|
|
settings_mod.SETTINGS_FILE = str(settings_file)
|
|
yield
|
|
settings_mod.SETTINGS_FILE = old_file
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def mock_sessions_dir(tmp_path):
|
|
"""Use temp dir for session persistence."""
|
|
sessions_dir = tmp_path / "sessions"
|
|
sessions_dir.mkdir()
|
|
|
|
import backend.config.paths as paths_mod
|
|
old_dir = paths_mod.SESSIONS_DIR
|
|
paths_mod.SESSIONS_DIR = str(sessions_dir)
|
|
yield str(sessions_dir)
|
|
paths_mod.SESSIONS_DIR = old_dir
|
|
|
|
|
|
def syncs(kind: str | None = None) -> list[dict]:
|
|
"""Return captured syncs, optionally filtered by inferred kind."""
|
|
if kind:
|
|
return [s for s in p_captured_syncs if s["kind"] == kind]
|
|
return list(p_captured_syncs)
|
|
|
|
|
|
def last_sync(kind: str) -> dict:
|
|
"""Return the last captured sync of a given inferred kind."""
|
|
matching = syncs(kind)
|
|
assert matching, f"No {kind} syncs captured. Got: {[s['kind'] for s in p_captured_syncs]}"
|
|
return matching[-1]
|
|
|
|
|
|
# Import application modules (after fixtures are wired).
|
|
from backend.apps.service.client import record
|
|
from backend.apps.agents.core.models import AgentConfig, AgentSession, Message, ApprovalRequest
|
|
from backend.apps.agents.agent_manager import AgentManager
|
|
|
|
|
|
@pytest.fixture
|
|
def manager():
|
|
"""Fresh AgentManager per test."""
|
|
return AgentManager()
|
|
|
|
|
|
# --------------------------------------------------------------------------- 1. record(), legacy shim correctness ---------------------------------------------------------------------------
|
|
|
|
class TestRecordBasics:
|
|
def test_record_sends_payload(self):
|
|
record("test.report", {"key": "value"})
|
|
s = last_sync("test.report")
|
|
assert s["properties"]["key"] == "value"
|
|
assert s["distinct_id"] == "test-install-id"
|
|
|
|
def test_record_adds_os_and_platform(self):
|
|
record("test.report", {})
|
|
s = last_sync("test.report")
|
|
assert "os" in s["properties"]
|
|
assert "platform" in s["properties"]
|
|
|
|
def test_record_includes_session_id(self):
|
|
record("test.report", {}, session_id="sess123")
|
|
s = last_sync("test.report")
|
|
assert s["properties"]["session_id"] == "sess123"
|
|
|
|
def test_record_includes_dashboard_id(self):
|
|
record("test.report", {}, dashboard_id="dash456")
|
|
s = last_sync("test.report")
|
|
assert s["properties"]["dashboard_id"] == "dash456"
|
|
|
|
|
|
# --------------------------------------------------------------------------- 2. Multi-message session, close fires exactly once ---------------------------------------------------------------------------
|
|
|
|
class TestMultiMessageSession:
|
|
@pytest.mark.asyncio
|
|
async def test_session_completes_only_on_close(self, manager):
|
|
"""Verify a completed-session sync does NOT fire mid-loop. It should
|
|
only fire on close_session() or persist_all_sessions()."""
|
|
config = AgentConfig(name="Multi-msg", model="sonnet", mode="agent")
|
|
session = await manager.launch_agent(config)
|
|
|
|
for i in range(3):
|
|
session.messages.append(Message(role="user", content=f"msg {i}"))
|
|
session.messages.append(Message(role="assistant", content=f"reply {i}"))
|
|
|
|
completed = syncs("session.completed")
|
|
assert len(completed) == 0, f"session-completed fired {len(completed)} times before close"
|
|
|
|
session.status = "completed"
|
|
await manager.close_session(session.id)
|
|
|
|
completed = syncs("session.completed")
|
|
assert len(completed) == 1, f"expected 1 completed sync, got {len(completed)}"
|
|
|
|
|
|
# --------------------------------------------------------------------------- 3. Token + cost capture on close ---------------------------------------------------------------------------
|
|
|
|
class TestTokenTracking:
|
|
@pytest.mark.asyncio
|
|
async def test_tokens_and_cost_in_session_close(self, manager):
|
|
config = AgentConfig(name="Token Test", model="opus", mode="agent")
|
|
session = await manager.launch_agent(config)
|
|
|
|
session.tokens = {"input": 50000, "output": 15000}
|
|
session.cost_usd = 0.25
|
|
session.status = "completed"
|
|
|
|
await manager.close_session(session.id)
|
|
|
|
s = last_sync("session.completed")
|
|
assert s["properties"]["tokens"]["input"] == 50000
|
|
assert s["properties"]["tokens"]["output"] == 15000
|
|
assert s["properties"]["cost_usd"] == 0.25
|