feat(avatar): add BOXIM chat takeover
This commit is contained in:
stefanfeng
@@ -1,322 +1,196 @@
|
||||
"""Tests for the TakeoverService — message listening, decision, reply execution."""
|
||||
"""End-to-end service tests for BOXIM takeover timing and human priority."""
|
||||
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from unittest.mock import AsyncMock, patch, MagicMock
|
||||
from services.takeover_service import TakeoverService
|
||||
from models import Authorization, Avatar
|
||||
from sqlalchemy import create_engine
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
from sqlalchemy.pool import StaticPool
|
||||
|
||||
from database import Base
|
||||
from models import Avatar, TakeoverCursor, TakeoverMessage, TakeoverReplyTask, User
|
||||
from services.takeover_service import TakeoverService, _plain_text_reply
|
||||
|
||||
|
||||
class Clock:
|
||||
def __init__(self):
|
||||
self.value = datetime(2026, 8, 19, 10, 0, 0)
|
||||
|
||||
def now(self):
|
||||
return self.value
|
||||
|
||||
def advance(self, seconds: int):
|
||||
self.value += timedelta(seconds=seconds)
|
||||
|
||||
def millis(self):
|
||||
return int(self.value.replace(tzinfo=timezone.utc).timestamp() * 1000)
|
||||
|
||||
|
||||
class FakeBoxIM:
|
||||
def __init__(self):
|
||||
self.messages = []
|
||||
self.sent = []
|
||||
|
||||
async def exchange_access_token(self, huihui_token):
|
||||
assert huihui_token == "prod-huihui-token"
|
||||
return {"accessToken": "box-token", "accessTokenExpiresIn": 3600}
|
||||
|
||||
async def get_self(self, access_token):
|
||||
assert access_token == "box-token"
|
||||
return {"id": 100}
|
||||
|
||||
async def fetch_private_messages(self, access_token, min_id="0"):
|
||||
assert access_token == "box-token"
|
||||
return [item.copy() for item in self.messages if int(item["id"]) > int(min_id)]
|
||||
|
||||
async def send_private_message(self, access_token, peer_id, content, *, local_id=None):
|
||||
self.sent.append({"peerId": str(peer_id), "content": content, "localId": str(local_id)})
|
||||
return {"id": 900 + len(self.sent), "localId": int(local_id)}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_db():
|
||||
db = MagicMock()
|
||||
return db
|
||||
def service_context():
|
||||
engine = create_engine(
|
||||
"sqlite://",
|
||||
connect_args={"check_same_thread": False},
|
||||
poolclass=StaticPool,
|
||||
)
|
||||
session_factory = sessionmaker(bind=engine, autoflush=False, expire_on_commit=False)
|
||||
Base.metadata.create_all(engine)
|
||||
db = session_factory()
|
||||
user = User(
|
||||
id="owner-local",
|
||||
huihui_user_id="owner-huihui",
|
||||
huihui_token="prod-huihui-token",
|
||||
app_token="app-token",
|
||||
)
|
||||
avatar = Avatar(
|
||||
id="avatar-1",
|
||||
owner_id=user.huihui_user_id,
|
||||
name="分身",
|
||||
status="active",
|
||||
config={"authorizationPermissions": ["chat", "takeover"]},
|
||||
)
|
||||
db.add_all([user, avatar])
|
||||
db.commit()
|
||||
db.close()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_boxim():
|
||||
client = AsyncMock()
|
||||
client.get_credentials.return_value = {"accid": "owner_acc", "token": "tok"}
|
||||
client.send_p2p_message.return_value = True
|
||||
return client
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_auth():
|
||||
auth = MagicMock(spec=Authorization)
|
||||
auth.takeover_enabled = True
|
||||
auth.takeover_mode = "immediate"
|
||||
auth.takeover_delay_seconds = 30
|
||||
auth.avatar_id = "avatar_123"
|
||||
auth.target_id = "target_user_123"
|
||||
auth.target_type = "user"
|
||||
auth.status = "active"
|
||||
auth.permissions = ["chat", "takeover"]
|
||||
return auth
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_avatar():
|
||||
avatar = MagicMock(spec=Avatar)
|
||||
avatar.id = "avatar_123"
|
||||
avatar.owner_id = "owner_huihui_123"
|
||||
return avatar
|
||||
|
||||
|
||||
# --- check_takeover_enabled ---
|
||||
|
||||
|
||||
def test_check_takeover_enabled_returns_auth_when_enabled(mock_db, mock_auth, mock_boxim, mock_avatar):
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
|
||||
auth_filter = MagicMock()
|
||||
auth_filter.filter.return_value = auth_filter
|
||||
auth_filter.first.return_value = mock_auth
|
||||
|
||||
def query_side_effect(model):
|
||||
if model == Avatar:
|
||||
return avatar_query
|
||||
return auth_filter
|
||||
|
||||
mock_db.query.side_effect = query_side_effect
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = service.check_takeover_enabled("owner_huihui_123", "target_user_123")
|
||||
assert result == mock_auth
|
||||
|
||||
|
||||
def test_check_takeover_enabled_returns_none_when_no_avatar(mock_db, mock_boxim):
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = None
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = service.check_takeover_enabled("owner_123", "target_123")
|
||||
assert result is None
|
||||
|
||||
|
||||
def test_check_takeover_enabled_returns_none_when_disabled(mock_db, mock_boxim, mock_avatar):
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
|
||||
disabled_auth = MagicMock(spec=Authorization)
|
||||
disabled_auth.takeover_enabled = False
|
||||
disabled_auth.permissions = []
|
||||
auth_filter = MagicMock()
|
||||
auth_filter.filter.return_value = auth_filter
|
||||
auth_filter.first.return_value = disabled_auth
|
||||
|
||||
def query_side_effect(model):
|
||||
if model == Avatar:
|
||||
return avatar_query
|
||||
return auth_filter
|
||||
|
||||
mock_db.query.side_effect = query_side_effect
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = service.check_takeover_enabled("owner_123", "target_123")
|
||||
assert result is None
|
||||
|
||||
|
||||
def test_check_takeover_enabled_filters_by_owner_and_target(mock_db, mock_boxim, mock_avatar, mock_auth):
|
||||
"""Verify that queries use the correct filter arguments."""
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
|
||||
auth_filter = MagicMock()
|
||||
auth_filter.filter.return_value = auth_filter
|
||||
auth_filter.first.return_value = mock_auth
|
||||
|
||||
call_order = []
|
||||
|
||||
def query_side_effect(model):
|
||||
if model == Avatar:
|
||||
call_order.append("Avatar")
|
||||
return avatar_query
|
||||
call_order.append("Authorization")
|
||||
return auth_filter
|
||||
|
||||
mock_db.query.side_effect = query_side_effect
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
service.check_takeover_enabled("owner_huihui_123", "target_user_123")
|
||||
|
||||
assert "Avatar" in call_order
|
||||
assert "Authorization" in call_order
|
||||
|
||||
|
||||
# --- generate_reply ---
|
||||
clock = Clock()
|
||||
boxim = FakeBoxIM()
|
||||
service = TakeoverService(session_factory, boxim, now=clock.now)
|
||||
return session_factory, service, boxim, clock
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_generate_reply_returns_answer(mock_boxim):
|
||||
mock_db = MagicMock()
|
||||
with patch("services.takeover_service.httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"code": 200, "data": {"answer": "Hello back"}}
|
||||
mock_client_class.return_value.__aenter__.return_value.post.return_value = mock_response
|
||||
async def test_first_sync_primes_cursor_without_replying_to_history(service_context):
|
||||
session_factory, service, boxim, clock = service_context
|
||||
boxim.messages = [
|
||||
{"id": 10, "localId": 1, "sendId": 200, "recvId": 100, "sendTime": clock.millis(), "type": 0, "content": "旧消息"}
|
||||
]
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = await service.generate_reply("avatar_123", "Hello")
|
||||
assert result == "Hello back"
|
||||
with patch("routers.chat._resolve_reply", return_value={"answer": "不应发送"}):
|
||||
await service.poll_and_process_messages()
|
||||
|
||||
db = session_factory()
|
||||
try:
|
||||
cursor = db.query(TakeoverCursor).one()
|
||||
assert cursor.initialized is True
|
||||
assert cursor.last_message_id == "10"
|
||||
assert db.query(TakeoverMessage).count() == 1
|
||||
assert db.query(TakeoverReplyTask).count() == 0
|
||||
assert boxim.sent == []
|
||||
finally:
|
||||
db.close()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_generate_reply_handles_empty_answer(mock_boxim):
|
||||
"""generate_reply should return empty string when answer is missing."""
|
||||
mock_db = MagicMock()
|
||||
with patch("services.takeover_service.httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"code": 200, "data": {}}
|
||||
mock_client_class.return_value.__aenter__.return_value.post.return_value = mock_response
|
||||
async def test_incoming_message_is_prepared_then_sent_at_three_seconds(service_context):
|
||||
session_factory, service, boxim, clock = service_context
|
||||
await service.poll_and_process_messages()
|
||||
boxim.messages.append(
|
||||
{"id": 11, "localId": 2, "sendId": 200, "recvId": 100, "sendTime": clock.millis(), "type": 0, "content": "你好"}
|
||||
)
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = await service.generate_reply("avatar_123", "Hello")
|
||||
assert result == ""
|
||||
with patch("routers.chat._resolve_reply", return_value={"answer": "**你好**\n\n很高兴见到你"}):
|
||||
await service.poll_and_process_messages()
|
||||
assert boxim.sent == []
|
||||
|
||||
clock.advance(2)
|
||||
await service.poll_and_process_messages()
|
||||
assert boxim.sent == []
|
||||
|
||||
clock.advance(1)
|
||||
await service.poll_and_process_messages()
|
||||
assert boxim.sent == [{"peerId": "200", "content": "你好\n很高兴见到你", "localId": boxim.sent[0]["localId"]}]
|
||||
|
||||
db = session_factory()
|
||||
try:
|
||||
task = db.query(TakeoverReplyTask).one()
|
||||
assert task.status == "sent"
|
||||
assert task.sent_at == clock.now()
|
||||
finally:
|
||||
db.close()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_generate_reply_handles_error_code(mock_boxim):
|
||||
"""generate_reply should return empty string when API returns error code."""
|
||||
mock_db = MagicMock()
|
||||
with patch("services.takeover_service.httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"code": 500, "message": "Internal error"}
|
||||
mock_client_class.return_value.__aenter__.return_value.post.return_value = mock_response
|
||||
async def test_owner_message_cancels_pending_reply(service_context):
|
||||
session_factory, service, boxim, clock = service_context
|
||||
await service.poll_and_process_messages()
|
||||
boxim.messages.append(
|
||||
{"id": 21, "localId": 3, "sendId": 200, "recvId": 100, "sendTime": clock.millis(), "type": 0, "content": "在吗"}
|
||||
)
|
||||
with patch("routers.chat._resolve_reply", return_value={"answer": "在的"}):
|
||||
await service.poll_and_process_messages()
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
result = await service.generate_reply("avatar_123", "Hello")
|
||||
assert result == ""
|
||||
clock.advance(2)
|
||||
boxim.messages.append(
|
||||
{"id": 22, "localId": 4, "sendId": 100, "recvId": 200, "sendTime": clock.millis(), "type": 0, "content": "我来回复"}
|
||||
)
|
||||
await service.poll_and_process_messages()
|
||||
clock.advance(2)
|
||||
await service.poll_and_process_messages()
|
||||
|
||||
|
||||
# --- execute_takeover ---
|
||||
db = session_factory()
|
||||
try:
|
||||
task = db.query(TakeoverReplyTask).filter(TakeoverReplyTask.trigger_message_id == "21").one()
|
||||
assert task.status == "cancelled"
|
||||
assert task.cancel_reason == "owner_replied"
|
||||
assert boxim.sent == []
|
||||
finally:
|
||||
db.close()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_execute_takeover_success(mock_db, mock_boxim, mock_auth, mock_avatar):
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
async def test_quick_successive_messages_are_coalesced_into_one_reply(service_context):
|
||||
session_factory, service, boxim, clock = service_context
|
||||
await service.poll_and_process_messages()
|
||||
boxim.messages.append(
|
||||
{"id": 31, "localId": 5, "sendId": 200, "recvId": 100, "sendTime": clock.millis(), "type": 0, "content": "第一句"}
|
||||
)
|
||||
with patch("routers.chat._resolve_reply", return_value={"answer": "第一版"}):
|
||||
await service.poll_and_process_messages()
|
||||
|
||||
with patch("services.takeover_service.httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"code": 200, "data": {"answer": "Hello back"}}
|
||||
mock_client_class.return_value.__aenter__.return_value.post.return_value = mock_response
|
||||
clock.advance(1)
|
||||
boxim.messages.append(
|
||||
{"id": 32, "localId": 6, "sendId": 200, "recvId": 100, "sendTime": clock.millis(), "type": 0, "content": "第二句"}
|
||||
)
|
||||
with patch("routers.chat._resolve_reply", return_value={"answer": "合并回复"}) as resolver:
|
||||
await service.poll_and_process_messages()
|
||||
assert resolver.call_args.args[2] == "第一句\n第二句"
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
message = {"from_accid": "user_acc", "content": "Hello"}
|
||||
clock.advance(3)
|
||||
await service.poll_and_process_messages()
|
||||
assert [item["content"] for item in boxim.sent] == ["合并回复"]
|
||||
|
||||
result = await service.execute_takeover(mock_auth, message)
|
||||
|
||||
assert result is True
|
||||
mock_boxim.get_credentials.assert_called_once_with("owner_huihui_123")
|
||||
mock_boxim.send_p2p_message.assert_called_once()
|
||||
db = session_factory()
|
||||
try:
|
||||
tasks = db.query(TakeoverReplyTask).order_by(TakeoverReplyTask.created_at).all()
|
||||
assert [task.status for task in tasks] == ["cancelled", "sent"]
|
||||
assert tasks[0].cancel_reason == "newer_incoming_message"
|
||||
finally:
|
||||
db.close()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_execute_takeover_fails_when_avatar_not_found(mock_db, mock_boxim, mock_auth):
|
||||
"""execute_takeover should return False when Avatar is not found."""
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = None
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
message = {"from_accid": "user_acc", "content": "Hello"}
|
||||
|
||||
result = await service.execute_takeover(mock_auth, message)
|
||||
|
||||
assert result is False
|
||||
mock_boxim.get_credentials.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_execute_takeover_fails_when_no_credentials(mock_db, mock_boxim, mock_auth, mock_avatar):
|
||||
"""execute_takeover should return False when boxim.get_credentials returns None."""
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
|
||||
mock_boxim.get_credentials.return_value = None
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
message = {"from_accid": "user_acc", "content": "Hello"}
|
||||
|
||||
result = await service.execute_takeover(mock_auth, message)
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
# --- enqueue_delayed_message ---
|
||||
|
||||
|
||||
def test_enqueue_delayed_message_with_redis(mock_db, mock_boxim, mock_auth, mock_avatar):
|
||||
mock_redis = MagicMock()
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim, mock_redis)
|
||||
message = {"msg_id": "msg_1", "from_accid": "user_acc", "content": "Hello"}
|
||||
|
||||
service.enqueue_delayed_message(mock_auth, message)
|
||||
|
||||
mock_redis.setex.assert_called_once()
|
||||
call_args = mock_redis.setex.call_args
|
||||
value = call_args[0][1]
|
||||
import json
|
||||
payload = json.loads(call_args[0][2])
|
||||
assert payload["owner_huihui_id"] == "owner_huihui_123"
|
||||
|
||||
|
||||
def test_enqueue_delayed_message_without_redis_logs_warning(mock_db, mock_boxim, mock_auth, mock_avatar):
|
||||
"""When Redis is not configured, enqueue_delayed_message should log a warning and not crash."""
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
mock_db.query.return_value = avatar_query
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
message = {"msg_id": "msg_1", "from_accid": "user_acc", "content": "Hello"}
|
||||
|
||||
service.enqueue_delayed_message(mock_auth, message)
|
||||
|
||||
|
||||
# --- process_delayed_queue ---
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_delayed_queue_no_redis(mock_db, mock_boxim):
|
||||
"""process_delayed_queue should return immediately without Redis."""
|
||||
service = TakeoverService(mock_db, mock_boxim)
|
||||
await service.process_delayed_queue()
|
||||
mock_db.query.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_delayed_queue_processes_messages(mock_db, mock_boxim, mock_auth, mock_avatar):
|
||||
"""process_delayed_queue should read from Redis, resolve auth, and execute takeover."""
|
||||
mock_redis = MagicMock()
|
||||
mock_redis.keys.return_value = ["takeover:delayed:target_user_123:msg_1"]
|
||||
mock_redis.get.return_value = '{"from_accid": "user_acc", "content": "Hello"}'
|
||||
|
||||
avatar_filter = MagicMock()
|
||||
avatar_filter.first.return_value = mock_avatar
|
||||
avatar_query = MagicMock()
|
||||
avatar_query.filter.return_value = avatar_filter
|
||||
|
||||
auth_filter = MagicMock()
|
||||
auth_filter.filter.return_value = auth_filter
|
||||
auth_filter.first.return_value = mock_auth
|
||||
|
||||
def query_side_effect(model):
|
||||
if model == Avatar:
|
||||
return avatar_query
|
||||
return auth_filter
|
||||
|
||||
mock_db.query.side_effect = query_side_effect
|
||||
|
||||
with patch("services.takeover_service.httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"code": 200, "data": {"answer": "Hello back"}}
|
||||
mock_client_class.return_value.__aenter__.return_value.post.return_value = mock_response
|
||||
|
||||
service = TakeoverService(mock_db, mock_boxim, mock_redis)
|
||||
await service.process_delayed_queue()
|
||||
|
||||
mock_boxim.send_p2p_message.assert_called_once()
|
||||
mock_redis.delete.assert_called_once()
|
||||
def test_plain_text_reply_removes_markdown_and_empty_lines():
|
||||
assert _plain_text_reply("## 建议\n\n**不能自行用药**\n`必要时就医`") == "建议\n不能自行用药\n必要时就医"
|
||||
|
||||
Reference in New Issue
Block a user