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
31.5 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

from __future__ import annotations

import contextlib
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest
from openjiuwen.agent_teams.monitor.models import MonitorEvent, MonitorEventType

from jiuwenswarm.agents.harness.team.handlers.team_monitor_handler import (
    _TASK_BODY_EVENT_TYPES,
    _TASK_TEXT_LIMIT,
    _task_text_field,
    _truncate_task_text,
)
from jiuwenswarm.agents.harness.team.handlers.team_monitor_handler import TeamMonitorHandler


class _FakeMessage:
    def __init__(
        self,
        message_id: str,
        content: str,
        protocol: str = "plain",
    ) -> None:
        self.message_id = message_id
        self.content = content
        self.protocol = protocol


class _FakeMember:
    def __init__(self, member_name: str, display_name: str = "", status: str = "ready",
                 execution_status: str | None = None, mode: str = "normal", role: str = "teammate"):
        self.member_name = member_name
        self.display_name = display_name
        self.status = status
        self.execution_status = execution_status
        self.mode = mode
        self.role = role


class _FakeTask:
    def __init__(self, task_id: str = "task-1", title: str = "test task",
                 content: str = "do something", status: str = "created",
                 assignee: str | None = None, updated_at: int | None = None):
        self.task_id = task_id
        self.team_name = "team-1"
        self.title = title
        self.content = content
        self.status = status
        self.assignee = assignee
        self.updated_at = updated_at


class _FakeTaskDao:
    """Stand-in for ``TaskDAO`` exposing only ``get_task`` used by _lookup_task_body."""

    def __init__(self, task: _FakeTask | None = None, *, get_task_mock=None) -> None:
        self._task = task
        self._explicit_mock = get_task_mock
        # Call counter so tests can assert "NOT called" for status-only events.
        self.get_task_call_count = 0

    async def get_task(self, task_id: str):
        self.get_task_call_count += 1
        if self._explicit_mock is not None:
            return await self._explicit_mock(task_id)
        return self._task


class _FakeDb:
    """Stand-in for ``monitor._db`` exposing only ``.task`` (a _FakeTaskDao)."""

    def __init__(self, task: _FakeTaskDao) -> None:
        self.task = task


class _FakeMonitor:
    def __init__(
        self,
        members: list[_FakeMember],
        leader_member_name: str | None,
        events: list[MonitorEvent] | None = None,
        tasks: list[_FakeTask] | None = None,
        messages: list[_FakeMessage] | None = None,
        task_dao: _FakeTaskDao | None = None,
    ):
        self.team_name = "team-1"
        self._members = members
        self._leader_member_name = leader_member_name
        self._events = events or []
        self._tasks = tasks or []
        self._messages = messages or []
        # ``get_task`` (the public monitor API used by _lookup_task_body)
        # delegates to this DAO. When no DAO is injected the real monitor would
        # raise (no ``_db``), which _lookup_task_body catches and degrades to a
        # body-less event; the fake reproduces that by raising in ``get_task``.
        self._task_dao = task_dao
        if task_dao is not None:
            self._db = _FakeDb(task_dao)

    async def start(self) -> None:
        pass

    async def stop(self) -> None:
        pass

    async def events(self):
        for event in self._events:
            yield event

    async def get_members(self) -> list[_FakeMember]:
        return list(self._members)

    async def get_member(self, member_name: str, team_name: str | None = None) -> _FakeMember | None:
        for m in self._members:
            if m.member_name == member_name:
                return m
        return None

    async def get_team_info(self):
        if self._leader_member_name is None:
            return None
        return SimpleNamespace(leader_member_name=self._leader_member_name)

    async def get_tasks(self) -> list[_FakeTask]:
        return list(self._tasks)

    async def get_task(self, task_id: str):
        """Mirror TeamMonitor.get_task: single-row read via the DAO.

        When no DAO was injected the real monitor would raise (no ``_db``),
        which _lookup_task_body catches and degrades to a body-less event.
        """
        if self._task_dao is None:
            raise AttributeError("_db not configured")
        return await self._task_dao.get_task(task_id)

    async def get_messages(self) -> list[_FakeMessage]:
        return list(self._messages)

    @contextlib.contextmanager
    def _bound_session(self):
        """Mirror TeamMonitor._bound_session (binds session_id contextvar).

        The real one sets/resets a contextvar for per-session table routing; the
        fake has no contextvar so it's a no-op contextmanager — sufficient to
        exercise the ``with self._monitor._bound_session():`` code path.
        """
        yield


