527 lines
20 KiB
Python
527 lines
20 KiB
Python
"""Tests for _execute_team_collab in chat.py (U6).
|
||
|
||
Tests cover:
|
||
- @team prefix triggers team collaboration (returns True)
|
||
- Non-@team input does not trigger (returns False)
|
||
- @team without task content sends error
|
||
- Team events are relayed to WebSocket via emit_team_event
|
||
- final_answer is sent after execution
|
||
- User message and final result are persisted to session history
|
||
- Team is dissolved after execution
|
||
- Execution failure sends error and dissolves team
|
||
- @team and @board do not interfere with each other
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from unittest.mock import AsyncMock, MagicMock, patch
|
||
|
||
import pytest
|
||
|
||
from agentkit.experts.config import ExpertConfig, ExpertTemplate
|
||
from agentkit.experts.registry import ExpertTemplateRegistry
|
||
from agentkit.server.routes.chat import _execute_team_collab
|
||
from agentkit.session.manager import SessionManager
|
||
from agentkit.session.models import MessageRole
|
||
from agentkit.session.store import InMemorySessionStore
|
||
|
||
|
||
# ── 辅助函数 ──────────────────────────────────────────────
|
||
|
||
|
||
def _make_expert_template(
|
||
name: str,
|
||
persona: str = "测试专家",
|
||
is_lead: bool = False,
|
||
) -> ExpertTemplate:
|
||
"""创建测试用 ExpertTemplate"""
|
||
config = ExpertConfig(
|
||
name=name,
|
||
agent_type="expert",
|
||
persona=persona,
|
||
thinking_style="analytical",
|
||
bound_skills=[],
|
||
is_lead=is_lead,
|
||
task_mode="llm_generate",
|
||
prompt={"identity": persona},
|
||
)
|
||
return ExpertTemplate(
|
||
name=name,
|
||
config=config,
|
||
is_builtin=True,
|
||
description=f"{name} 模板",
|
||
)
|
||
|
||
|
||
def _make_registry_with_dev_team() -> ExpertTemplateRegistry:
|
||
"""创建包含 dev_team 模板和成员模板的注册中心"""
|
||
registry = ExpertTemplateRegistry()
|
||
registry.register(_make_expert_template("tech_lead", persona="技术负责人"))
|
||
registry.register(_make_expert_template("frontend_engineer", persona="前端工程师"))
|
||
registry.register(_make_expert_template("backend_engineer", persona="后端工程师"))
|
||
# dev_team 模板（bound_skills 存储成员列表）
|
||
registry.register(
|
||
ExpertTemplate(
|
||
name="dev_team",
|
||
config=ExpertConfig(
|
||
name="dev_team",
|
||
agent_type="expert",
|
||
persona="编程团队",
|
||
thinking_style="流水线",
|
||
bound_skills=["tech_lead", "frontend_engineer", "backend_engineer"],
|
||
task_mode="llm_generate",
|
||
prompt={"identity": "Dev Team"},
|
||
),
|
||
is_builtin=True,
|
||
description="编程团队模板",
|
||
)
|
||
)
|
||
return registry
|
||
|
||
|
||
class FakeWebSocket:
|
||
"""Minimal WebSocket fake for testing."""
|
||
|
||
def __init__(self) -> None:
|
||
self.sent: list[dict] = []
|
||
self.app = MagicMock()
|
||
self.app.state.agent_pool = MagicMock()
|
||
self.app.state.expert_template_registry = None # Will be set per-test
|
||
|
||
async def send_json(self, data: dict) -> None:
|
||
self.sent.append(data)
|
||
|
||
|
||
def _make_mock_team() -> MagicMock:
|
||
"""创建 mock ExpertTeam 实例"""
|
||
mock_team = MagicMock()
|
||
mock_team.team_channel = "team:test"
|
||
mock_team.handoff_transport = MagicMock()
|
||
mock_team.handoff_transport.register_handler = MagicMock()
|
||
mock_team.handoff_transport._handlers = {}
|
||
mock_team.create_team = AsyncMock()
|
||
mock_team.dissolve = AsyncMock()
|
||
return mock_team
|
||
|
||
|
||
def _make_mock_orchestrator(result: dict) -> MagicMock:
|
||
"""创建 mock TeamOrchestrator 实例"""
|
||
mock_orch = MagicMock()
|
||
mock_orch.execute = AsyncMock(return_value=result)
|
||
return mock_orch
|
||
|
||
|
||
@pytest.fixture
|
||
async def session_manager() -> SessionManager:
|
||
sm = SessionManager(store=InMemorySessionStore())
|
||
session = await sm.create_session(agent_name="test-agent")
|
||
sm._test_session_id = session.session_id
|
||
return sm
|
||
|
||
|
||
@pytest.fixture
|
||
def websocket() -> FakeWebSocket:
|
||
ws = FakeWebSocket()
|
||
ws.app.state.expert_template_registry = _make_registry_with_dev_team()
|
||
return ws
|
||
|
||
|
||
@pytest.fixture
|
||
def mock_orchestrator_result() -> dict:
|
||
"""Mock result from TeamOrchestrator.execute()"""
|
||
return {
|
||
"status": "completed",
|
||
"result": {"content": "## 团队最终结果\n\n用户登录功能已实现"},
|
||
"phase_results": {
|
||
"phase-1": {"content": "规划完成", "phase_name": "规划"},
|
||
"phase-2": {"content": "前端实现完成", "phase_name": "前端"},
|
||
},
|
||
"plan": MagicMock(),
|
||
}
|
||
|
||
|
||
# ── 路由匹配测试 ──────────────────────────────────────────
|
||
|
||
|
||
class TestTeamCollabRouting:
|
||
"""_execute_team_collab 路由匹配测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_prefix_triggers_collab(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""@team 前缀触发团队协作，返回 True"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "@team 开发用户登录功能", session_manager
|
||
)
|
||
|
||
assert result is True
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_non_team_input_does_not_trigger(self, websocket, session_manager):
|
||
"""非 @team 输入不触发，返回 False"""
|
||
session_id = session_manager._test_session_id
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "普通问题", session_manager
|
||
)
|
||
assert result is False
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_board_prefix_does_not_trigger_team(
|
||
self, websocket, session_manager
|
||
):
|
||
"""@board 前缀不触发 @team 协作"""
|
||
session_id = session_manager._test_session_id
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "@board 讨论主题", session_manager
|
||
)
|
||
assert result is False
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_with_dev_team_template(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""@team:dev_team 触发团队协作"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "@team:dev_team 开发功能", session_manager
|
||
)
|
||
|
||
assert result is True
|
||
|
||
|
||
# ── 错误处理测试 ──────────────────────────────────────────
|
||
|
||
|
||
class TestTeamCollabErrorHandling:
|
||
"""_execute_team_collab 错误处理测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_without_task_sends_error(
|
||
self, websocket, session_manager
|
||
):
|
||
"""@team 无任务内容时发送错误（通过 mock router 模拟空 task_content）"""
|
||
session_id = session_manager._test_session_id
|
||
# Mock ExpertTeamRouter to return empty task_content
|
||
mock_routing_result = MagicMock()
|
||
mock_routing_result.matched = True
|
||
mock_routing_result.task_content = "" # 空 task_content
|
||
mock_routing_result.specified_experts = ["tech_lead"]
|
||
|
||
with patch(
|
||
"agentkit.experts.router.ExpertTeamRouter"
|
||
) as mock_router_cls:
|
||
mock_router = MagicMock()
|
||
mock_router.resolve = MagicMock(return_value=mock_routing_result)
|
||
mock_router_cls.return_value = mock_router
|
||
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "@team", session_manager
|
||
)
|
||
|
||
assert result is True
|
||
# 应该发送了错误消息
|
||
assert any(
|
||
msg.get("type") == "error" and "描述" in msg.get("data", {}).get("message", "")
|
||
for msg in websocket.sent
|
||
)
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_execution_failure_sends_error(
|
||
self, websocket, session_manager
|
||
):
|
||
"""团队执行失败时发送错误并清理"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team = _make_mock_team()
|
||
mock_team_cls.return_value = mock_team
|
||
|
||
mock_orch_cls.return_value = _make_mock_orchestrator_result_failing()
|
||
|
||
result = await _execute_team_collab(
|
||
websocket, session_id, "@team 开发功能", session_manager
|
||
)
|
||
|
||
assert result is True
|
||
# 应该发送了错误消息
|
||
assert any(
|
||
msg.get("type") == "error"
|
||
and "团队协作执行失败" in msg.get("data", {}).get("message", "")
|
||
for msg in websocket.sent
|
||
)
|
||
# 应该调用了 dissolve 清理
|
||
mock_team.dissolve.assert_called()
|
||
# 失败时不应发送 final_answer
|
||
assert not any(msg.get("type") == "final_answer" for msg in websocket.sent)
|
||
|
||
|
||
def _make_mock_orchestrator_result_failing() -> MagicMock:
|
||
"""创建 mock TeamOrchestrator that raises an exception"""
|
||
mock_orch = MagicMock()
|
||
mock_orch.execute = AsyncMock(side_effect=RuntimeError("LLM 不可用"))
|
||
return mock_orch
|
||
|
||
|
||
# ── 事件中继与持久化测试 ──────────────────────────────────
|
||
|
||
|
||
class TestTeamCollabEventRelay:
|
||
"""_execute_team_collab 事件中继与持久化测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_final_answer_sent_after_execution(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""执行完成后发送 final_answer"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发登录功能", session_manager
|
||
)
|
||
|
||
final_msgs = [msg for msg in websocket.sent if msg.get("type") == "final_answer"]
|
||
assert len(final_msgs) == 1
|
||
assert "团队最终结果" in final_msgs[0]["content"]
|
||
assert final_msgs[0]["is_final"] is True
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_user_message_persisted(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""用户消息持久化到会话历史"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发登录功能", session_manager
|
||
)
|
||
|
||
messages = await session_manager.get_messages(session_id)
|
||
user_msgs = [m for m in messages if m.role == MessageRole.USER]
|
||
assert len(user_msgs) == 1
|
||
assert "@team 开发登录功能" in user_msgs[0].content
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_final_result_persisted(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""最终结果持久化为 assistant 消息"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发登录功能", session_manager
|
||
)
|
||
|
||
messages = await session_manager.get_messages(session_id)
|
||
assistant_msgs = [m for m in messages if m.role == MessageRole.ASSISTANT]
|
||
assert len(assistant_msgs) == 1
|
||
assert "团队最终结果" in assistant_msgs[0].content
|
||
assert assistant_msgs[0].agent_name == "team_collab"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_dissolved_after_execution(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""执行后 team.dissolve() 被调用"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team = _make_mock_team()
|
||
mock_team_cls.return_value = mock_team
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发登录功能", session_manager
|
||
)
|
||
|
||
mock_team.dissolve.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_handoff_handler_registered(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""handoff_transport handler 被注册用于事件中继"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team = _make_mock_team()
|
||
mock_team.team_channel = "team:test-channel"
|
||
mock_team_cls.return_value = mock_team
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发登录功能", session_manager
|
||
)
|
||
|
||
mock_team.handoff_transport.register_handler.assert_called_once()
|
||
call_args = mock_team.handoff_transport.register_handler.call_args
|
||
assert call_args[0][0] == "team:test-channel"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_team_events_relayed_to_websocket(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""注册的 handler 将团队事件转发到 WebSocket"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team = _make_mock_team()
|
||
mock_team.team_channel = "team:test-channel"
|
||
mock_team_cls.return_value = mock_team
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发功能", session_manager
|
||
)
|
||
|
||
# Get the registered handler and invoke it with a sample event
|
||
register_call = mock_team.handoff_transport.register_handler.call_args
|
||
handler = register_call[0][1] # second arg is the handler callback
|
||
await handler({"type": "expert_step", "expert": "lead", "message": "开始分析"})
|
||
|
||
# Verify the event was relayed to WebSocket via emit_team_event
|
||
team_event_msgs = [
|
||
msg for msg in websocket.sent
|
||
if msg.get("type") == "expert_step"
|
||
]
|
||
assert len(team_event_msgs) == 1
|
||
assert team_event_msgs[0].get("data", {}).get("expert") == "lead"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_team_called_with_lead_and_members(
|
||
self, websocket, session_manager, mock_orchestrator_result
|
||
):
|
||
"""create_team 以 lead_config 和 member_configs 调用"""
|
||
session_id = session_manager._test_session_id
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team = _make_mock_team()
|
||
mock_team_cls.return_value = mock_team
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(mock_orchestrator_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team:dev_team 开发功能", session_manager
|
||
)
|
||
|
||
mock_team.create_team.assert_called_once()
|
||
call_kwargs = mock_team.create_team.call_args.kwargs
|
||
# lead_config 应该是第一个专家（tech_lead）
|
||
assert call_kwargs["lead_config"].name == "tech_lead"
|
||
# member_configs 应该包含其余专家
|
||
member_names = [c.name for c in call_kwargs["member_configs"]]
|
||
assert "frontend_engineer" in member_names
|
||
assert "backend_engineer" in member_names
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_empty_synthesis_falls_back_to_phase_results(
|
||
self, websocket, session_manager
|
||
):
|
||
"""synthesis 结果为空时 fallback 到 phase_results"""
|
||
session_id = session_manager._test_session_id
|
||
empty_result = {
|
||
"status": "completed",
|
||
"result": {"content": ""}, # 空的 synthesis
|
||
"phase_results": {
|
||
"phase-1": {"content": "阶段1结果", "phase_name": "规划"},
|
||
"phase-2": {"content": "阶段2结果", "phase_name": "执行"},
|
||
},
|
||
"plan": MagicMock(),
|
||
}
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(empty_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发功能", session_manager
|
||
)
|
||
|
||
final_msgs = [msg for msg in websocket.sent if msg.get("type") == "final_answer"]
|
||
assert len(final_msgs) == 1
|
||
# 应该包含 phase_results 的内容
|
||
assert "阶段1结果" in final_msgs[0]["content"] and "阶段2结果" in final_msgs[0]["content"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_completely_empty_result(
|
||
self, websocket, session_manager
|
||
):
|
||
"""result 和 phase_results 都为空时发送默认消息"""
|
||
session_id = session_manager._test_session_id
|
||
empty_result = {
|
||
"status": "completed",
|
||
"result": {},
|
||
"phase_results": {},
|
||
"plan": MagicMock(),
|
||
}
|
||
with patch(
|
||
"agentkit.experts.team.ExpertTeam"
|
||
) as mock_team_cls, patch(
|
||
"agentkit.experts.orchestrator.TeamOrchestrator"
|
||
) as mock_orch_cls:
|
||
mock_team_cls.return_value = _make_mock_team()
|
||
mock_orch_cls.return_value = _make_mock_orchestrator(empty_result)
|
||
|
||
await _execute_team_collab(
|
||
websocket, session_id, "@team 开发功能", session_manager
|
||
)
|
||
|
||
final_msgs = [msg for msg in websocket.sent if msg.get("type") == "final_answer"]
|
||
assert len(final_msgs) == 1
|
||
assert "未生成最终结果" in final_msgs[0]["content"]
|