Simon
835 lines
33 KiB
Python
835 lines
33 KiB
Python
# =============================================================================
|
||
# 企微IT智能服务台 — 摇人多坐席协作功能 测试
|
||
# =============================================================================
|
||
# 测试覆盖：
|
||
# 一、邀请协作（POST /api/conversations/{id}/invite）
|
||
# 1. 成功邀请：collaborating_agent_ids 更新，WS广播，WS定向推送
|
||
# 2. 邀请已结单会话 → 3002
|
||
# 3. 邀请未接单会话（queued）→ 3020
|
||
# 4. 非主责/协作坐席邀请 → 3021
|
||
# 5. 邀请主责坐席本人 → 3022
|
||
# 6. 邀请已在协作中的坐席 → 3023
|
||
# 7. 邀请离线坐席 → 3024
|
||
# 8. 协作坐席也可以摇人（再摇第三人）
|
||
# 9. 邀请不存在的坐席 → 3004
|
||
# 10. 邀请不存在的会话 → 3003
|
||
#
|
||
# 二、退出协作（POST /api/conversations/{id}/leave）
|
||
# 1. 成功退出：从 collaborating_agent_ids 移除，WS 广播
|
||
# 2. 主责坐席尝试退出 → 3025
|
||
# 3. 非协作坐席退出 → 3026
|
||
# 4. 退出后清空当前选中会话
|
||
#
|
||
# 三、列表集成测试
|
||
# 1. collaborating_agent_ids 字段正确
|
||
# 2. collaborating_agent_names 姓名映射正确
|
||
# 3. is_collaborator 字段正确
|
||
# 4. 协作坐席仍能查看和回复
|
||
#
|
||
# 四、权限矩阵验证（端到端）
|
||
# 1. 协作坐席不能结单
|
||
# 2. 协作坐席不能转接
|
||
# 3. 协作坐席不占负载
|
||
# =============================================================================
|
||
|
||
import uuid
|
||
from datetime import datetime
|
||
from unittest.mock import AsyncMock, MagicMock, patch
|
||
|
||
import pytest
|
||
import pytest_asyncio
|
||
from httpx import ASGITransport, AsyncClient
|
||
from sqlalchemy import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.models.agent import Agent
|
||
from app.models.conversation import Conversation
|
||
from app.services.session_service import SessionService
|
||
from app.utils.response import AppException
|
||
from tests.conftest import create_test_conversation, create_test_agent, MockRedis
|
||
|
||
|
||
# =============================================================================
|
||
# 辅助函数
|
||
# =============================================================================
|
||
|
||
async def login_agent(client: AsyncClient, user_id: str, name: str) -> dict:
|
||
"""登录坐席并返回认证头字典。"""
|
||
response = await client.post(
|
||
"/agents/login",
|
||
json={"user_id": user_id, "name": name},
|
||
)
|
||
data = response.json()
|
||
token = data["data"]["token"]
|
||
return {"Authorization": f"Bearer {token}"}
|
||
|
||
|
||
async def create_serving_conversation(
|
||
db_session: AsyncSession,
|
||
employee_id: str = "emp_001",
|
||
agent_user_id: str = "agent_owner",
|
||
collab_ids: list = None,
|
||
) -> Conversation:
|
||
"""创建一个 serving 状态且有主责坐席的会话（可选已有协作坐席）。"""
|
||
conv = create_test_conversation(
|
||
employee_id=employee_id,
|
||
status="serving",
|
||
)
|
||
conv.assigned_agent_id = agent_user_id
|
||
conv.collaborating_agent_ids = collab_ids or []
|
||
db_session.add(conv)
|
||
await db_session.flush()
|
||
return conv
|
||
|
||
|
||
# =============================================================================
|
||
# 一、邀请协作测试
|
||
# =============================================================================
|
||
|
||
class TestInviteCollaborator:
|
||
"""测试邀请协作接口 POST /api/conversations/{id}/invite。"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_success_updates_collaborating_ids(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证成功邀请：collaborating_agent_ids 更新，WS广播+定向推送。
|
||
|
||
场景：坐席A（owner）在处理会话，邀请在线坐席B加入协作。
|
||
"""
|
||
# 创建坐席
|
||
owner = create_test_agent(user_id="owner_001", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_001", name="坐席B", status="online")
|
||
db_session.add_all([owner, invitee])
|
||
await db_session.flush()
|
||
|
||
# 创建 serving 会话，分配给 owner
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_invite", agent_user_id="owner_001"
|
||
)
|
||
|
||
# 坐席A 登录并发起邀请
|
||
headers = await login_agent(client, "owner_001", "坐席A")
|
||
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock) as mock_broadcast, \
|
||
patch("app.services.ws_manager.manager.send_to_agent", new_callable=AsyncMock) as mock_send:
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "invitee_001"},
|
||
headers=headers,
|
||
)
|
||
|
||
assert response.status_code == 200
|
||
data = response.json()
|
||
assert data["code"] == 0
|
||
|
||
# 验证 collaborating_agent_ids 包含被邀请坐席
|
||
result = data["data"]
|
||
assert "invitee_001" in result["collaborating_agent_ids"]
|
||
|
||
# 验证 WS 广播被调用（collaborator_joined）
|
||
mock_broadcast.assert_called_once()
|
||
broadcast_msg = mock_broadcast.call_args[0][0]
|
||
assert broadcast_msg["type"] == "collaborator_joined"
|
||
assert broadcast_msg["data"]["agent_id"] == "invitee_001"
|
||
assert broadcast_msg["data"]["inviter_agent_id"] == "owner_001"
|
||
|
||
# 验证 WS 定向推送被调用（collaborator_invited）
|
||
mock_send.assert_called_once_with("invitee_001", mock_send.call_args[0][1])
|
||
sent_msg = mock_send.call_args[0][1]
|
||
assert sent_msg["type"] == "collaborator_invited"
|
||
assert sent_msg["data"]["invitee_agent_id"] == "invitee_001"
|
||
|
||
# 验证数据库持久化
|
||
stmt = select(Conversation).where(Conversation.id == conv.id)
|
||
result_db = await db_session.execute(stmt)
|
||
db_conv = result_db.scalars().first()
|
||
assert "invitee_001" in db_conv.collaborating_agent_ids
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_resolved_conversation_error_3002(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不能邀请已结单会话 → 3002。"""
|
||
owner = create_test_agent(user_id="owner_resolved", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_resolved", name="坐席B", status="online")
|
||
db_session.add_all([owner, invitee])
|
||
await db_session.flush()
|
||
|
||
conv = create_test_conversation(
|
||
employee_id="emp_resolved_invite", status="resolved"
|
||
)
|
||
conv.assigned_agent_id = "owner_resolved"
|
||
db_session.add(conv)
|
||
await db_session.flush()
|
||
|
||
headers = await login_agent(client, "owner_resolved", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "invitee_resolved"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3002 # ERR_CONVERSATION_RESOLVED
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_queued_conversation_error_3020(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不能邀请未接单（queued）的会话 → 3020。"""
|
||
owner = create_test_agent(user_id="owner_queued", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_queued", name="坐席B", status="online")
|
||
db_session.add_all([owner, invitee])
|
||
await db_session.flush()
|
||
|
||
# queued 状态，未分配坐席 → 应先报 3021（不是 owner/collaborator）
|
||
# 但如果有 assigned_agent_id=owner，则是 queued 状态 → 3020
|
||
conv = create_test_conversation(
|
||
employee_id="emp_queued_invite", status="queued"
|
||
)
|
||
conv.assigned_agent_id = "owner_queued"
|
||
db_session.add(conv)
|
||
await db_session.flush()
|
||
|
||
headers = await login_agent(client, "owner_queued", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "invitee_queued"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3020
|
||
assert "服务中" in data["message"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_by_non_owner_error_3021(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证非主责/协作坐席不能摇人 → 3021。"""
|
||
owner = create_test_agent(user_id="owner_3021", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_3021", name="坐席B", status="online")
|
||
stranger = create_test_agent(user_id="stranger_3021", name="路过的坐席", status="online")
|
||
db_session.add_all([owner, invitee, stranger])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_3021", agent_user_id="owner_3021"
|
||
)
|
||
|
||
# 用路过的坐席登录（既不是主责也不是协作坐席）
|
||
headers = await login_agent(client, "stranger_3021", "路过的坐席")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "invitee_3021"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3021
|
||
assert "摇人" in data["message"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_owner_self_error_3022(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不能邀请主责坐席本人 → 3022。"""
|
||
owner = create_test_agent(user_id="owner_3022", name="坐席A", status="online")
|
||
db_session.add(owner)
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_3022", agent_user_id="owner_3022"
|
||
)
|
||
|
||
headers = await login_agent(client, "owner_3022", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "owner_3022"}, # 邀请自己
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3022
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_duplicate_collaborator_error_3023(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不能重复邀请已在协作中的坐席 → 3023。"""
|
||
owner = create_test_agent(user_id="owner_3023", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_3023", name="坐席B", status="online")
|
||
db_session.add_all([owner, invitee])
|
||
await db_session.flush()
|
||
|
||
# 坐席B 已在协作列表中
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_3023",
|
||
agent_user_id="owner_3023",
|
||
collab_ids=["invitee_3023"],
|
||
)
|
||
|
||
headers = await login_agent(client, "owner_3023", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "invitee_3023"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3023
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_offline_agent_error_3024(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不能邀请离线坐席 → 3024。"""
|
||
owner = create_test_agent(user_id="owner_3024", name="坐席A", status="online")
|
||
offline_agent = create_test_agent(user_id="offline_3024", name="离线坐席", status="offline")
|
||
db_session.add_all([owner, offline_agent])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_3024", agent_user_id="owner_3024"
|
||
)
|
||
|
||
headers = await login_agent(client, "owner_3024", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "offline_3024"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3024
|
||
assert "不在线" in data["message"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_nonexistent_agent_error_3004(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证邀请不存在的坐席 → 3004。"""
|
||
owner = create_test_agent(user_id="owner_3004", name="坐席A", status="online")
|
||
db_session.add(owner)
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_3004", agent_user_id="owner_3004"
|
||
)
|
||
|
||
headers = await login_agent(client, "owner_3004", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "nonexistent_agent"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3004 # ERR_AGENT_NOT_FOUND
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_nonexistent_conversation_error_3003(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证邀请不存在的会话 → 3003。"""
|
||
agent = create_test_agent(user_id="agent_3003", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="invitee_3003", name="坐席B", status="online")
|
||
db_session.add_all([agent, invitee])
|
||
await db_session.flush()
|
||
|
||
fake_id = str(uuid.uuid4())
|
||
headers = await login_agent(client, "agent_3003", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{fake_id}/invite",
|
||
json={"agent_id": "invitee_3003"},
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3003 # ERR_CONVERSATION_NOT_FOUND
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_collaborator_can_also_invite_others(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证协作坐席也可以摇人（再摇第三人加入）。
|
||
|
||
场景：坐席A（owner）邀请坐席B → 坐席B 再摇坐席C
|
||
"""
|
||
owner = create_test_agent(user_id="chain_owner", name="坐席A", status="online")
|
||
collab1 = create_test_agent(user_id="chain_collab1", name="坐席B", status="online")
|
||
collab2 = create_test_agent(user_id="chain_collab2", name="坐席C", status="online")
|
||
db_session.add_all([owner, collab1, collab2])
|
||
await db_session.flush()
|
||
|
||
# 坐席A 创建会话，邀请坐席B
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_chain",
|
||
agent_user_id="chain_owner",
|
||
collab_ids=["chain_collab1"],
|
||
)
|
||
|
||
# 坐席B 登录并发起邀请坐席C
|
||
headers = await login_agent(client, "chain_collab1", "坐席B")
|
||
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock), \
|
||
patch("app.services.ws_manager.manager.send_to_agent", new_callable=AsyncMock):
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "chain_collab2"},
|
||
headers=headers,
|
||
)
|
||
|
||
assert response.status_code == 200
|
||
data = response.json()
|
||
assert data["code"] == 0
|
||
|
||
# 验证 collaborating_agent_ids 包含两个协作坐席
|
||
result = data["data"]
|
||
assert "chain_collab1" in result["collaborating_agent_ids"]
|
||
assert "chain_collab2" in result["collaborating_agent_ids"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_invite_without_auth_returns_unauthorized(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证未登录时邀请返回未授权错误。"""
|
||
owner = create_test_agent(user_id="noauth_owner", name="坐席A", status="online")
|
||
invitee = create_test_agent(user_id="noauth_invitee", name="坐席B", status="online")
|
||
db_session.add_all([owner, invitee])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_noauth", agent_user_id="noauth_owner"
|
||
)
|
||
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "noauth_invitee"},
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 1002 # ERR_UNAUTHORIZED
|
||
|
||
|
||
# =============================================================================
|
||
# 二、退出协作测试
|
||
# =============================================================================
|
||
|
||
class TestLeaveCollaboration:
|
||
"""测试退出协作接口 POST /api/conversations/{id}/leave。"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_leave_success_removes_from_list(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证成功退出：从 collaborating_agent_ids 移除，WS 广播。"""
|
||
owner = create_test_agent(user_id="leave_owner", name="坐席A", status="online")
|
||
collab = create_test_agent(user_id="leave_collab", name="坐席B", status="online")
|
||
db_session.add_all([owner, collab])
|
||
await db_session.flush()
|
||
|
||
# 坐席B 已在协作列表中
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_leave",
|
||
agent_user_id="leave_owner",
|
||
collab_ids=["leave_collab"],
|
||
)
|
||
|
||
headers = await login_agent(client, "leave_collab", "坐席B")
|
||
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock) as mock_broadcast:
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/leave",
|
||
headers=headers,
|
||
)
|
||
|
||
assert response.status_code == 200
|
||
data = response.json()
|
||
assert data["code"] == 0
|
||
|
||
# 验证 collaborating_agent_ids 不再包含坐席B
|
||
result = data["data"]
|
||
assert "leave_collab" not in result["collaborating_agent_ids"]
|
||
|
||
# 验证 WS 广播被调用（collaborator_left）
|
||
mock_broadcast.assert_called_once()
|
||
broadcast_msg = mock_broadcast.call_args[0][0]
|
||
assert broadcast_msg["type"] == "collaborator_left"
|
||
assert broadcast_msg["data"]["agent_id"] == "leave_collab"
|
||
|
||
# 验证数据库持久化
|
||
stmt = select(Conversation).where(Conversation.id == conv.id)
|
||
result_db = await db_session.execute(stmt)
|
||
db_conv = result_db.scalars().first()
|
||
assert "leave_collab" not in db_conv.collaborating_agent_ids
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_leave_owner_error_3025(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证主责坐席不能退出协作 → 3025。"""
|
||
owner = create_test_agent(user_id="leave_owner_3025", name="坐席A", status="online")
|
||
db_session.add(owner)
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_leave_owner",
|
||
agent_user_id="leave_owner_3025",
|
||
collab_ids=["some_collab"],
|
||
)
|
||
|
||
headers = await login_agent(client, "leave_owner_3025", "坐席A")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/leave",
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3025
|
||
assert "主责坐席" in data["message"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_leave_non_collaborator_error_3026(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证不在协作列表中的坐席不能退出 → 3026。"""
|
||
owner = create_test_agent(user_id="leave_owner_3026", name="坐席A", status="online")
|
||
stranger = create_test_agent(user_id="stranger_3026", name="路过的坐席", status="online")
|
||
db_session.add_all([owner, stranger])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_leave_stranger",
|
||
agent_user_id="leave_owner_3026",
|
||
)
|
||
|
||
headers = await login_agent(client, "stranger_3026", "路过的坐席")
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/leave",
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 3026
|
||
assert "协作列表" in data["message"]
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_leave_without_auth_returns_unauthorized(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证未登录时退出返回未授权错误。"""
|
||
owner = create_test_agent(user_id="noauth_leave_owner", name="坐席A", status="online")
|
||
collab = create_test_agent(user_id="noauth_leave_collab", name="坐席B", status="online")
|
||
db_session.add_all([owner, collab])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_noauth_leave",
|
||
agent_user_id="noauth_leave_owner",
|
||
collab_ids=["noauth_leave_collab"],
|
||
)
|
||
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/leave",
|
||
)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 1002 # ERR_UNAUTHORIZED
|
||
|
||
|
||
# =============================================================================
|
||
# 三、列表集成测试
|
||
# =============================================================================
|
||
|
||
class TestCollaborationListIntegration:
|
||
"""测试会话列表接口的协作字段集成。"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_list_includes_collaboration_fields(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证列表接口返回 collaborating_agent_ids 和 _names 字段。"""
|
||
owner = create_test_agent(user_id="list_owner", name="坐席A", status="online")
|
||
collab1 = create_test_agent(user_id="list_collab1", name="坐席B", status="online")
|
||
collab2 = create_test_agent(user_id="list_collab2", name="坐席C", status="online")
|
||
db_session.add_all([owner, collab1, collab2])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_list_collab",
|
||
agent_user_id="list_owner",
|
||
collab_ids=["list_collab1", "list_collab2"],
|
||
)
|
||
|
||
# 以坐席A身份查看列表
|
||
headers = await login_agent(client, "list_owner", "坐席A")
|
||
response = await client.get("/conversations", headers=headers)
|
||
|
||
data = response.json()
|
||
assert data["code"] == 0
|
||
items = data["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
|
||
conv_item = item_map[str(conv.id)]
|
||
|
||
# 验证 collaborating_agent_ids
|
||
assert "list_collab1" in conv_item["collaborating_agent_ids"]
|
||
assert "list_collab2" in conv_item["collaborating_agent_ids"]
|
||
assert len(conv_item["collaborating_agent_ids"]) == 2
|
||
|
||
# 验证 collaborating_agent_names
|
||
assert conv_item["collaborating_agent_names"]["list_collab1"] == "坐席B"
|
||
assert conv_item["collaborating_agent_names"]["list_collab2"] == "坐席C"
|
||
|
||
# 验证 is_collaborator（坐席A是主责不是协作坐席）
|
||
assert conv_item["is_collaborator"] is False
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_list_is_collaborator_field_correctness(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证 is_collaborator 字段标注正确。
|
||
|
||
- 主责坐席 → is_collaborator=False
|
||
- 协作坐席（且非主责）→ is_collaborator=True
|
||
- 既非主责也非协作 → is_collaborator=False
|
||
"""
|
||
owner = create_test_agent(user_id="iscoll_owner", name="主责坐席", status="online")
|
||
collab = create_test_agent(user_id="iscoll_collab", name="协作坐席", status="online")
|
||
stranger = create_test_agent(user_id="iscoll_stranger", name="路人坐席", status="online")
|
||
db_session.add_all([owner, collab, stranger])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_iscoll",
|
||
agent_user_id="iscoll_owner",
|
||
collab_ids=["iscoll_collab"],
|
||
)
|
||
|
||
# 主责坐席查看 → is_collaborator=False
|
||
headers_owner = await login_agent(client, "iscoll_owner", "主责坐席")
|
||
resp = await client.get("/conversations", headers=headers_owner)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
assert item_map[str(conv.id)]["is_collaborator"] is False
|
||
|
||
# 协作坐席查看 → is_collaborator=True
|
||
headers_collab = await login_agent(client, "iscoll_collab", "协作坐席")
|
||
resp = await client.get("/conversations", headers=headers_collab)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
assert item_map[str(conv.id)]["is_collaborator"] is True
|
||
|
||
# 路人坐席查看 → is_collaborator=False
|
||
headers_stranger = await login_agent(client, "iscoll_stranger", "路人坐席")
|
||
resp = await client.get("/conversations", headers=headers_stranger)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
assert item_map[str(conv.id)]["is_collaborator"] is False
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_list_no_collaborators_returns_empty_arrays(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证无协作坐席时返回空数组和空对象。"""
|
||
owner = create_test_agent(user_id="empty_owner", name="坐席A", status="online")
|
||
db_session.add(owner)
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_empty_collab", agent_user_id="empty_owner"
|
||
)
|
||
|
||
headers = await login_agent(client, "empty_owner", "坐席A")
|
||
response = await client.get("/conversations", headers=headers)
|
||
|
||
data = response.json()
|
||
items = data["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
|
||
conv_item = item_map[str(conv.id)]
|
||
assert conv_item["collaborating_agent_ids"] == []
|
||
assert conv_item["collaborating_agent_names"] == {}
|
||
assert conv_item["is_collaborator"] is False
|
||
|
||
|
||
# =============================================================================
|
||
# 四、权限矩阵验证（端到端）
|
||
# =============================================================================
|
||
|
||
class TestCollaborationPermissions:
|
||
"""测试协作坐席的权限边界。
|
||
|
||
协作坐席可以：查看会话、发送回复、摇人（再邀请）
|
||
协作坐席不能：结单、转接、置顶/代办
|
||
协作坐席不占负载。
|
||
"""
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_collaborator_does_not_count_load(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证协作坐席加入后负载不变（不占负载）。
|
||
|
||
主责坐席 current_load 应保持为1，协作坐席 current_load 保持不变。
|
||
"""
|
||
owner = create_test_agent(user_id="load_owner", name="坐席A", status="online")
|
||
owner.current_load = 1
|
||
|
||
collab = create_test_agent(user_id="load_collab", name="坐席B", status="online")
|
||
collab.current_load = 0
|
||
|
||
db_session.add_all([owner, collab])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_load", agent_user_id="load_owner"
|
||
)
|
||
|
||
headers = await login_agent(client, "load_owner", "坐席A")
|
||
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock), \
|
||
patch("app.services.ws_manager.manager.send_to_agent", new_callable=AsyncMock):
|
||
await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "load_collab"},
|
||
headers=headers,
|
||
)
|
||
|
||
# 验证主责坐席 load 不变（=1）
|
||
stmt = select(Agent).where(Agent.user_id == "load_owner")
|
||
result = await db_session.execute(stmt)
|
||
db_owner = result.scalars().first()
|
||
assert db_owner.current_load == 1
|
||
|
||
# 验证协作坐席 load 不变（=0）
|
||
stmt = select(Agent).where(Agent.user_id == "load_collab")
|
||
result = await db_session.execute(stmt)
|
||
db_collab = result.scalars().first()
|
||
assert db_collab.current_load == 0 # 协作不占负载
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_collaborator_cannot_resolve_conversation(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""验证协作坐席不能结单。
|
||
|
||
场景：坐席A（owner）邀请坐席B协作 → 坐席B 尝试结单（应失败）
|
||
"""
|
||
owner = create_test_agent(user_id="perm_owner", name="坐席A", status="online")
|
||
collab = create_test_agent(user_id="perm_collab", name="坐席B", status="online")
|
||
db_session.add_all([owner, collab])
|
||
await db_session.flush()
|
||
|
||
conv = await create_serving_conversation(
|
||
db_session,
|
||
employee_id="emp_perm",
|
||
agent_user_id="perm_owner",
|
||
collab_ids=["perm_collab"],
|
||
)
|
||
|
||
# 协作坐席登录并尝试结单
|
||
headers = await login_agent(client, "perm_collab", "坐席B")
|
||
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock):
|
||
response = await client.post(
|
||
f"/conversations/{conv.id}/resolve",
|
||
headers=headers,
|
||
)
|
||
|
||
data = response.json()
|
||
# 协作坐席不是主责坐席，resolve 应返回 3027（只有主责坐席才能结单）
|
||
assert data["code"] == 3027, f"协作坐席不应该能结单，期望 code=3027，实际 code={data['code']}"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_full_invite_leave_cycle(
|
||
self, client, db_session, mock_redis
|
||
):
|
||
"""端到端测试：邀请→查看列表→退出→验证清理。
|
||
|
||
完整流程：
|
||
1. 坐席A 邀请坐席B
|
||
2. 坐席B 查看列表，确认协作会话出现
|
||
3. 坐席A 邀请坐席C
|
||
4. 坐席A 查看列表，验证两个协作坐席
|
||
5. 坐席B 退出协作
|
||
6. 验证坐席B 不再出现在协作列表中，坐席C 仍存在
|
||
"""
|
||
# 创建坐席
|
||
owner = create_test_agent(user_id="e2e_owner", name="坐席A", status="online")
|
||
collab_b = create_test_agent(user_id="e2e_b", name="坐席B", status="online")
|
||
collab_c = create_test_agent(user_id="e2e_c", name="坐席C", status="online")
|
||
db_session.add_all([owner, collab_b, collab_c])
|
||
await db_session.flush()
|
||
|
||
# 创建会话
|
||
conv = await create_serving_conversation(
|
||
db_session, employee_id="emp_e2e", agent_user_id="e2e_owner"
|
||
)
|
||
|
||
headers_a = await login_agent(client, "e2e_owner", "坐席A")
|
||
|
||
# Step 1: 坐席A 邀请坐席B
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock), \
|
||
patch("app.services.ws_manager.manager.send_to_agent", new_callable=AsyncMock):
|
||
resp = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "e2e_b"},
|
||
headers=headers_a,
|
||
)
|
||
assert resp.json()["code"] == 0
|
||
|
||
# Step 2: 坐席B 查看列表，确认协作会话出现
|
||
headers_b = await login_agent(client, "e2e_b", "坐席B")
|
||
resp = await client.get("/conversations", headers=headers_b)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
assert str(conv.id) in item_map
|
||
assert item_map[str(conv.id)]["is_collaborator"] is True
|
||
|
||
# Step 3: 坐席A 邀请坐席C
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock), \
|
||
patch("app.services.ws_manager.manager.send_to_agent", new_callable=AsyncMock):
|
||
resp = await client.post(
|
||
f"/conversations/{conv.id}/invite",
|
||
json={"agent_id": "e2e_c"},
|
||
headers=headers_a,
|
||
)
|
||
assert resp.json()["code"] == 0
|
||
|
||
# Step 4: 坐席A 查看列表，验证两个协作坐席
|
||
resp = await client.get("/conversations", headers=headers_a)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
conv_item = item_map[str(conv.id)]
|
||
assert "e2e_b" in conv_item["collaborating_agent_ids"]
|
||
assert "e2e_c" in conv_item["collaborating_agent_ids"]
|
||
assert conv_item["collaborating_agent_names"]["e2e_b"] == "坐席B"
|
||
assert conv_item["collaborating_agent_names"]["e2e_c"] == "坐席C"
|
||
|
||
# Step 5: 坐席B 退出协作
|
||
with patch("app.services.ws_manager.manager.broadcast", new_callable=AsyncMock):
|
||
resp = await client.post(
|
||
f"/conversations/{conv.id}/leave",
|
||
headers=headers_b,
|
||
)
|
||
assert resp.json()["code"] == 0
|
||
|
||
# Step 6: 验证坐席B 已移除，坐席C 仍存在
|
||
resp = await client.get("/conversations", headers=headers_a)
|
||
items = resp.json()["data"]["items"]
|
||
item_map = {item["id"]: item for item in items}
|
||
conv_item = item_map[str(conv.id)]
|
||
assert "e2e_b" not in conv_item["collaborating_agent_ids"]
|
||
assert "e2e_c" in conv_item["collaborating_agent_ids"]
|