@pytest.mark.anyio
async def test_get_team_snapshot_filters_leader_member() -> None:
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("team_leader"), _FakeMember("worker-1")],
            leader_member_name="team_leader",
            tasks=[_FakeTask(task_id="task-1", title="research", status="created", assignee="worker-1")],
        ),
        "sess-1",
    )

    snapshot = await handler.get_team_snapshot()

    assert snapshot == {
        "members": [
            {
                "member_id": "worker-1",
                "name": "",
                "status": "ready",
                "execution_status": None,
                "mode": "normal",
                "role": "teammate",
            }
        ],
        "tasks": [
            {
                "task_id": "task-1",
                "team_name": "team-1",
                "title": "research",
                "content": "do something",
                "status": "created",
                "assignee": "worker-1",
                "updated_at": None,
            }
        ],
        "team_id": "team-1",
    }


@pytest.mark.anyio
async def test_get_team_snapshot_keeps_members_when_team_info_unavailable() -> None:
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("worker-1"), _FakeMember("worker-2")],
            leader_member_name=None,
        ),
        "sess-2",
    )

    snapshot = await handler.get_team_snapshot()

    assert snapshot == {
        "members": [
            {
                "member_id": "worker-1",
                "name": "",
                "status": "ready",
                "execution_status": None,
                "mode": "normal",
                "role": "teammate",
            },
            {
                "member_id": "worker-2",
                "name": "",
                "status": "ready",
                "execution_status": None,
                "mode": "normal",
                "role": "teammate",
            },
        ],
        "tasks": [],
        "team_id": "team-1",
    }


@pytest.mark.anyio
async def test_convert_event_includes_session_id() -> None:
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-1",
        status="created",
    )
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[],
            leader_member_name=None,
            events=[event],
        ),
        "sess-monitor",
    )

    await handler.start()
    try:
        converted = await anext(handler.events())

        assert converted == {
            "event_type": "team.task",
            "session_id": "sess-monitor",
            "event": {
                "type": "team.task.created",
                "team_id": "team-1",
                "task_id": "task-1",
                "status": "created",
            },
        }
    finally:
        await handler.stop()


@pytest.mark.anyio
async def test_convert_json_protocol_message_decodes_unicode_escapes() -> None:
    event = MonitorEvent(
        event_type=MonitorEventType.MESSAGE,
        team_name="team-1",
        timestamp=123,
        message_id="msg-approval",
        from_member_name="team_leader",
        to_member_name="worker-1",
    )
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[],
            leader_member_name=None,
            events=[event],
            messages=[
                _FakeMessage(
                    message_id="msg-approval",
                    content=(
                        '{"type": "tool_approval_result", "approved": true, '
                        '"feedback": "\\u597d\\u8bd7"}'
                    ),
                    protocol="json",
                ),
            ],
        ),
        "sess-monitor",
    )

    await handler.start()
    try:
        converted = await anext(handler.events())

        assert converted["event"]["protocol"] == "json"
        assert converted["event"]["content"] == (
            '{"type": "tool_approval_result", "approved": true, "feedback": "好诗"}'
        )
    finally:
        await handler.stop()


