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
8.4 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""Unit tests for ``AgentWebSocketServer._handle_team_session_reset`` (Task 3).

The handler is the session-scoped counterpart to ``_handle_team_delete``:
explicitly keyed by a single ``session_id`` (no cross-thread scan), clears
shell-side runtime tracking + first-request flag FIRST, then delegates to
``Runner.reset_agent_team_session`` (which drops session tables + releases
the checkpoint while keeping team_info / roster / team_home / binding).

These tests pin:
- runtime team name is resolved from session metadata (``resolve_session_runtime_team_name(metadata) or team_name``);
- shell state is cleared with ``stop_session_runtime(stop_runner=False)`` + ``clear_session_initialized`` BEFORE the Runner reset;
- ``Runner.reset_agent_team_session`` is called with the resolved runtime team name + same session_id + force=True;
- missing team_name/session_id -> BAD_REQUEST (ok=False);
- a Runner failure degrades to ok=False without raising (chat.send path stays usable).
"""
from __future__ import annotations

import asyncio
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_reset(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_response():
    """Return (capture_dict, fake_encode) wiring encode -> capture resp."""
    captured: dict = {}

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

    return captured, fake_encode


async def _call_handler(request) -> dict:
    """Invoke the handler with all external deps mocked; returns the captured
    AgentResponse. Uses realistic control-RPC params (session_id + team_name
    only, NO `team`/`mode` marker — the reset RPC is team-scoped by relay
    gate, not by is_team_params)."""
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers

    captured, fake_encode = _capture_response()
    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,
    ) as get_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, "encode_agent_response_for_wire", side_effect=fake_encode,
    ), patch.object(
        mod, "send_wire_payload", new=AsyncMock(),
    ) as send_wire:
        await team_handlers.handle_team_session_reset(_ctx_for_reset(mod, request))
        captured["fake_tm"] = fake_tm
        captured["get_tm"] = get_tm
        captured["runner_reset"] = runner_reset
        captured["send_wire"] = send_wire
    return captured


@pytest.mark.asyncio
async def test_handler_resolves_runtime_team_name_and_calls_runner_reset():
    # Realistic relay control-RPC params: session_id + team_name ONLY (no
    # `team`/`mode` marker). The reset RPC is gated team-scoped on the relay
    # side (teamParams.isTeamModeForName && teamParams.teamName); the handler
    # must NOT reject these minimal params.
    params = {"team_name": "oc_team_preset-software-dev", "session_id": "sess_1"}
    request = _make_request(params)

    captured = await _call_handler(request)

    # Runner reset called with the RESOLVED runtime team name + same session_id.
    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

    # Shell state cleared FIRST, before the Runner reset.
    tm = captured["fake_tm"]
    tm.stop_session_runtime.assert_awaited_once()
    call = tm.stop_session_runtime.call_args
    assert call.args[0] == "sess_1"            # session_id passed positionally
    assert call.kwargs["stop_runner"] is False
    tm.clear_session_initialized.assert_called_once_with("sess_1")

    # Response ok=True, payload.reset=True, wire sent.
    resp = captured["resp"]
    assert resp.ok is True
    assert resp.payload["reset"] is True
    assert resp.payload["session_id"] == "sess_1"
    captured["send_wire"].assert_awaited_once()


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

    # Realistic params without `team` marker; session_id absent -> BAD_REQUEST.
    params = {"team_name": "oc_team_x"}  # no session_id
    request = _make_request(params)
    captured, fake_encode = _capture_response()

    with 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_session_reset(_ctx_for_reset(mod, request))

    resp = captured["resp"]
    assert resp.ok is False
    assert resp.payload["code"] == "BAD_REQUEST"


@pytest.mark.asyncio
async def test_handler_does_not_gate_on_mode_marker():
    """The reset control RPC carries only {team_name, session_id} (no `team`/
    `mode` marker); team-scoping is the relay gate's responsibility, so the
    handler must NOT reject minimal params even when a non-team `mode` is
    present. Guards against the is_team_params regression."""
    params = {"team_name": "oc_team_x", "session_id": "sess_1", "mode": "office"}
    request = _make_request(params)

    captured = await _call_handler(request)

    resp = captured["resp"]
    assert resp.ok is True, "reset must not be rejected for lacking a team-mode marker"
    captured["runner_reset"].assert_awaited_once()


@pytest.mark.asyncio
async def test_handler_runner_failure_returns_ok_false_not_raises():
    """A Runner.reset_agent_team_session failure must degrade to ok=False
    without raising (so the chat.send path stays usable)."""
    from jiuwenswarm.server import agent_ws_server as mod
    from jiuwenswarm.server.handlers import team as team_handlers

    params = {"team": "oc_team_x", "team_name": "oc_team_x", "session_id": "sess_1"}
    request = _make_request(params)
    captured, fake_encode = _capture_response()
    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"},
    ), 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(side_effect=RuntimeError("boom")),
    ), 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(),
    ):
        # Must not raise.
        await team_handlers.handle_team_session_reset(_ctx_for_reset(mod, request))

    resp = captured["resp"]
    assert resp.ok is False
    assert resp.payload["reset"] is False
    # Shell state was still cleared (best-effort) before the Runner failure.
    fake_tm.clear_session_initialized.assert_called_once_with("sess_1")