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
13.0 KB
Raw Blame
# tests/unit_tests/test_team_runtime_dissolve_handler.py
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""Tests for ``handle_team_runtime_dissolve`` (mirrors reset handler test)."""
from __future__ import annotations

from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest


def _make_request(params: dict, *, request_id: str = "req-1") -> SimpleNamespace:
    return SimpleNamespace(
        params=params,
        request_id=request_id,
        channel_id="officeclaw",
        metadata={"team_name": params.get("team_name", "")},
    )


def _ctx_for(mod, request):
    ctx = MagicMock()
    ctx.request = request

    async def _send_wire(wire):
        return await mod.send_wire_payload(None, wire)

    ctx.sink.send_wire = _send_wire
    return ctx


def _capture():
    captured: dict = {}

    def fake_encode(resp, response_id=None):  # noqa: ANN001
        captured["resp"] = resp
        return b"wire"

    return captured, fake_encode


async def _call_dissolve(
    request, *, resolved_name: str | None = "oc_team_x__sess_1", clear_raises=None
) -> dict:
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers

    captured, fake_encode = _capture()
    fake_tm = MagicMock()
    fake_tm.stop_session_runtime = AsyncMock(return_value=True)
    fake_tm.clear_session_initialized = MagicMock(side_effect=clear_raises)

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"channel_id": "officeclaw", "team_name": "oc_team_x"},
    ), patch(
        "jiuwenswarm.server.runtime.session.session_metadata."
        "resolve_session_runtime_team_name",
        return_value=resolved_name,
    ), patch(
        "jiuwenswarm.agents.harness.team.get_team_manager",
        return_value=fake_tm,
    ), patch(
        "openjiuwen.core.runner.Runner.reset_agent_team_session",
        new=AsyncMock(return_value=True),
    ) as runner_reset, patch.object(
        team_handlers, "_sessions_dir_for_request", return_value="/tmp/sessions",
    ), patch.object(
        team_handlers, "_effective_config_for_request", return_value={},
    ), patch.object(
        team_handlers, "encode_agent_response_for_wire", side_effect=fake_encode,
    ), patch.object(
        mod, "send_wire_payload", new=AsyncMock(),
    ):
        await team_handlers.handle_team_runtime_dissolve(_ctx_for(mod, request))
        captured["fake_tm"] = fake_tm
        captured["runner_reset"] = runner_reset
    return captured


@pytest.mark.asyncio
async def test_dissolve_calls_runner_reset_with_resolved_name():
    params = {"team_name": "oc_team_preset-software-dev", "session_id": "sess_1"}
    captured = await _call_dissolve(_make_request(params))

    assert captured["runner_reset"].await_count == 1
    _, kwargs = captured["runner_reset"].call_args
    assert kwargs["team_name"] == "oc_team_x__sess_1"
    assert kwargs["session_id"] == "sess_1"
    assert kwargs["force"] is True

    tm = captured["fake_tm"]
    tm.stop_session_runtime.assert_awaited_once()
    sargs, skwargs = tm.stop_session_runtime.call_args
    assert sargs[0] == "sess_1"
    assert skwargs["reason"] == "team.runtime.dissolve"
    assert skwargs["stop_runner"] is False
    tm.clear_session_initialized.assert_called_once_with("sess_1")

    resp = captured["resp"]
    assert resp.ok is True
    assert resp.payload["dissolved"] is True
    assert resp.payload["session_id"] == "sess_1"
    # 回显解析后的权威运行时名,而非请求参数里的 team_name。
    assert resp.payload["team_name"] == "oc_team_x__sess_1"


@pytest.mark.asyncio
async def test_dissolve_continues_when_clear_initialized_fails():
    params = {"team_name": "oc_team_x", "session_id": "sess_1"}
    captured = await _call_dissolve(
        _make_request(params), clear_raises=RuntimeError("clear failed")
    )

    captured["runner_reset"].assert_awaited_once()
    captured["fake_tm"].clear_session_initialized.assert_called_once_with("sess_1")
    assert captured["resp"].ok is True
    assert captured["resp"].payload["dissolved"] is True


@pytest.mark.asyncio
async def test_dissolve_missing_session_id_is_bad_request():
    captured = await _call_dissolve(_make_request({"team_name": "oc_team_x"}))
    resp = captured["resp"]
    assert resp.ok is False
    assert resp.payload["code"] == "BAD_REQUEST"
    captured["runner_reset"].assert_not_called()


@pytest.mark.asyncio
async def test_dissolve_runner_failure_degrades_ok_false():
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers

    captured, fake_encode = _capture()
    fake_tm = MagicMock()
    fake_tm.stop_session_runtime = AsyncMock(return_value=True)
    fake_tm.clear_session_initialized = MagicMock()

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"channel_id": "officeclaw", "team_name": "oc_team_x"},
    ), patch(
        "jiuwenswarm.server.runtime.session.session_metadata."
        "resolve_session_runtime_team_name",
        return_value="oc_team_x__sess_1",
    ), patch(
        "jiuwenswarm.agents.harness.team.get_team_manager",
        return_value=fake_tm,
    ), patch(
        "openjiuwen.core.runner.Runner.reset_agent_team_session",
        new=AsyncMock(return_value=False),
    ), patch.object(
        team_handlers, "_sessions_dir_for_request", return_value="/tmp/sessions",
    ), patch.object(
        team_handlers, "encode_agent_response_for_wire", side_effect=fake_encode,
    ), patch.object(
        mod, "send_wire_payload", new=AsyncMock(),
    ):
        await team_handlers.handle_team_runtime_dissolve(
            _ctx_for(mod, _make_request({"session_id": "sess_1"}))
        )

    assert captured["resp"].ok is False
    assert captured["resp"].payload["dissolved"] is False


@pytest.mark.asyncio
async def test_dissolve_team_name_optional():
    # relay 发 dissolve 帧时 team_name 可选(仅 session_id 恒带)。
    captured = await _call_dissolve(_make_request({"session_id": "sess_1"}))
    assert captured["runner_reset"].await_count == 1
    assert captured["resp"].ok is True


@pytest.mark.asyncio
async def test_dissolve_no_bound_team_and_no_param_is_ok_noop():
    # 会话无绑定运行时团队且请求未带 team_name:无可 dissolve,ok=True
    # 短路(与 relay resetTeamSession 接受 NOT_FOUND 的语义对齐),
    # 不触发任何 stop/reset。
    captured = await _call_dissolve(
        _make_request({"session_id": "sess_1"}), resolved_name=None
    )
    assert captured["resp"].ok is True
    assert captured["resp"].payload["dissolved"] is True
    assert captured["resp"].payload["team_name"] == ""
    captured["runner_reset"].assert_not_called()
    captured["fake_tm"].stop_session_runtime.assert_not_called()
    captured["fake_tm"].clear_session_initialized.assert_not_called()


@pytest.mark.asyncio
async def test_dissolve_registered_in_dispatch():
    from jiuwenswarm.common.schema.message import ReqMethod
    from jiuwenswarm.server.dispatch import HANDLERS

    spec = HANDLERS.get(ReqMethod.TEAM_RUNTIME_DISSOLVE)
    assert spec is not None
    assert spec.fn.__name__ == "handle_team_runtime_dissolve"


# ---- dissolve + roster prune ----------------------------------------------


async def _call_dissolve_prune(
    request,
    *,
    keep=None,
    prune_return=None,
    prune_raises=None,
    reset_return=True,
    resolved_name: str | None = "oc_team_x__sess_1",
) -> dict:
    """Drive dissolve with ``resolve_dissolve_keep_members`` and the Runner
    reset/prune pair mocked, so prune wiring can be asserted in isolation."""
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers
    from openjiuwen.core.runner import Runner

    captured, fake_encode = _capture()
    fake_tm = MagicMock()
    fake_tm.stop_session_runtime = AsyncMock(return_value=True)
    fake_tm.clear_session_initialized = MagicMock()

    runner_reset = AsyncMock(return_value=reset_return)
    runner_prune = AsyncMock(return_value=prune_return)
    if prune_raises is not None:
        runner_prune.side_effect = prune_raises

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"channel_id": "officeclaw", "team_name": "oc_team_x"},
    ), patch(
        "jiuwenswarm.server.runtime.session.session_metadata."
        "resolve_session_runtime_team_name",
        return_value=resolved_name,
    ), patch(
        "jiuwenswarm.agents.harness.team.get_team_manager", return_value=fake_tm,
    ), patch(
        "openjiuwen.core.runner.Runner.reset_agent_team_session", new=runner_reset,
    ), patch.object(
        Runner, "prune_agent_team_roster", new=runner_prune, create=True,
    ), patch.object(
        team_handlers, "_sessions_dir_for_request", return_value="/tmp/sessions",
    ), patch.object(
        team_handlers, "_effective_config_for_request", return_value={},
    ), patch(
        "jiuwenswarm.server.runtime.team_snapshot_refresh."
        "resolve_dissolve_keep_members",
        return_value=keep,
    ), patch.object(
        team_handlers, "encode_agent_response_for_wire", side_effect=fake_encode,
    ), patch.object(
        mod, "send_wire_payload", new=AsyncMock(),
    ):
        await team_handlers.handle_team_runtime_dissolve(_ctx_for(mod, request))
        captured["runner_reset"] = runner_reset
        captured["runner_prune"] = runner_prune
        captured["fake_tm"] = fake_tm
    return captured


@pytest.mark.asyncio
async def test_dissolve_prunes_roster_when_keep_set_resolved():
    request = _make_request({"session_id": "sess_1", "team_name": "oc_team_x"})
    captured = await _call_dissolve_prune(
        request, keep={"leader", "m1"}, prune_return=["m2"],
    )
    assert captured["runner_reset"].await_count == 1
    assert captured["runner_prune"].await_count == 1
    _, pkwargs = captured["runner_prune"].call_args
    assert pkwargs["team_name"] == "oc_team_x__sess_1"
    assert pkwargs["session_id"] == "sess_1"
    assert pkwargs["keep_members"] == {"leader", "m1"}
    resp = captured["resp"]
    assert resp.ok is True
    assert resp.payload["dissolved"] is True


@pytest.mark.asyncio
async def test_dissolve_prune_failure_degrades_ok_false():
    # prune raises → ok=false so relay keeps the dirty flag and retries.
    request = _make_request({"session_id": "sess_1"})
    captured = await _call_dissolve_prune(
        request, keep={"leader"}, prune_raises=RuntimeError("db down"),
    )
    assert captured["runner_prune"].await_count == 1
    resp = captured["resp"]
    assert resp.ok is False
    assert resp.payload["dissolved"] is False


@pytest.mark.asyncio
async def test_dissolve_skips_prune_when_keep_set_none():
    # keep=None (template unavailable) → skip prune, ok stays True (fail-open).
    request = _make_request({"session_id": "sess_1"})
    captured = await _call_dissolve_prune(request, keep=None, prune_return=[])
    assert captured["runner_prune"].await_count == 0
    assert captured["resp"].ok is True


@pytest.mark.asyncio
async def test_dissolve_skips_prune_when_agent_core_too_old():
    # agent-core predates prune_agent_team_roster: dissolve must not crash and
    # must leave ok at reset's True. ok=True proves the hasattr guard fired
    # (without the guard the missing method would raise → ok=False).
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers

    class _OldRunner:
        @classmethod
        async def reset_agent_team_session(cls, **kwargs):  # noqa: ANN001
            return True

    captured, fake_encode = _capture()
    fake_tm = MagicMock()
    fake_tm.stop_session_runtime = AsyncMock(return_value=True)
    fake_tm.clear_session_initialized = MagicMock()

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"channel_id": "officeclaw", "team_name": "oc_team_x"},
    ), patch(
        "jiuwenswarm.server.runtime.session.session_metadata."
        "resolve_session_runtime_team_name",
        return_value="oc_team_x__sess_1",
    ), patch(
        "jiuwenswarm.agents.harness.team.get_team_manager", return_value=fake_tm,
    ), patch("openjiuwen.core.runner.Runner", _OldRunner), patch.object(
        team_handlers, "_sessions_dir_for_request", return_value="/tmp/sessions",
    ), patch.object(
        team_handlers, "_effective_config_for_request", return_value={},
    ), patch(
        "jiuwenswarm.server.runtime.team_snapshot_refresh."
        "resolve_dissolve_keep_members",
        return_value={"leader"},  # keep-set present → prune branch entered
    ), patch.object(
        team_handlers, "encode_agent_response_for_wire", side_effect=fake_encode,
    ), patch.object(
        mod, "send_wire_payload", new=AsyncMock(),
    ):
        await team_handlers.handle_team_runtime_dissolve(
            _ctx_for(mod, _make_request({"session_id": "sess_1"}))
        )
    assert captured["resp"].ok is True