@pytest.mark.anyio
async def test_convert_plain_protocol_message_keeps_json_like_text_unchanged() -> None:
    raw_content = '{"feedback": "\\u597d\\u8bd7"}'
    event = MonitorEvent(
        event_type=MonitorEventType.BROADCAST,
        team_name="team-1",
        timestamp=123,
        message_id="msg-plain",
        from_member_name="team_leader",
    )
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[],
            leader_member_name=None,
            events=[event],
            messages=[
                _FakeMessage(
                    message_id="msg-plain",
                    content=raw_content,
                    protocol="plain",
                ),
            ],
        ),
        "sess-monitor",
    )

    await handler.start()
    try:
        converted = await anext(handler.events())

        assert converted["event"]["protocol"] == "plain"
        assert converted["event"]["content"] == raw_content
    finally:
        await handler.stop()


@pytest.mark.anyio
async def test_member_spawned_event_includes_mode_for_human_agent() -> None:
    """验证 member_spawned 事件对 human_agent 成员返回 mode="human"."""
    event = MonitorEvent(
        event_type=MonitorEventType.MEMBER_SPAWNED,
        team_name="team-1",
        timestamp=123,
        member_name="HumanPlayer_A",
    )
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("HumanPlayer_A", role="human_agent")],
            leader_member_name=None,
            events=[event],
        ),
        "sess-monitor",
    )

    await handler.start()
    try:
        converted = await anext(handler.events())

        assert converted["event"]["member_id"] == "HumanPlayer_A"
        assert converted["event"]["mode"] == "human"
    finally:
        await handler.stop()


@pytest.mark.anyio
async def test_member_spawned_event_includes_mode_for_ai_member() -> None:
    """验证 member_spawned 事件对 AI 成员返回 mode=role(teammate/leader 等)。"""
    event = MonitorEvent(
        event_type=MonitorEventType.MEMBER_SPAWNED,
        team_name="team-1",
        timestamp=123,
        member_name="Werewolf_AI_1",
    )
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("Werewolf_AI_1", role="teammate")],
            leader_member_name=None,
            events=[event],
        ),
        "sess-monitor",
    )

    await handler.start()
    try:
        converted = await anext(handler.events())

        assert converted["event"]["member_id"] == "Werewolf_AI_1"
        # AI 成员(role=teammate)返回 mode=role 值
        assert converted["event"]["mode"] == "teammate"
    finally:
        await handler.stop()


# =====================================================================
# Truncation helpers (pure functions)
# =====================================================================


class TestTruncateTaskText:
    """``_truncate_task_text`` returns (truncated_str, was_truncated, original_size)."""

    def test_non_string_returns_passthrough_untruncated(self) -> None:
        assert _truncate_task_text(None) == (None, False, 0)
        assert _truncate_task_text(123) == (123, False, 0)

    def test_empty_string_returns_empty_untruncated(self) -> None:
        assert _truncate_task_text("") == ("", False, 0)

    def test_under_limit_returns_unchanged_untruncated(self) -> None:
        value = "a" * _TASK_TEXT_LIMIT
        result, truncated, original = _truncate_task_text(value)
        assert result == value
        assert truncated is False
        assert original == _TASK_TEXT_LIMIT

    def test_exactly_at_limit_is_not_truncated(self) -> None:
        value = "b" * _TASK_TEXT_LIMIT
        _, truncated, original = _truncate_task_text(value)
        assert truncated is False
        assert original == _TASK_TEXT_LIMIT

    def test_over_limit_truncates_with_inline_marker(self) -> None:
        value = "c" * (_TASK_TEXT_LIMIT + 50)
        result, truncated, original = _truncate_task_text(value)
        assert truncated is True
        assert original == _TASK_TEXT_LIMIT + 50
        # Truncated string = first _TASK_TEXT_LIMIT chars + inline marker; marker uses U+2026
        # ellipsis and reports the ORIGINAL length of this field.
        assert result == "c" * _TASK_TEXT_LIMIT + f"…(truncated, total {original} chars)"
        # Inline marker must use the Unicode ellipsis (U+2026), not three dots.
        assert "…" in result
        assert "..." not in result

    def test_over_limit_truncates_at_exactly_one_over(self) -> None:
        value = "d" * (_TASK_TEXT_LIMIT + 1)
        result, truncated, original = _truncate_task_text(value)
        assert truncated is True
        assert original == _TASK_TEXT_LIMIT + 1
        assert result == "d" * _TASK_TEXT_LIMIT + f"…(truncated, total {original} chars)"


