Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

4.5 KB
Raw Blame
"""Role boundaries and shared web admission order."""

from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import pytest
from fastapi import FastAPI

from xagent.web import app as app_module
from xagent.web.api.websocket import manager
from xagent.web.services import task_command_transport as transport
from xagent.web.services import (
    task_coordinator_runtime,
    task_event_bridge,
    task_execution,
)


@pytest.mark.asyncio
async def test_web_role_cannot_claim_or_promptly_execute(monkeypatch):
    monkeypatch.setenv("XAGENT_SHARED_TASK_EXECUTION_ENABLED", "true")
    monkeypatch.setenv("XAGENT_TASK_EXECUTION_ROLE", "web")
    db, execute = Mock(), AsyncMock()
    assert transport.claim_task_command(db, command_db_id=1) is None
    await transport.dispatch_task_command_promptly(execute, command_db_id=1)
    assert transport.start_task_command_dispatcher(execute) is None
    assert app_module.start_task_lease_recovery_task(FastAPI()) is None
    db.assert_not_called()
    assert db.mock_calls == []
    execute.assert_not_awaited()


@pytest.mark.asyncio
@pytest.mark.parametrize("fails", [None, "bridge", "dispatcher"])
async def test_shared_web_starts_bridge_before_consumers_and_unwinds_failure(
    monkeypatch, fails
):
    monkeypatch.setenv("XAGENT_SHARED_TASK_EXECUTION_ENABLED", "true")
    app = FastAPI()
    events = []
    monkeypatch.setattr(app_module, "_trigger_dispatcher_task", None)
    monkeypatch.setattr(app_module, "_task_command_dispatcher_task", None)

    async def start_bridge(**kwargs):
        events.append("bridge")
        assert kwargs["deliver"] == manager.deliver_shared_event
        if fails == "bridge":
            raise ConnectionError("bridge")

    def start_dispatcher(execute):
        events.append("dispatcher")
        if fails == "dispatcher":
            raise RuntimeError("dispatcher")

    monkeypatch.setattr(task_event_bridge, "start_task_event_bridge", start_bridge)
    monkeypatch.setattr(
        task_event_bridge,
        "stop_task_event_bridge",
        AsyncMock(side_effect=lambda: events.append("bridge_stop")),
    )
    monkeypatch.setattr(
        manager, "start_stream_reconciliation", lambda: events.append("reconcile")
    )
    monkeypatch.setattr(
        manager,
        "stop_stream_reconciliation",
        AsyncMock(side_effect=lambda: events.append("reconcile_stop")),
    )
    monkeypatch.setattr(
        task_execution,
        "background_task_manager",
        SimpleNamespace(
            start_accepting=lambda: events.append("admit"),
            shutdown=AsyncMock(side_effect=lambda: events.append("execution_stop")),
        ),
    )
    monkeypatch.setattr(
        app_module,
        "start_trigger_dispatcher_task",
        lambda app: events.append("triggers"),
    )
    monkeypatch.setattr(
        app_module,
        "start_task_lease_recovery_task",
        lambda app: events.append("recovery"),
    )
    monkeypatch.setattr(
        app_module,
        "stop_task_lease_recovery_task",
        AsyncMock(side_effect=lambda app: events.append("recovery_stop")),
    )
    monkeypatch.setattr(
        app_module,
        "start_task_auto_resume_task",
        lambda app: events.append("auto_resume"),
    )
    monkeypatch.setattr(
        app_module,
        "stop_task_auto_resume_task",
        AsyncMock(side_effect=lambda app: events.append("auto_resume_stop")),
    )
    monkeypatch.setattr(transport, "start_task_command_dispatcher", start_dispatcher)
    monkeypatch.setattr(
        transport,
        "stop_task_command_dispatcher",
        AsyncMock(side_effect=lambda: events.append("claims_stop")),
    )
    monkeypatch.setattr(
        task_coordinator_runtime,
        "close_task_coordinators",
        AsyncMock(side_effect=lambda: events.append("owner_stop")),
    )
    if fails:
        with pytest.raises((ConnectionError, RuntimeError), match=fails):
            await app_module._start_shared_task_runtime(app)
    else:
        await app_module._start_shared_task_runtime(app)
    if fails == "bridge":
        assert events == ["bridge"]
    else:
        assert events[:7] == [
            "bridge",
            "reconcile",
            "admit",
            "triggers",
            "recovery",
            "auto_resume",
            "dispatcher",
        ]
        if fails:
            assert events[7:] == [
                "claims_stop",
                "auto_resume_stop",
                "recovery_stop",
                "owner_stop",
                "execution_stop",
                "reconcile_stop",
                "bridge_stop",
            ]