Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
6.3 KB
Raw Blame
"""SkillNet 异步安装会话连续性:跨 SkillManager / 无状态 fallback 复用."""

from __future__ import annotations

import asyncio
from types import SimpleNamespace
from unittest.mock import MagicMock

import pytest

def _default_ctx(server, request):
    import asyncio as _asyncio

    from jiuwenswarm.server.context import AgentServerServices, RequestContext
    from jiuwenswarm.server.transports.sink import WSSink

    class _NullWs:
        async def send(self, text):  # noqa: ANN001
            return None

    _ws = _NullWs()
    return RequestContext(
        request=request,
        sink=WSSink(_ws, _asyncio.Lock()),
        connection_id=str(id(_ws)),
        services=AgentServerServices(server),
    )



from jiuwenswarm.server.handlers import _default

from jiuwenswarm.server import agent_ws_server as agent_ws_server_module
from jiuwenswarm.server.runtime.skill import skill_manager as skill_manager_module
from jiuwenswarm.server.runtime.skill.skill_manager import SkillManager


@pytest.fixture(autouse=True)
def _clear_skillnet_install_jobs():
    skill_manager_module._SKILLNET_INSTALL_JOBS.clear()
    yield
    skill_manager_module._SKILLNET_INSTALL_JOBS.clear()


@pytest.mark.asyncio
async def test_skillnet_install_status_visible_across_skill_manager_instances(
    tmp_path, monkeypatch
):
    """install 与 install_status 落到不同 SkillManager 时仍能查到 pending job."""
    manager_a = SkillManager(workspace_dir=str(tmp_path / "a"))
    manager_b = SkillManager(workspace_dir=str(tmp_path / "b"))

    async def _never_finish(*_args, **_kwargs):
        await asyncio.Event().wait()

    monkeypatch.setattr(manager_a, "_skillnet_install_background", _never_finish)

    install = await manager_a.handle_skills_skillnet_install(
        {"url": "https://github.com/example/skill-demo"}
    )
    assert install["success"] is True
    assert install["pending"] is True
    install_id = install["install_id"]
    assert install_id

    status = await manager_b.handle_skills_skillnet_install_status(
        {"install_id": install_id}
    )
    assert status == {"success": True, "status": "pending"}


@pytest.mark.asyncio
async def test_skillnet_install_status_missing_id_still_reports_session_expired(
    tmp_path,
):
    manager = SkillManager(workspace_dir=str(tmp_path))
    status = await manager.handle_skills_skillnet_install_status(
        {"install_id": "nonexistent"}
    )
    assert status["success"] is False
    assert status["detail_key"] == "skills.skillNet.errors.sessionExpired"


@pytest.mark.asyncio
async def test_get_stateless_agent_reuses_fallback_on_repeated_cache_miss(monkeypatch):
    server = agent_ws_server_module.AgentWebSocketServer()
    server._agent_manager.get_agent_nowait = MagicMock(return_value=None)

    created: list[object] = []

    class _FakeSwarm:
        def __init__(self) -> None:
            created.append(self)

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface.JiuWenSwarm",
        _FakeSwarm,
    )

    first = await _default._get_stateless_agent(_default_ctx(server, None), "web")
    second = await _default._get_stateless_agent(_default_ctx(server, None), "web")

    assert first is second
    assert len(created) == 1
    assert server._stateless_fallback_agents["web"] is first


@pytest.mark.asyncio
async def test_get_stateless_agent_prefers_cached_agent_mode_instance():
    server = agent_ws_server_module.AgentWebSocketServer()
    cached = SimpleNamespace(name="cached-agent")
    server._agent_manager.get_agent_nowait = MagicMock(return_value=cached)
    server._stateless_fallback_agents["web"] = SimpleNamespace(name="fallback")

    got = await _default._get_stateless_agent(_default_ctx(server, None), "web")

    assert got is cached
    server._agent_manager.get_agent_nowait.assert_called_once_with(
        channel_id="web", mode="agent"
    )


@pytest.mark.asyncio
async def test_get_stateless_agent_isolates_fallback_by_channel(monkeypatch):
    server = agent_ws_server_module.AgentWebSocketServer()
    server._agent_manager.get_agent_nowait = MagicMock(return_value=None)

    class _FakeSwarm:
        def __init__(self) -> None:
            pass

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface.JiuWenSwarm",
        _FakeSwarm,
    )

    web = await _default._get_stateless_agent(_default_ctx(server, None), "web")
    cli = await _default._get_stateless_agent(_default_ctx(server, None), "cli")

    assert web is not cli
    assert server._stateless_fallback_agents["web"] is web
    assert server._stateless_fallback_agents["cli"] is cli


@pytest.mark.asyncio
async def test_skillnet_install_then_status_via_distinct_stateless_fallbacks(
    tmp_path, monkeypatch
):
    """模拟旧行为:两次 cache miss 各 new 一个 Swarm;共享 job 表后 status 仍连续."""
    server = agent_ws_server_module.AgentWebSocketServer()
    server._agent_manager.get_agent_nowait = MagicMock(return_value=None)

    managers = [
        SkillManager(workspace_dir=str(tmp_path / "m1")),
        SkillManager(workspace_dir=str(tmp_path / "m2")),
    ]
    idx = {"n": 0}

    class _EphemeralSwarm:
        def __init__(self) -> None:
            self._skill_manager = managers[idx["n"]]
            idx["n"] += 1

    # 强制每次 fallback miss 都 new(绕过 server 缓存),验证共享 job 仍生效
    async def _always_new(_channel_id: str):
        return _EphemeralSwarm()

    monkeypatch.setattr(
        _default, "_get_stateless_agent", lambda _ctx, channel_id: _always_new(channel_id)
    )

    swarm_install = await _default._get_stateless_agent(_default_ctx(server, None), "web")
    manager_install = swarm_install._skill_manager

    async def _never_finish(*_args, **_kwargs):
        await asyncio.Event().wait()

    monkeypatch.setattr(manager_install, "_skillnet_install_background", _never_finish)

    install = await manager_install.handle_skills_skillnet_install(
        {"url": "https://github.com/example/skill-demo"}
    )
    install_id = install["install_id"]

    swarm_status = await _default._get_stateless_agent(_default_ctx(server, None), "web")
    assert swarm_status is not swarm_install

    status = await swarm_status._skill_manager.handle_skills_skillnet_install_status(
        {"install_id": install_id}
    )
    assert status == {"success": True, "status": "pending"}