class TestTaskTextField:
    """``_task_text_field`` expands to a dict; flags attach ONLY when truncated."""

    def test_under_limit_emits_only_value_key(self) -> None:
        out = _task_text_field("title", "short title")
        assert out == {"title": "short title"}
        # No flag keys when not truncated.
        assert "title_truncated" not in out
        assert "title_original_size" not in out

    def test_over_limit_attaches_truncation_flags(self) -> None:
        value = "x" * (_TASK_TEXT_LIMIT + 10)
        out = _task_text_field("content", value)
        assert out["content"] == "x" * _TASK_TEXT_LIMIT + f"…(truncated, total {len(value)} chars)"
        assert out["content_truncated"] is True
        assert out["content_original_size"] == len(value)

    def test_non_string_emits_only_value_key(self) -> None:
        out = _task_text_field("title", None)
        assert out == {"title": None}
        assert "title_truncated" not in out
        assert "title_original_size" not in out

    def test_empty_string_emits_only_value_key(self) -> None:
        out = _task_text_field("title", "")
        assert out == {"title": ""}
        assert "title_truncated" not in out


# =====================================================================
# _handle_task: body supplement + truncation + non-body events
# =====================================================================


def _make_handler(task_dao: _FakeTaskDao | None = None, *, session_id: str = "sess-1") -> TeamMonitorHandler:
    return TeamMonitorHandler(
        _FakeMonitor(members=[], leader_member_name=None, task_dao=task_dao),
        session_id,
    )


@pytest.mark.anyio
async def test_handle_task_created_supplements_title_and_content_from_db() -> None:
    """TASK_CREATED re-queries the DB and attaches title/content to the event."""
    task_dao = _FakeTaskDao(
        _FakeTask(task_id="task-1", title="research plan", content="do the thing")
    )
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-1",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["task_id"] == "task-1"
    assert result["status"] == "pending"
    assert result["title"] == "research plan"
    assert result["content"] == "do the thing"
    # Under limit → no truncation flags.
    assert "title_truncated" not in result
    assert "content_truncated" not in result
    assert task_dao.get_task_call_count == 1


@pytest.mark.anyio
async def test_handle_task_created_backfills_assignee_from_db() -> None:
    """TASK_CREATED carries no member_name; assignee is backfilled from the DB.

    Lets the frontend attach a freshly-created task to its assignee's card
    without waiting for a later TASK_CLAIMED event.
    """
    task_dao = _FakeTaskDao(
        _FakeTask(task_id="task-1", title="research", content="do", assignee="worker-1")
    )
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-1",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["assignee"] == "worker-1"
    assert "member_id" not in result
    assert task_dao.get_task_call_count == 1


@pytest.mark.anyio
async def test_handle_task_created_no_assignee_when_db_task_unassigned() -> None:
    """An unassigned DB task must not synthesize an assignee field."""
    task_dao = _FakeTaskDao(
        _FakeTask(task_id="task-1", title="research", content="do", assignee=None)
    )
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-1",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert "assignee" not in result


@pytest.mark.anyio
async def test_handle_task_updated_supplements_body_from_db() -> None:
    """TASK_UPDATED also triggers the DB body lookup."""
    task_dao = _FakeTaskDao(
        _FakeTask(task_id="task-2", title="updated title", content="updated content")
    )
    handler = _make_handler(task_dao)
    base = {"type": "team.task.updated", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_UPDATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-2",
        status="in_progress",
    )

    result = await handler._handle_task(base, event)

    assert result["title"] == "updated title"
    assert result["content"] == "updated content"
    assert result["status"] == "in_progress"
    assert task_dao.get_task_call_count == 1


