更新
This commit is contained in:
Your Name
@@ -0,0 +1,294 @@
|
||||
"""托管多个账号时的会话归属隔离回归测试。
|
||||
|
||||
复现的缺陷：账号 A 的处理链路收到属于账号 B 的会话（0:1:B:B的好友）后，
|
||||
resolve_peer_uid 把末段当成「对方」、normalize_conversation_id 再拼成
|
||||
0:1:A:B的好友，于是账号 A 用自己的凭证把自动回复发给了账号 B 的好友。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import AsyncMock, Mock, patch
|
||||
|
||||
|
||||
BACKEND_DIR = Path(__file__).resolve().parents[1]
|
||||
os.environ.setdefault("KEFU_DB_TYPE", "sqlite")
|
||||
os.environ.setdefault("KEFU_DATABASE_URL", "")
|
||||
os.environ.setdefault("KEFU_DB_PATH", str(BACKEND_DIR / "kefu.db"))
|
||||
if str(BACKEND_DIR) not in sys.path:
|
||||
sys.path.insert(0, str(BACKEND_DIR))
|
||||
|
||||
from rpa_engine.douyin_im import hosted_registry
|
||||
from rpa_engine.douyin_im import ws_client as ws_module
|
||||
from rpa_engine.douyin_im.conv_util import conversation_belongs_to
|
||||
from rpa_engine.douyin_im.http_client import DouyinImHttpClient
|
||||
from rpa_engine.douyin_im.service import DouyinImService
|
||||
from rpa_engine.douyin_im.session import DouyinImSession
|
||||
from rpa_engine.douyin_im.ws_client import DouyinImWsClient
|
||||
|
||||
ACCOUNT_A_UID = 7670159096859706425
|
||||
ACCOUNT_B_UID = 7670157997767050299
|
||||
PEER_OF_B = 66578464308
|
||||
|
||||
|
||||
class ConversationOwnershipTests(unittest.TestCase):
|
||||
def test_foreign_single_chat_is_rejected(self):
|
||||
self.assertFalse(
|
||||
conversation_belongs_to(
|
||||
f"0:1:{ACCOUNT_B_UID}:{PEER_OF_B}", ACCOUNT_A_UID
|
||||
)
|
||||
)
|
||||
|
||||
def test_own_conversation_in_either_position(self):
|
||||
self.assertTrue(
|
||||
conversation_belongs_to(f"0:1:{ACCOUNT_A_UID}:{PEER_OF_B}", ACCOUNT_A_UID)
|
||||
)
|
||||
self.assertTrue(
|
||||
conversation_belongs_to(f"0:1:{PEER_OF_B}:{ACCOUNT_A_UID}", ACCOUNT_A_UID)
|
||||
)
|
||||
|
||||
def test_undecidable_shapes_pass_through(self):
|
||||
# 缺 my_uid / 群聊 / 裸 UID：本来就判不了归属，保守放行
|
||||
self.assertTrue(conversation_belongs_to(f"0:1:{ACCOUNT_B_UID}:{PEER_OF_B}", 0))
|
||||
self.assertTrue(conversation_belongs_to("0:2:123:456", ACCOUNT_A_UID))
|
||||
self.assertTrue(conversation_belongs_to(str(PEER_OF_B), ACCOUNT_A_UID))
|
||||
self.assertTrue(conversation_belongs_to("", ACCOUNT_A_UID))
|
||||
|
||||
|
||||
class ForeignMessageDropTests(unittest.IsolatedAsyncioTestCase):
|
||||
def _service(self) -> DouyinImService:
|
||||
service = DouyinImService(
|
||||
session=DouyinImSession(cookies={"sessionid": "a"}, my_uid=ACCOUNT_A_UID),
|
||||
match_reply=AsyncMock(return_value=["自动回复"]),
|
||||
log_fn=AsyncMock(),
|
||||
account_id=1,
|
||||
)
|
||||
service._running = True
|
||||
return service
|
||||
|
||||
async def test_message_from_another_account_never_schedules_a_reply(self):
|
||||
service = self._service()
|
||||
service._resolve_peer_profile = AsyncMock(
|
||||
return_value=("B 的好友", "", str(PEER_OF_B))
|
||||
)
|
||||
|
||||
with patch(
|
||||
"rpa_engine.douyin_im.service.system_logger.record", Mock()
|
||||
) as record:
|
||||
result = await service._prepare_incoming(
|
||||
{
|
||||
"conversation_id": f"0:1:{ACCOUNT_B_UID}:{PEER_OF_B}",
|
||||
"sender_uid": str(PEER_OF_B),
|
||||
"content": "在吗",
|
||||
"server_message_id": "7665317099296081465",
|
||||
}
|
||||
)
|
||||
|
||||
self.assertIsNone(result)
|
||||
service.match_reply.assert_not_awaited()
|
||||
service.log_fn.assert_not_awaited()
|
||||
self.assertEqual(service._conv_meta, {})
|
||||
self.assertTrue(record.called)
|
||||
|
||||
async def test_own_message_is_still_processed(self):
|
||||
service = self._service()
|
||||
conv_id = f"0:1:{ACCOUNT_A_UID}:{PEER_OF_B}"
|
||||
service._resolve_peer_profile = AsyncMock(
|
||||
return_value=("我的好友", "", str(PEER_OF_B))
|
||||
)
|
||||
service._resolve_cooldown_seconds = AsyncMock(return_value=0)
|
||||
service._resolve_reply_delay_seconds = AsyncMock(return_value=0)
|
||||
service._send_auto_reply = AsyncMock()
|
||||
|
||||
with patch("rpa_engine.douyin_im.service.system_logger.record", Mock()):
|
||||
send_reply = await service._prepare_incoming(
|
||||
{
|
||||
"conversation_id": conv_id,
|
||||
"sender_uid": str(PEER_OF_B),
|
||||
"content": "在吗",
|
||||
"server_message_id": "7665317099296081466",
|
||||
}
|
||||
)
|
||||
|
||||
self.assertIsNotNone(send_reply)
|
||||
service.match_reply.assert_awaited()
|
||||
self.assertIn(conv_id, service._conv_meta)
|
||||
|
||||
|
||||
class ForeignSendRefusalTests(unittest.IsolatedAsyncioTestCase):
|
||||
async def test_send_refuses_a_conversation_owned_by_another_account(self):
|
||||
client = DouyinImHttpClient(
|
||||
DouyinImSession(cookies={"sessionid": "a"}, my_uid=ACCOUNT_A_UID),
|
||||
account_id=1,
|
||||
)
|
||||
resolve_meta = AsyncMock()
|
||||
|
||||
with (
|
||||
patch.object(
|
||||
DouyinImHttpClient,
|
||||
"_resolve_authoritative_uid",
|
||||
return_value=ACCOUNT_A_UID,
|
||||
),
|
||||
patch.object(
|
||||
DouyinImHttpClient, "resolve_conversation_meta", resolve_meta
|
||||
),
|
||||
patch("rpa_engine.douyin_im.http_client.system_logger.record", Mock()),
|
||||
):
|
||||
sent = await client.send_text_message(
|
||||
f"0:1:{ACCOUNT_B_UID}:{PEER_OF_B}",
|
||||
"你好",
|
||||
_bypass_global_queue=True,
|
||||
)
|
||||
|
||||
self.assertFalse(sent)
|
||||
# 关键断言：拒发必须发生在解析 ticket / 真正写出去之前
|
||||
resolve_meta.assert_not_awaited()
|
||||
self.assertIn("不是本账号", client.last_error)
|
||||
self.assertFalse(client.last_send_channel_retryable)
|
||||
|
||||
|
||||
class HostedPeerLoopTests(unittest.IsolatedAsyncioTestCase):
|
||||
"""两个本系统托管的账号之间不得互相自动回复（无限回环 → 抖音风控）。"""
|
||||
|
||||
def _service(self) -> DouyinImService:
|
||||
service = DouyinImService(
|
||||
session=DouyinImSession(cookies={"sessionid": "a"}, my_uid=ACCOUNT_A_UID),
|
||||
match_reply=AsyncMock(return_value=["自动回复"]),
|
||||
log_fn=AsyncMock(),
|
||||
account_id=1,
|
||||
)
|
||||
service._running = True
|
||||
service._resolve_cooldown_seconds = AsyncMock(return_value=0)
|
||||
service._resolve_reply_delay_seconds = AsyncMock(return_value=0)
|
||||
return service
|
||||
|
||||
def tearDown(self):
|
||||
hosted_registry.unregister(ACCOUNT_B_UID)
|
||||
|
||||
async def _incoming_from(self, service, peer_uid: int, message_id: str):
|
||||
service._resolve_peer_profile = AsyncMock(
|
||||
return_value=("对方", "", str(peer_uid))
|
||||
)
|
||||
with patch("rpa_engine.douyin_im.service.system_logger.record", Mock()):
|
||||
return await service._prepare_incoming(
|
||||
{
|
||||
"conversation_id": f"0:1:{ACCOUNT_A_UID}:{peer_uid}",
|
||||
"sender_uid": str(peer_uid),
|
||||
"content": "在吗",
|
||||
"server_message_id": message_id,
|
||||
}
|
||||
)
|
||||
|
||||
async def test_no_auto_reply_to_another_hosted_account(self):
|
||||
hosted_registry.register(ACCOUNT_B_UID)
|
||||
service = self._service()
|
||||
|
||||
result = await self._incoming_from(service, ACCOUNT_B_UID, "1")
|
||||
|
||||
self.assertIsNone(result)
|
||||
service.match_reply.assert_not_awaited()
|
||||
# 消息本身照常入库，只是标记为未回复
|
||||
statuses = [
|
||||
call.kwargs.get("status") for call in service.log_fn.await_args_list
|
||||
]
|
||||
self.assertIn("received", statuses)
|
||||
self.assertIn("ignored", statuses)
|
||||
|
||||
async def test_ordinary_follower_still_gets_a_reply(self):
|
||||
hosted_registry.register(ACCOUNT_B_UID)
|
||||
service = self._service()
|
||||
service._send_auto_reply = AsyncMock()
|
||||
|
||||
result = await self._incoming_from(service, PEER_OF_B, "2")
|
||||
|
||||
self.assertIsNotNone(result)
|
||||
service.match_reply.assert_awaited()
|
||||
|
||||
|
||||
class FrontierDeviceExclusivityTests(unittest.IsolatedAsyncioTestCase):
|
||||
"""同一个 frontier 设备号同时只允许一个账号建连。"""
|
||||
|
||||
WS_URL = (
|
||||
"wss://frontier-im.douyin.com/ws/v2?fpid=9&device_id=987654321&"
|
||||
"token=shared-token"
|
||||
)
|
||||
|
||||
def setUp(self):
|
||||
ws_module._FRONTIER_DEVICE_OWNERS.clear()
|
||||
|
||||
def tearDown(self):
|
||||
ws_module._FRONTIER_DEVICE_OWNERS.clear()
|
||||
|
||||
def _client(self, account_id: int) -> DouyinImWsClient:
|
||||
client = DouyinImWsClient(
|
||||
DouyinImSession(cookies={"sessionid": "s"}, ws_urls=[self.WS_URL]),
|
||||
AsyncMock(),
|
||||
account_id=account_id,
|
||||
)
|
||||
client._running = True
|
||||
client._task = SimpleNamespace(done=lambda: False)
|
||||
return client
|
||||
|
||||
def test_second_account_is_denied_while_the_first_holds_the_device(self):
|
||||
first = self._client(11)
|
||||
second = self._client(12)
|
||||
|
||||
self.assertTrue(first._claim_frontier_device(self.WS_URL))
|
||||
self.assertFalse(second._claim_frontier_device(self.WS_URL))
|
||||
self.assertEqual(second._blocked_device_owner_id, 11)
|
||||
# 让出方不会被误标为已占用，重连时仍是 HTTP 轮询兜底
|
||||
self.assertFalse(second.connected)
|
||||
|
||||
def test_device_is_taken_over_after_the_owner_stops(self):
|
||||
first = self._client(11)
|
||||
second = self._client(12)
|
||||
self.assertTrue(first._claim_frontier_device(self.WS_URL))
|
||||
|
||||
first._running = False
|
||||
first._release_frontier_device()
|
||||
|
||||
self.assertTrue(second._claim_frontier_device(self.WS_URL))
|
||||
|
||||
def test_same_account_reconnect_keeps_its_own_device(self):
|
||||
client = self._client(11)
|
||||
self.assertTrue(client._claim_frontier_device(self.WS_URL))
|
||||
self.assertTrue(client._claim_frontier_device(self.WS_URL))
|
||||
|
||||
async def test_run_loop_does_not_open_a_second_connection(self):
|
||||
owner = self._client(11)
|
||||
self.assertTrue(owner._claim_frontier_device(self.WS_URL))
|
||||
|
||||
blocked = self._client(12)
|
||||
blocked._prepare_url = AsyncMock(return_value=self.WS_URL)
|
||||
run_connection = AsyncMock()
|
||||
blocked._run_connection = run_connection
|
||||
|
||||
async def stop_after_first_backoff(_seconds):
|
||||
blocked._running = False
|
||||
|
||||
with (
|
||||
patch.object(ws_module, "_reconnect_delay", return_value=0.0),
|
||||
patch.object(ws_module.system_logger, "record") as record,
|
||||
patch.object(ws_module.asyncio, "sleep", stop_after_first_backoff),
|
||||
):
|
||||
await asyncio.wait_for(blocked._run_loop(self.WS_URL), timeout=1.0)
|
||||
|
||||
run_connection.assert_not_awaited()
|
||||
self.assertFalse(blocked.connected)
|
||||
self.assertTrue(record.called)
|
||||
|
||||
def test_url_without_device_id_is_not_blocked(self):
|
||||
first = self._client(11)
|
||||
second = self._client(12)
|
||||
url = "wss://frontier-im.douyin.com/ws/v2?fpid=9&token=t"
|
||||
|
||||
self.assertTrue(first._claim_frontier_device(url))
|
||||
self.assertTrue(second._claim_frontier_device(url))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user