438 lines
15 KiB
Python
438 lines
15 KiB
Python
"""Expert 运行时包装器单元测试"""
|
||
|
||
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
|
||
from agentkit.experts.expert import Expert
|
||
|
||
|
||
# ── 辅助函数 ──────────────────────────────────────────────
|
||
|
||
|
||
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,
|
||
color: str = "#1890ff",
|
||
avatar: str = "",
|
||
**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,
|
||
color=color,
|
||
avatar=avatar,
|
||
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
|
||
|
||
|
||
# ── Expert 创建测试 ───────────────────────────────────────
|
||
|
||
|
||
class TestExpertCreate:
|
||
"""Expert.create 工厂方法测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_expert_via_pool(self):
|
||
"""通过 AgentPool 创建 Expert"""
|
||
config = _make_expert_config()
|
||
pool = _make_mock_pool()
|
||
|
||
expert = await Expert.create(config=config, pool=pool)
|
||
|
||
pool.create_agent.assert_awaited_once_with(config)
|
||
assert expert.config is config
|
||
assert expert.agent is pool.create_agent.return_value
|
||
assert expert.is_active is True
|
||
assert expert.team_id is None
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_with_handoff_transport(self):
|
||
"""创建 Expert 时传入 handoff_transport"""
|
||
config = _make_expert_config()
|
||
pool = _make_mock_pool()
|
||
transport = MagicMock(spec=InProcessHandoffTransport)
|
||
|
||
expert = await Expert.create(
|
||
config=config, pool=pool, handoff_transport=transport
|
||
)
|
||
|
||
assert expert._handoff_transport is transport
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_with_workspace(self):
|
||
"""创建 Expert 时传入 workspace"""
|
||
config = _make_expert_config()
|
||
pool = _make_mock_pool()
|
||
workspace = MagicMock(spec=SharedWorkspace)
|
||
|
||
expert = await Expert.create(
|
||
config=config, pool=pool, workspace=workspace
|
||
)
|
||
|
||
assert expert._workspace is workspace
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_with_team_context_injects_into_prompt(self):
|
||
"""team_context 注入到 Agent 的 prompt 中"""
|
||
config = _make_expert_config()
|
||
pool = _make_mock_pool()
|
||
mock_agent = _make_mock_agent()
|
||
|
||
# 模拟有 _prompt_template 的 Agent
|
||
mock_template = MagicMock()
|
||
mock_sections = MagicMock()
|
||
mock_sections.context = "原始上下文"
|
||
mock_template._sections = mock_sections
|
||
mock_agent._prompt_template = mock_template
|
||
|
||
pool.create_agent = AsyncMock(return_value=mock_agent)
|
||
|
||
expert = await Expert.create(
|
||
config=config,
|
||
pool=pool,
|
||
team_context="你是团队中的分析专家",
|
||
)
|
||
|
||
# 验证 team_context 被注入到 context 段落
|
||
assert "你是团队中的分析专家" in mock_sections.context
|
||
assert "原始上下文" in mock_sections.context
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_create_with_team_context_no_existing_context(self):
|
||
"""team_context 注入到空 context 段落"""
|
||
config = _make_expert_config()
|
||
pool = _make_mock_pool()
|
||
mock_agent = _make_mock_agent()
|
||
|
||
mock_template = MagicMock()
|
||
mock_sections = MagicMock()
|
||
mock_sections.context = ""
|
||
mock_template._sections = mock_sections
|
||
mock_agent._prompt_template = mock_template
|
||
|
||
pool.create_agent = AsyncMock(return_value=mock_agent)
|
||
|
||
expert = await Expert.create(
|
||
config=config,
|
||
pool=pool,
|
||
team_context="你是团队中的分析专家",
|
||
)
|
||
|
||
assert mock_sections.context == "你是团队中的分析专家"
|
||
|
||
|
||
# ── Expert.send_message 测试 ──────────────────────────────
|
||
|
||
|
||
class TestExpertSendMessage:
|
||
"""Expert.send_message 消息广播测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_send_message_broadcasts_to_transport(self):
|
||
"""send_message 通过 handoff_transport 广播消息"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=transport)
|
||
|
||
await expert.send_message("team:chat", "你好团队")
|
||
|
||
transport.send.assert_awaited_once()
|
||
call_args = transport.send.call_args
|
||
assert call_args[0][0] == "team:chat"
|
||
message = call_args[0][1]
|
||
assert message["expert_id"] == "test_expert"
|
||
assert message["content"] == "你好团队"
|
||
assert message["type"] == "chat"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_send_message_no_transport(self):
|
||
"""没有 handoff_transport 时 send_message 不报错（静默忽略）"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=None)
|
||
|
||
# 不应抛出异常
|
||
await expert.send_message("team:chat", "你好")
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_send_message_long_content_stores_in_workspace(self):
|
||
"""长内容（>500 字符）存储到 SharedWorkspace，广播摘要"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
workspace = AsyncMock(spec=SharedWorkspace)
|
||
|
||
expert = Expert(
|
||
config=config, agent=agent,
|
||
handoff_transport=transport, workspace=workspace,
|
||
)
|
||
|
||
long_content = "x" * 600
|
||
summary = "长内容摘要"
|
||
|
||
await expert.send_message("team:chat", long_content, summary=summary)
|
||
|
||
# 验证 workspace.write 被调用存储完整内容
|
||
workspace.write.assert_awaited_once()
|
||
write_call = workspace.write.call_args
|
||
assert write_call[0][1] == long_content # value = 完整内容
|
||
assert write_call[0][2] == "test_expert" # agent_id
|
||
|
||
# 验证 transport.send 广播的是摘要
|
||
transport.send.assert_awaited_once()
|
||
message = transport.send.call_args[0][1]
|
||
assert message["content"] == summary
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_send_message_short_content_no_workspace(self):
|
||
"""短内容（<=500 字符）不存储到 workspace"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
workspace = AsyncMock(spec=SharedWorkspace)
|
||
|
||
expert = Expert(
|
||
config=config, agent=agent,
|
||
handoff_transport=transport, workspace=workspace,
|
||
)
|
||
|
||
await expert.send_message("team:chat", "短消息")
|
||
|
||
workspace.write.assert_not_awaited()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_send_message_long_content_without_summary(self):
|
||
"""长内容没有 summary 时，广播截断内容（前500字符），但仍存储到 workspace 防止数据丢失"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
workspace = AsyncMock(spec=SharedWorkspace)
|
||
|
||
expert = Expert(
|
||
config=config, agent=agent,
|
||
handoff_transport=transport, workspace=workspace,
|
||
)
|
||
|
||
long_content = "x" * 600
|
||
|
||
await expert.send_message("team:chat", long_content)
|
||
|
||
# 即使没有 summary，长内容也会存储到 workspace 防止数据丢失
|
||
workspace.write.assert_awaited_once()
|
||
|
||
# 广播的是截断内容
|
||
transport.send.assert_awaited_once()
|
||
message = transport.send.call_args[0][1]
|
||
assert message["content"] == long_content[:500]
|
||
|
||
|
||
# ── Expert.request_assist 测试 ────────────────────────────
|
||
|
||
|
||
class TestExpertRequestAssist:
|
||
"""Expert.request_assist 协助请求测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_request_assist_sends_handoff_message(self):
|
||
"""request_assist 通过 handoff_transport 发送协助请求"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=transport)
|
||
|
||
await expert.request_assist(
|
||
target_expert="analyst", task="分析数据", reason="需要专业分析"
|
||
)
|
||
|
||
transport.send.assert_awaited_once()
|
||
call_args = transport.send.call_args
|
||
assert call_args[0][0] == "expert:analyst:handoff"
|
||
message = call_args[0][1]
|
||
assert message["source_expert"] == "test_expert"
|
||
assert message["target_expert"] == "analyst"
|
||
assert message["task"] == "分析数据"
|
||
assert message["reason"] == "需要专业分析"
|
||
assert message["type"] == "assist_request"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_request_assist_raises_without_transport(self):
|
||
"""没有 handoff_transport 时 request_assist 抛出 RuntimeError"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=None)
|
||
|
||
with pytest.raises(RuntimeError, match="No handoff transport configured"):
|
||
await expert.request_assist("analyst", "分析数据")
|
||
|
||
|
||
# ── Expert.propose_plan_modification 测试 ─────────────────
|
||
|
||
|
||
class TestExpertProposePlanModification:
|
||
"""Expert.propose_plan_modification 计划修改提案测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_propose_plan_modification_sends_proposal(self):
|
||
"""propose_plan_modification 通过 handoff_transport 发送提案"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
transport = AsyncMock(spec=InProcessHandoffTransport)
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=transport)
|
||
|
||
modification = {"action": "add_step", "step": "验证结果"}
|
||
await expert.propose_plan_modification(plan_id="plan_1", modification=modification)
|
||
|
||
transport.send.assert_awaited_once()
|
||
call_args = transport.send.call_args
|
||
assert call_args[0][0] == "team:plan_modifications"
|
||
message = call_args[0][1]
|
||
assert message["proposing_expert"] == "test_expert"
|
||
assert message["plan_id"] == "plan_1"
|
||
assert message["modification"] == modification
|
||
assert message["type"] == "plan_modification_proposal"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_propose_plan_modification_raises_without_transport(self):
|
||
"""没有 handoff_transport 时 propose_plan_modification 抛出 RuntimeError"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent, handoff_transport=None)
|
||
|
||
with pytest.raises(RuntimeError, match="No handoff transport configured"):
|
||
await expert.propose_plan_modification("plan_1", {"action": "add"})
|
||
|
||
|
||
# ── Expert.get_capabilities_summary 测试 ──────────────────
|
||
|
||
|
||
class TestExpertGetCapabilitiesSummary:
|
||
"""Expert.get_capabilities_summary 能力摘要测试"""
|
||
|
||
def test_returns_correct_dict(self):
|
||
"""返回正确的能力摘要字典"""
|
||
config = _make_expert_config(
|
||
name="analyst",
|
||
persona="数据分析师",
|
||
thinking_style="逻辑推理",
|
||
bound_skills=["data_query", "chart_gen"],
|
||
is_lead=True,
|
||
color="#52c41a",
|
||
avatar="C",
|
||
)
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent)
|
||
|
||
summary = expert.get_capabilities_summary()
|
||
|
||
assert summary == {
|
||
"name": "analyst",
|
||
"persona": "数据分析师",
|
||
"thinking_style": "逻辑推理",
|
||
"bound_skills": ["data_query", "chart_gen"],
|
||
"is_lead": True,
|
||
"color": "#52c41a",
|
||
"avatar": "C",
|
||
}
|
||
|
||
|
||
# ── Expert.destroy 测试 ───────────────────────────────────
|
||
|
||
|
||
class TestExpertDestroy:
|
||
"""Expert.destroy 销毁测试"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_destroy_removes_agent_from_pool(self):
|
||
"""destroy 从 AgentPool 中移除 Agent"""
|
||
config = _make_expert_config(name="removable_expert")
|
||
agent = _make_mock_agent()
|
||
pool = _make_mock_pool()
|
||
|
||
expert = Expert(config=config, agent=agent)
|
||
|
||
await expert.destroy(pool)
|
||
|
||
pool.remove_agent.assert_awaited_once_with("removable_expert")
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_is_active_after_destroy(self):
|
||
"""destroy 后 is_active 为 False"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
pool = _make_mock_pool()
|
||
|
||
expert = Expert(config=config, agent=agent)
|
||
assert expert.is_active is True
|
||
|
||
await expert.destroy(pool)
|
||
|
||
assert expert.is_active is False
|
||
|
||
|
||
# ── Expert.team_id 测试 ───────────────────────────────────
|
||
|
||
|
||
class TestExpertTeamId:
|
||
"""Expert.team_id 属性测试"""
|
||
|
||
def test_team_id_defaults_to_none(self):
|
||
"""team_id 默认为 None"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent)
|
||
|
||
assert expert.team_id is None
|
||
|
||
def test_team_id_setter(self):
|
||
"""team_id setter 正确设置值"""
|
||
config = _make_expert_config()
|
||
agent = _make_mock_agent()
|
||
|
||
expert = Expert(config=config, agent=agent)
|
||
expert.team_id = "team_alpha"
|
||
|
||
assert expert.team_id == "team_alpha"
|