@pytest.mark.anyio
async def test_handle_task_created_truncates_over_limit_body() -> None:
    """When title/content exceed the limit, the event carries truncation flags."""
    long_title = "T" * (_TASK_TEXT_LIMIT + 20)
    long_content = "C" * (_TASK_TEXT_LIMIT + 100)
    task_dao = _FakeTaskDao(
        _FakeTask(task_id="task-3", title=long_title, content=long_content)
    )
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-3",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["title"] == "T" * _TASK_TEXT_LIMIT + f"…(truncated, total {len(long_title)} chars)"
    assert result["title_truncated"] is True
    assert result["title_original_size"] == len(long_title)
    assert result["content"] == "C" * _TASK_TEXT_LIMIT + f"…(truncated, total {len(long_content)} chars)"
    assert result["content_truncated"] is True
    assert result["content_original_size"] == len(long_content)


@pytest.mark.anyio
async def test_handle_task_claimed_does_not_query_db() -> None:
    """A status-only event (TASK_CLAIMED) MUST NOT trigger a DB body lookup."""
    task_dao = _FakeTaskDao(_FakeTask(task_id="task-4"))
    handler = _make_handler(task_dao)
    base = {"type": "team.task.claimed", "team_id": "team-1", "member_id": "worker-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CLAIMED,
        team_name="team-1",
        timestamp=123,
        task_id="task-4",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["task_id"] == "task-4"
    assert result["status"] == "in_progress"
    assert "title" not in result
    assert "content" not in result
    assert task_dao.get_task_call_count == 0


@pytest.mark.anyio
async def test_handle_task_emits_task_id_and_status_when_lookup_raises() -> None:
    """If the DB lookup raises, the event still carries task_id + status (no body)."""
    failing_mock = AsyncMock(side_effect=RuntimeError("db down"))
    task_dao = _FakeTaskDao(get_task_mock=failing_mock)
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-5",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["task_id"] == "task-5"
    assert result["status"] == "pending"
    assert "title" not in result
    assert "content" not in result


@pytest.mark.anyio
async def test_handle_task_emits_task_id_and_status_when_task_not_found() -> None:
    """If get_task returns None (task not in DB), event carries task_id + status only."""
    task_dao = _FakeTaskDao(task=None)
    handler = _make_handler(task_dao)
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-missing",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["task_id"] == "task-missing"
    assert result["status"] == "pending"
    assert "title" not in result
    assert "content" not in result
    assert task_dao.get_task_call_count == 1


@pytest.mark.anyio
async def test_handle_task_emits_task_id_and_status_when_monitor_lacks_db() -> None:
    """If monitor has no _db (AttributeError), event still carries task_id + status."""
    # No task_dao injected → _FakeMonitor has no _db attribute → AttributeError,
    # caught by _lookup_task_body, degrades to no-body event.
    handler = TeamMonitorHandler(
        _FakeMonitor(members=[], leader_member_name=None),
        "sess-1",
    )
    base = {"type": "team.task.created", "team_id": "team-1"}
    event = MonitorEvent(
        event_type=MonitorEventType.TASK_CREATED,
        team_name="team-1",
        timestamp=123,
        task_id="task-6",
        status=None,
    )

    result = await handler._handle_task(base, event)

    assert result["task_id"] == "task-6"
    assert result["status"] == "pending"
    assert "title" not in result
    assert "content" not in result


def test_task_body_event_types_contains_only_created_and_updated() -> None:
    """Only TASK_CREATED and TASK_UPDATED trigger the DB body lookup."""
    assert _TASK_BODY_EVENT_TYPES == {
        MonitorEventType.TASK_CREATED,
        MonitorEventType.TASK_UPDATED,
    }


# =====================================================================
# get_team_snapshot: title/content truncation (T2.1)
#
# ``get_team_snapshot`` feeds BOTH the ``team.task.status_snapshot`` live
# broadcast (emitted by ``_broadcast_team_state_snapshot``) AND the
# ``team.snapshot`` RPC (served by ``agent_ws_server._handle_team_snapshot``).
# So applying truncation here covers both exits (design D4).
# =====================================================================


@pytest.mark.anyio
async def test_get_team_snapshot_truncates_over_limit_title_and_keeps_under_limit_content() -> None:
    """A task whose title > limit gets a truncated title + flags; content ≤ limit
    gets no flags (and the content_truncated key MUST be absent)."""
    long_title = "T" * (_TASK_TEXT_LIMIT + 30)
    short_content = "do the research"
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("worker-1")],
            leader_member_name=None,
            tasks=[
                _FakeTask(
                    task_id="task-long",
                    title=long_title,
                    content=short_content,
                    status="in_progress",
                    assignee="worker-1",
                )
            ],
        ),
        "sess-snap-1",
    )

    snapshot = await handler.get_team_snapshot()
    assert snapshot is not None
    task = snapshot["tasks"][0]

    # title is truncated to first _TASK_TEXT_LIMIT + inline marker carrying ORIGINAL size.
    assert task["title"] == "T" * _TASK_TEXT_LIMIT + f"…(truncated, total {len(long_title)} chars)"
    assert task["title_truncated"] is True
    assert task["title_original_size"] == len(long_title)
    # content under the limit → no truncation flags, and the flag keys must
    # be ABSENT (not just falsy).
    assert task["content"] == short_content
    assert "content_truncated" not in task
    assert "content_original_size" not in task
    # Non-body fields untouched.
    assert task["task_id"] == "task-long"
    assert task["status"] == "in_progress"
    assert task["assignee"] == "worker-1"


