769 lines
27 KiB
Python
769 lines
27 KiB
Python
"""ExpertTeam 容器单元测试"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from unittest.mock import AsyncMock, MagicMock, patch
|
||
|
||
import pytest
|
||
|
||
from agentkit.core.config_driven import ConfigDrivenAgent
|
||
from agentkit.core.handoff_transport import InProcessHandoffTransport
|
||
from agentkit.core.shared_workspace import SharedWorkspace
|
||
from agentkit.experts.config import ExpertConfig, ExpertTemplate
|
||
from agentkit.experts.expert import Expert
|
||
from agentkit.experts.plan import (
|
||
CollaborationPlan,
|
||
PlanPhase,
|
||
PlanStatus,
|
||
)
|
||
from agentkit.experts.registry import ExpertTemplateRegistry
|
||
from agentkit.experts.team import ExpertTeam, TeamStatus
|
||
|
||
|
||
# ── 辅助函数 ──────────────────────────────────────────────
|
||
|
||
|
||
def _make_expert_config(
|
||
name: str = "test_expert",
|
||
agent_type: str = "expert",
|
||
persona: str = "测试专家",
|
||
thinking_style: str = "逻辑推理",
|
||
bound_skills: list[str] | None = None,
|
||
is_lead: bool = False,
|
||
**kwargs,
|
||
) -> ExpertConfig:
|
||
"""创建测试用 ExpertConfig 实例"""
|
||
return ExpertConfig(
|
||
name=name,
|
||
agent_type=agent_type,
|
||
persona=persona,
|
||
thinking_style=thinking_style,
|
||
bound_skills=bound_skills or ["skill_a"],
|
||
is_lead=is_lead,
|
||
task_mode="llm_generate",
|
||
prompt={"identity": "测试"},
|
||
**kwargs,
|
||
)
|
||
|
||
|
||
def _make_mock_agent() -> MagicMock:
|
||
"""创建 mock ConfigDrivenAgent"""
|
||
agent = MagicMock(spec=ConfigDrivenAgent)
|
||
agent.name = "test_expert"
|
||
agent._prompt_template = None
|
||
return agent
|
||
|
||
|
||
def _make_mock_pool() -> AsyncMock:
|
||
"""创建 mock AgentPool"""
|
||
pool = AsyncMock()
|
||
pool.create_agent = AsyncMock(return_value=_make_mock_agent())
|
||
pool.remove_agent = AsyncMock()
|
||
return pool
|
||
|
||
|
||
def _make_mock_expert(
|
||
name: str = "test_expert",
|
||
is_lead: bool = False,
|
||
is_active: bool = True,
|
||
) -> MagicMock:
|
||
"""创建 mock Expert"""
|
||
config = _make_expert_config(name=name, is_lead=is_lead)
|
||
expert = MagicMock(spec=Expert)
|
||
expert.config = config
|
||
expert.is_active = is_active
|
||
expert.team_id = None
|
||
expert.get_capabilities_summary.return_value = {
|
||
"name": name,
|
||
"persona": config.persona,
|
||
"thinking_style": config.thinking_style,
|
||
"bound_skills": config.bound_skills,
|
||
"is_lead": is_lead,
|
||
}
|
||
expert.destroy = AsyncMock()
|
||
return expert
|
||
|
||
|
||
def _make_valid_plan(
|
||
plan_id: str = "plan_1",
|
||
task: str = "测试任务",
|
||
lead_expert: str = "lead",
|
||
) -> CollaborationPlan:
|
||
"""创建有效的 CollaborationPlan"""
|
||
return CollaborationPlan(
|
||
id=plan_id,
|
||
task=task,
|
||
phases=[
|
||
PlanPhase(
|
||
id="phase_1",
|
||
name="阶段1",
|
||
assigned_expert=lead_expert,
|
||
task_description="执行任务",
|
||
)
|
||
],
|
||
lead_expert=lead_expert,
|
||
)
|
||
|
||
|
||
# ── ExpertTeam 创建测试 ───────────────────────────────────
|
||
|
||
|
||
class TestExpertTeamCreation:
|
||
"""ExpertTeam 初始化与默认值测试"""
|
||
|
||
def test_default_values(self):
|
||
"""默认值：自动生成 team_id，FORMING 状态"""
|
||
team = ExpertTeam()
|
||
|
||
assert team.team_id is not None
|
||
assert len(team.team_id) > 0
|
||
assert team.status == TeamStatus.FORMING
|
||
assert team.lead_expert is None
|
||
assert team.plan is None
|
||
assert team.experts == []
|
||
assert team.active_experts == []
|
||
|
||
def test_custom_team_id(self):
|
||
"""自定义 team_id"""
|
||
team = ExpertTeam(team_id="my_team")
|
||
|
||
assert team.team_id == "my_team"
|
||
|
||
def test_custom_workspace(self):
|
||
"""自定义 SharedWorkspace"""
|
||
workspace = SharedWorkspace()
|
||
team = ExpertTeam(workspace=workspace)
|
||
|
||
assert team._workspace is workspace
|
||
|
||
def test_custom_pool(self):
|
||
"""自定义 AgentPool"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
assert team._pool is pool
|
||
|
||
def test_custom_template_registry(self):
|
||
"""自定义 ExpertTemplateRegistry"""
|
||
registry = ExpertTemplateRegistry()
|
||
team = ExpertTeam(template_registry=registry)
|
||
|
||
assert team._template_registry is registry
|
||
|
||
|
||
# ── ExpertTeam.create_team 测试 ────────────────────────────
|
||
|
||
|
||
class TestExpertTeamCreateTeam:
|
||
"""ExpertTeam.create_team 团队创建测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_team_with_lead_only(self):
|
||
"""仅创建 Lead Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
mock_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = mock_expert
|
||
|
||
await team.create_team(lead_config)
|
||
|
||
assert team._lead_expert_name == "lead"
|
||
assert team.lead_expert is mock_expert
|
||
assert team.status == TeamStatus.PLANNING
|
||
assert mock_expert.team_id == team.team_id
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_team_with_lead_and_members(self):
|
||
"""创建 Lead Expert 和成员 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1", is_lead=False)
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1", is_lead=False)
|
||
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
assert len(team.experts) == 2
|
||
assert team._lead_expert_name == "lead"
|
||
assert team.status == TeamStatus.PLANNING
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_team_without_pool_raises(self):
|
||
"""没有 AgentPool 时 create_team 抛出 RuntimeError"""
|
||
team = ExpertTeam(pool=None)
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
|
||
with pytest.raises(RuntimeError, match="AgentPool not configured"):
|
||
await team.create_team(lead_config)
|
||
|
||
|
||
# ── ExpertTeam.add_expert 测试 ─────────────────────────────
|
||
|
||
|
||
class TestExpertTeamAddExpert:
|
||
"""ExpertTeam.add_expert 动态添加 Expert 测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_add_expert_with_config(self):
|
||
"""通过 ExpertConfig 添加 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
# 先创建团队
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
# 添加新成员
|
||
new_config = _make_expert_config(name="new_member")
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
new_expert = _make_mock_expert(name="new_member")
|
||
mock_create.return_value = new_expert
|
||
|
||
result = await team.add_expert(new_config)
|
||
|
||
assert result is new_expert
|
||
assert "new_member" in team._experts
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_add_expert_with_template_name(self):
|
||
"""通过模板名称添加 Expert"""
|
||
pool = _make_mock_pool()
|
||
registry = ExpertTemplateRegistry()
|
||
template_config = _make_expert_config(name="analyst", persona="分析师")
|
||
registry.register(ExpertTemplate(name="analyst", config=template_config))
|
||
|
||
team = ExpertTeam(pool=pool, template_registry=registry)
|
||
|
||
# 先创建团队
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
# 通过模板名称添加
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
analyst_expert = _make_mock_expert(name="analyst")
|
||
mock_create.return_value = analyst_expert
|
||
|
||
result = await team.add_expert("analyst")
|
||
|
||
assert result is analyst_expert
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_add_expert_with_nonexistent_template_raises(self):
|
||
"""使用不存在的模板名称添加 Expert 抛出 ValueError"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
# 先创建团队
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
with pytest.raises(ValueError, match="ExpertTemplate 'nonexistent' not found"):
|
||
await team.add_expert("nonexistent")
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_add_expert_broadcasts_joined_message(self):
|
||
"""添加 Expert 时广播 expert_joined 消息"""
|
||
pool = _make_mock_pool()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
team = ExpertTeam(pool=pool)
|
||
team._handoff_transport = transport
|
||
|
||
# 先创建团队
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
# 添加新成员
|
||
new_config = _make_expert_config(name="new_member")
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
new_expert = _make_mock_expert(name="new_member")
|
||
mock_create.return_value = new_expert
|
||
|
||
await team.add_expert(new_config)
|
||
|
||
# 验证 broadcast 消息（create_team 也会调用 send，所以检查最后一次）
|
||
calls = transport.send.call_args_list
|
||
joined_calls = [
|
||
c for c in calls if c[0][1].get("type") == "expert_joined"
|
||
]
|
||
assert len(joined_calls) >= 1
|
||
last_joined = joined_calls[-1]
|
||
assert last_joined[0][1]["expert_name"] == "new_member"
|
||
|
||
|
||
# ── ExpertTeam.remove_expert 测试 ──────────────────────────
|
||
|
||
|
||
class TestExpertTeamRemoveExpert:
|
||
"""ExpertTeam.remove_expert 移除 Expert 测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_remove_expert(self):
|
||
"""移除普通 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1")
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
await team.remove_expert("member1")
|
||
|
||
assert "member1" not in team._experts
|
||
member_expert.destroy.assert_awaited_once_with(pool)
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_remove_lead_expert_reassigns(self):
|
||
"""移除 Lead Expert 时重新分配给下一个活跃 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1")
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
await team.remove_expert("lead")
|
||
|
||
assert team._lead_expert_name == "member1"
|
||
assert member_expert.config.is_lead is True
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_remove_lead_expert_no_active_members(self):
|
||
"""移除 Lead Expert 且无其他活跃成员时 lead_expert_name 为 None"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
await team.remove_expert("lead")
|
||
|
||
assert team._lead_expert_name is None
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_remove_nonexistent_expert_no_error(self):
|
||
"""移除不存在的 Expert 不报错"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
# 不应抛出异常
|
||
await team.remove_expert("nonexistent")
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_remove_expert_broadcasts_left_message(self):
|
||
"""移除 Expert 时广播 expert_left 消息"""
|
||
pool = _make_mock_pool()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
team = ExpertTeam(pool=pool)
|
||
team._handoff_transport = transport
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1")
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
await team.remove_expert("member1")
|
||
|
||
# 验证 expert_left 消息
|
||
calls = transport.send.call_args_list
|
||
left_calls = [c for c in calls if c[0][1].get("type") == "expert_left"]
|
||
assert len(left_calls) >= 1
|
||
last_left = left_calls[-1]
|
||
assert last_left[0][1]["expert_name"] == "member1"
|
||
|
||
|
||
# ── ExpertTeam.update_plan 测试 ────────────────────────────
|
||
|
||
|
||
class TestExpertTeamUpdatePlan:
|
||
"""ExpertTeam.update_plan 协作计划更新测试"""
|
||
|
||
def test_update_plan_with_valid_plan(self):
|
||
"""有效计划更新成功，返回受影响的 Expert 名称"""
|
||
team = ExpertTeam()
|
||
plan = _make_valid_plan(lead_expert="lead")
|
||
|
||
affected = team.update_plan(plan)
|
||
|
||
assert team.plan is plan
|
||
assert "lead" in affected
|
||
|
||
def test_update_plan_confirmed_sets_executing(self):
|
||
"""CONFIRMED 状态的计划将团队状态设为 EXECUTING"""
|
||
team = ExpertTeam()
|
||
plan = _make_valid_plan(lead_expert="lead")
|
||
plan.status = PlanStatus.CONFIRMED
|
||
|
||
team.update_plan(plan)
|
||
|
||
assert team.status == TeamStatus.EXECUTING
|
||
|
||
def test_update_plan_with_invalid_plan_no_update(self):
|
||
"""无效计划（validate 返回错误）不更新，返回验证错误列表"""
|
||
team = ExpertTeam()
|
||
# 创建有循环依赖的无效计划
|
||
plan = CollaborationPlan(
|
||
id="bad_plan",
|
||
task="无效任务",
|
||
phases=[
|
||
PlanPhase(
|
||
id="p1",
|
||
name="阶段1",
|
||
assigned_expert="a",
|
||
task_description="t1",
|
||
depends_on=["p2"],
|
||
),
|
||
PlanPhase(
|
||
id="p2",
|
||
name="阶段2",
|
||
assigned_expert="b",
|
||
task_description="t2",
|
||
depends_on=["p1"],
|
||
),
|
||
],
|
||
lead_expert="lead",
|
||
)
|
||
|
||
result = team.update_plan(plan)
|
||
|
||
assert len(result) > 0 # 返回验证错误而非空列表
|
||
assert team.plan is None # 未更新
|
||
|
||
|
||
# ── ExpertTeam.broadcast_user_message 测试 ─────────────────
|
||
|
||
|
||
class TestExpertTeamBroadcastUserMessage:
|
||
"""ExpertTeam.broadcast_user_message 用户干预消息广播测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_broadcast_user_message(self):
|
||
"""广播用户干预消息到团队频道"""
|
||
team = ExpertTeam()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
team._handoff_transport = transport
|
||
|
||
await team.broadcast_user_message("请暂停执行")
|
||
|
||
transport.send.assert_awaited_once()
|
||
call_args = transport.send.call_args
|
||
assert call_args[0][0] == team._team_channel
|
||
message = call_args[0][1]
|
||
assert message["type"] == "user_intervention"
|
||
assert message["content"] == "请暂停执行"
|
||
assert "timestamp" in message
|
||
|
||
|
||
# ── ExpertTeam.get_shared_context 测试 ────────────────────
|
||
|
||
|
||
class TestExpertTeamGetSharedContext:
|
||
"""ExpertTeam.get_shared_context 共享上下文读取测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_get_shared_context_reads_team_keys(self):
|
||
"""读取团队范围的共享上下文"""
|
||
workspace = AsyncMock(spec=SharedWorkspace)
|
||
workspace.list_keys = AsyncMock(
|
||
return_value=[
|
||
"team:abc:output1",
|
||
"team:abc:output2",
|
||
"other:key",
|
||
]
|
||
)
|
||
workspace.read = AsyncMock(
|
||
side_effect=lambda key: {"value": f"data_{key}"} if key.startswith("team:abc") else None
|
||
)
|
||
|
||
team = ExpertTeam(team_id="abc", workspace=workspace)
|
||
|
||
context = await team.get_shared_context()
|
||
|
||
assert "team:abc:output1" in context
|
||
assert "team:abc:output2" in context
|
||
assert "other:key" not in context
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_get_shared_context_empty(self):
|
||
"""没有团队范围的键时返回空字典"""
|
||
workspace = AsyncMock(spec=SharedWorkspace)
|
||
workspace.list_keys = AsyncMock(return_value=[])
|
||
|
||
team = ExpertTeam(team_id="abc", workspace=workspace)
|
||
|
||
context = await team.get_shared_context()
|
||
|
||
assert context == {}
|
||
|
||
|
||
# ── ExpertTeam.generate_plan 测试 ──────────────────────────
|
||
|
||
|
||
class TestExpertTeamGeneratePlan:
|
||
"""ExpertTeam.generate_plan 计划生成测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_generate_plan(self):
|
||
"""生成空的 CollaborationPlan"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
plan = await team.generate_plan("分析数据")
|
||
|
||
assert plan is not None
|
||
assert plan.task == "分析数据"
|
||
assert plan.lead_expert == "lead"
|
||
assert plan.phases == []
|
||
assert team.plan is plan
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_generate_plan_without_lead(self):
|
||
"""没有 Lead Expert 时生成计划，lead_expert 为空字符串"""
|
||
team = ExpertTeam()
|
||
|
||
plan = await team.generate_plan("测试任务")
|
||
|
||
assert plan.lead_expert == ""
|
||
|
||
|
||
# ── ExpertTeam.dissolve 测试 ───────────────────────────────
|
||
|
||
|
||
class TestExpertTeamDissolve:
|
||
"""ExpertTeam.dissolve 团队解散测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_dissolve_recycles_experts(self):
|
||
"""解散团队时回收所有 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1")
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
await team.dissolve()
|
||
|
||
assert team.status == TeamStatus.DISSOLVED
|
||
assert team.experts == []
|
||
assert team._lead_expert_name is None
|
||
lead_expert.destroy.assert_awaited_once_with(pool)
|
||
member_expert.destroy.assert_awaited_once_with(pool)
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_dissolve_preserves_outputs_in_workspace(self):
|
||
"""解散团队后 SharedWorkspace 中的输出仍保留"""
|
||
workspace = SharedWorkspace()
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool, workspace=workspace)
|
||
|
||
# 写入一些数据到 workspace
|
||
await workspace.write("team:abc:result", "重要输出", "lead")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
await team.create_team(lead_config)
|
||
|
||
await team.dissolve()
|
||
|
||
# workspace 数据仍然存在
|
||
data = await workspace.read("team:abc:result")
|
||
assert data is not None
|
||
assert data["value"] == "重要输出"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_dissolve_closes_handoff_transport(self):
|
||
"""解散团队时关闭 handoff_transport"""
|
||
pool = _make_mock_pool()
|
||
transport = MagicMock(spec=InProcessHandoffTransport)
|
||
transport.close = MagicMock()
|
||
team = ExpertTeam(pool=pool)
|
||
team._handoff_transport = transport
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
await team.create_team(lead_config)
|
||
|
||
await team.dissolve()
|
||
|
||
transport.close.assert_called_once()
|
||
|
||
|
||
# ── ExpertTeam 操作已解散团队测试 ──────────────────────────
|
||
|
||
|
||
class TestExpertTeamDissolvedOperations:
|
||
"""解散后的团队操作应报错"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_team_on_dissolved_raises(self):
|
||
"""在已解散的团队上 create_team 应报错（因为 pool 可能已被清理）"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
await team.create_team(lead_config)
|
||
|
||
await team.dissolve()
|
||
|
||
# 解散后状态为 DISSOLVED
|
||
assert team.status == TeamStatus.DISSOLVED
|
||
|
||
# 再次 create_team 时，由于 experts 已清空，
|
||
# 但 pool 仍然存在，理论上可以重新创建
|
||
# 但这里验证状态是 DISSOLVED
|
||
assert team.status == TeamStatus.DISSOLVED
|
||
|
||
|
||
# ── ExpertTeam.lead_expert 属性测试 ────────────────────────
|
||
|
||
|
||
class TestExpertTeamLeadExpert:
|
||
"""ExpertTeam.lead_expert 属性测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_lead_expert_returns_lead(self):
|
||
"""lead_expert 返回 Lead Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
mock_create.return_value = lead_expert
|
||
await team.create_team(lead_config)
|
||
|
||
assert team.lead_expert is lead_expert
|
||
|
||
def test_lead_expert_none_when_no_lead(self):
|
||
"""没有 Lead Expert 时返回 None"""
|
||
team = ExpertTeam()
|
||
|
||
assert team.lead_expert is None
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_active_experts_filters_inactive(self):
|
||
"""active_experts 只返回活跃的 Expert"""
|
||
pool = _make_mock_pool()
|
||
team = ExpertTeam(pool=pool)
|
||
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
member_config = _make_expert_config(name="member1")
|
||
|
||
with patch.object(Expert, "create", new_callable=AsyncMock) as mock_create:
|
||
lead_expert = _make_mock_expert(name="lead", is_lead=True)
|
||
member_expert = _make_mock_expert(name="member1")
|
||
mock_create.side_effect = [lead_expert, member_expert]
|
||
await team.create_team(lead_config, [member_config])
|
||
|
||
# 标记 member1 为非活跃
|
||
member_expert.is_active = False
|
||
|
||
active = team.active_experts
|
||
assert len(active) == 1
|
||
assert active[0] is lead_expert
|
||
|
||
|
||
# ── ExpertTeam._build_team_context 测试 ────────────────────
|
||
|
||
|
||
class TestExpertTeamBuildContext:
|
||
"""ExpertTeam._build_team_context 团队上下文构建测试"""
|
||
|
||
def test_build_team_context_with_lead_and_members(self):
|
||
"""构建包含 Lead 和成员的团队上下文"""
|
||
team = ExpertTeam()
|
||
|
||
lead_config = _make_expert_config(
|
||
name="lead", persona="领导者", is_lead=True
|
||
)
|
||
member_config = _make_expert_config(
|
||
name="analyst", persona="分析师", bound_skills=["data_query"]
|
||
)
|
||
|
||
context = team._build_team_context(lead_config, [member_config])
|
||
|
||
assert "You are part of an Expert Team." in context
|
||
assert "Lead Expert: lead (领导者)" in context
|
||
assert "Team Member: analyst (分析师), Skills: data_query" in context
|
||
assert "send_message() and request_assist()" in context
|
||
|
||
def test_build_team_context_no_lead(self):
|
||
"""没有 Lead Expert 时构建上下文"""
|
||
team = ExpertTeam()
|
||
member_config = _make_expert_config(name="analyst")
|
||
|
||
context = team._build_team_context(None, [member_config])
|
||
|
||
assert "Lead Expert" not in context
|
||
assert "Team Member: analyst" in context
|
||
|
||
def test_build_team_context_skips_lead_in_members(self):
|
||
"""成员列表中包含 Lead 时跳过"""
|
||
team = ExpertTeam()
|
||
lead_config = _make_expert_config(name="lead", is_lead=True)
|
||
|
||
context = team._build_team_context(lead_config, [lead_config])
|
||
|
||
# Lead 不应出现在 Team Member 行
|
||
assert "Team Member: lead" not in context
|