@pytest.mark.anyio
async def test_get_team_snapshot_truncates_over_limit_content_and_attaches_flags() -> None:
    """A task whose content > limit gets a truncated content + flags."""
    short_title = "research plan"
    long_content = "C" * (_TASK_TEXT_LIMIT + 75)
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("worker-1")],
            leader_member_name=None,
            tasks=[
                _FakeTask(
                    task_id="task-c",
                    title=short_title,
                    content=long_content,
                    status="pending",
                )
            ],
        ),
        "sess-snap-2",
    )

    snapshot = await handler.get_team_snapshot()
    assert snapshot is not None
    task = snapshot["tasks"][0]

    assert task["title"] == short_title
    assert "title_truncated" not in task
    assert task["content"] == "C" * _TASK_TEXT_LIMIT + f"…(truncated, total {len(long_content)} chars)"
    assert task["content_truncated"] is True
    assert task["content_original_size"] == len(long_content)


@pytest.mark.anyio
async def test_get_team_snapshot_under_limit_title_and_content_emit_no_flag_keys() -> None:
    """Both title and content ≤ limit → no flag keys at all."""
    handler = TeamMonitorHandler(
        _FakeMonitor(
            members=[_FakeMember("worker-1")],
            leader_member_name=None,
            tasks=[
                _FakeTask(
                    task_id="task-short",
                    title="short title",
                    content="short content",
                    status="completed",
                )
            ],
        ),
        "sess-snap-3",
    )

    snapshot = await handler.get_team_snapshot()
    assert snapshot is not None
    task = snapshot["tasks"][0]

    assert task["title"] == "short title"
    assert task["content"] == "short content"
    assert "title_truncated" not in task
    assert "title_original_size" not in task
    assert "content_truncated" not in task
    assert "content_original_size" not in task


# ---------------------------------------------------------------------------
# get_team_snapshot_from_db — monitor-down history restore path
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_get_team_snapshot_from_db_requires_session_and_team() -> None:
    assert await TeamMonitorHandler.get_team_snapshot_from_db("", "team-1") is None
    assert await TeamMonitorHandler.get_team_snapshot_from_db("sess-1", "") is None


@pytest.mark.anyio
@pytest.mark.parametrize("stored_status,expected_status", [
    ("pending", "pending"),
    ("in_progress", "in_progress"),
    ("completed", "completed"),
    ("cancelled", "cancelled"),
    ("claimed", "in_progress"),
    ("started", "in_progress"),
    ("plan_approved", "in_progress"),
])
async def test_get_team_snapshot_from_db_reads_tasks_with_truncation(
    stored_status: str, expected_status: str,
) -> None:
    """When monitor is down, bind session_id and read tasks/members from team.db."""
    from pathlib import Path
    from unittest.mock import patch

    long_title = "T" * (_TASK_TEXT_LIMIT + 20)
    member = _FakeMember("worker-1", display_name="Worker")
    leader = _FakeMember("team-leader", role="leader")
    task = _FakeTask(
        task_id="uuid-1",
        title=long_title,
        content="body",
        status=stored_status,
        assignee="worker-1",
        updated_at=123,
    )

    class _FakeTeamInfo:
        leader_member_name = "team-leader"

    class _FakeSharedDb:
        def __init__(self) -> None:
            self.member = SimpleNamespace(
                get_team_members=AsyncMock(return_value=[leader, member])
            )
            self.task = SimpleNamespace(
                get_team_tasks=AsyncMock(return_value=[task]),
                get_team_dependencies=AsyncMock(return_value=[
                    SimpleNamespace(task_id="b", depends_on_task_id="a", resolved=True)
                ])
            )
            self.team = SimpleNamespace(
                get_team=AsyncMock(return_value=_FakeTeamInfo())
            )
            self.initialize = AsyncMock()
            self.create_cur_session_tables = AsyncMock()

    shared = _FakeSharedDb()
    bound: list[str] = []

    def _fake_set_session_id(sid: str):
        bound.append(sid)
        return "token"

    with (
        patch(
            "jiuwenswarm.agents.harness.team.config_loader.resolve_team_sqlite_db_path",
            return_value=Path("/tmp/team.db"),
        ),
        patch("jiuwenswarm.common.config.get_config", return_value={}),
        patch(
            "openjiuwen.agent_teams.spawn.shared_resources.get_shared_db",
            return_value=shared,
        ),
        patch(
            "openjiuwen.agent_teams.tools.database.config.DatabaseConfig",
            return_value=SimpleNamespace(),
        ),
        patch(
            "openjiuwen.agent_teams.context.set_session_id",
            side_effect=_fake_set_session_id,
        ),
        patch(
            "openjiuwen.agent_teams.context.reset_session_id",
            return_value=None,
        ),
    ):
        snapshot = await TeamMonitorHandler.get_team_snapshot_from_db(
            "sess-19f8", "team-sess-1"
        )

        edges = await TeamMonitorHandler.get_team_dependencies_from_db("sess-19f8", "team-sess-1")

    assert edges == [{"task_id": "b", "depends_on_task_id": "a", "resolved": True}]
    assert snapshot is not None
    assert bound == ["sess-19f8", "sess-19f8"]
    shared.initialize.assert_awaited()
    shared.create_cur_session_tables.assert_not_awaited()
    assert snapshot["team_id"] == "team-sess-1"
    assert [m["member_id"] for m in snapshot["members"]] == ["worker-1"]
    assert len(snapshot["tasks"]) == 1
    out = snapshot["tasks"][0]
    assert out["task_id"] == "uuid-1"
    assert out["status"] == expected_status
    assert task.status == stored_status
    assert out["assignee"] == "worker-1"
    assert out["title_truncated"] is True
    assert out["title"].startswith("T" * _TASK_TEXT_LIMIT)
    assert out["content"] == "body"
    assert "content_truncated" not in out