Files
xieyi-weixin-/test_native_protocol_pipeline.py
T
2026-09-21 10:56:48 +08:00

255 lines
16 KiB
Python

"""Protocol regression tests use synthetic messages and never connect to WeCom."""
import json
from pathlib import Path
import tempfile
import unittest
from contextlib import nullcontext
from unittest import mock
from wecom_native_sender import NativeSender,NativeUnavailable,DeliveryUnknown,DeliveryFailed,SendCancelled
from protocol_engine import ProtocolBot,session_key
ACCOUNT='100';CONV='S:100_200'
def message(n=1,*,account=ACCOUNT,conv=CONV,self=False,text='客户问题'):
return {'account':account,'conv_id':conv,'display_name':'同名客户','rowid':n,'server_id':str(n),'sender_id':account if self else '200','is_self':self,'content':text,'content_type':2,'send_time':n,'dedup_key':f'{account}:{conv}:{n}'}
class Database:
def __init__(self):self.events=[];self.messages=[message()]
def health_check(self):return True
def get_new_messages(self,since):items=self.events;self.events=[];return items
def get_conversation_context_by_id(self,a,c,limit=100):
values=[m for m in self.messages if m['account']==a and m['conv_id']==c]
if not values:return None
return {'account':a,'conv_id':c,'display_name':'同名客户','text':'客户:'+values[-1]['content'],'last_message':values[-1],'messages':values[-limit:]}
def add(self,m):self.messages.append(m);self.events.append(m)
def close(self):pass
class Sender:
def __init__(self,db):self.calls=[];self.db=db;self.error=None
def send(self,r,p,a,c,t,*,guard):
if not guard():raise SendCancelled('changed')
self.calls.append((r,a,c,t))
if self.error:raise self.error
self.db.add(message(999,account=a,conv=c,self=True,text=t));return {'serverId':999,'status':'confirmed'}
def close(self):pass
class EngineTests(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup);self.root=Path(self.tmp.name)
self.db=Database();self.sender=Sender(self.db);self.gen=mock.Mock(return_value='回复')
self.patches=[mock.patch('protocol_engine.application_data_dir',return_value=self.root),mock.patch('queue_log.application_data_dir',return_value=self.root)]
for p in self.patches:p.start();self.addCleanup(p.stop)
self.bot=self.make_bot();self.bot.message_batch_window_seconds=0;self.bot.send_delay_seconds=0
self.bot._needs_review=lambda state:(self.bot.send_mode=='review','人工审核')
def make_bot(self):
return ProtocolBot(db=self.db,sender=self.sender,identity={'accountId':ACCOUNT,'pid':1},path=self.root/'queue.json',generate=self.gen)
def enqueue(self,m=None):self.db.add(m or message());self.bot.poll_once()
def test_text_pipeline_with_native_receipt_and_no_feedback(self):
self.enqueue();self.assertEqual(len(self.sender.calls),1);self.assertEqual(self.bot.reply_count,1)
self.bot.poll_once();self.assertEqual(len(self.sender.calls),1);self.assertFalse(self.bot._pending)
def observe_progress(self):
self.progress=[];self.logs=[]
self.bot.progress_cb=self.progress.append;self.bot.log=self.logs.append
def test_progress_follows_receive_generate_send_then_waiting(self):
self.observe_progress()
self.bot.generate=lambda ctx:(self.assertIn('正在生成回复',self.progress[-1]) or '回复')
original_send=self.sender.send
def send(*args,**kwargs):
self.assertIn('正在协议发送并核对回执',self.progress[-1])
return original_send(*args,**kwargs)
self.sender.send=send
self.enqueue(message(text='私密聊天正文'))
self.assertEqual(self.progress[-1],'协议监听中 · 等待新消息')
self.assertTrue(any('[协议收信]' in item for item in self.logs))
self.assertTrue(any('[协议发送成功]' in item for item in self.logs))
self.assertNotIn('私密聊天正文',' '.join(self.progress+self.logs))
self.bot.poll_once()
self.assertEqual(len(self.sender.calls),1)
self.assertEqual(sum('[协议收信]' in item for item in self.logs),1)
def test_waiting_progress_and_periodic_read_confirmation_are_throttled(self):
self.observe_progress();self.bot._last_poll_log=100
with mock.patch('protocol_engine.time.monotonic',return_value=101):
self.bot.poll_once();self.bot.poll_once()
self.assertEqual(self.progress,['协议监听中 · 等待新消息'])
self.assertEqual(self.logs,[])
with mock.patch('protocol_engine.time.monotonic',return_value=160):
self.bot.poll_once();self.bot.poll_once()
self.assertEqual(len(self.logs),1)
self.assertIn('已检查 3 轮',self.logs[0])
self.assertIn('已确认发送 0 条',self.logs[0])
def test_pending_review_and_errors_do_not_show_idle(self):
self.observe_progress();self.bot.message_batch_window_seconds=60;self.enqueue()
self.assertEqual(self.progress[-1],'协议监听中 · 待处理 1 个会话')
key=session_key(ACCOUNT,CONV);self.bot._pending[key]['ready_at']=0
self.bot.send_mode='review';self.bot.poll_once()
self.assertEqual(self.progress[-1],'协议监听中 · 1 个会话待审核')
self.bot.cancel_pending_replies([key]);self.bot.send_mode='auto'
self.bot.message_batch_window_seconds=0
self.bot.generate=mock.Mock(side_effect=RuntimeError('model offline'))
self.enqueue(message(2))
self.assertEqual(self.progress[-1],'协议监听中 · 1 个会话待人工处理')
self.assertTrue(any('model offline' in item for item in self.logs))
self.assertFalse(self.sender.calls)
def test_unknown_receipt_isolated_with_healthy_poll_log(self):
self.observe_progress();self.sender.error=DeliveryUnknown('timeout')
self.bot._last_poll_log=0
self.enqueue()
self.assertEqual(self.progress[-1],'协议监听中 · 1 个会话发送结果待核对,其他会话继续处理')
self.assertTrue(any('轮询正常' in item for item in self.logs))
self.assertFalse(any('[协议发送成功]' in item for item in self.logs))
self.bot.poll_once();self.assertEqual(len(self.sender.calls),1)
def test_database_read_failure_never_announces_healthy_listener(self):
self.observe_progress();self.bot._last_poll_log=0
self.db.get_new_messages=mock.Mock(side_effect=RuntimeError('database unreadable'))
with self.assertRaisesRegex(RuntimeError,'database unreadable'):self.bot.poll_once()
self.assertEqual(self.progress,[]);self.assertEqual(self.logs,[])
self.assertEqual(self.bot._completed_polls,0)
self.assertFalse(self.sender.calls)
def test_progress_callback_failure_does_not_repeat_or_block_send(self):
self.bot.progress_cb=mock.Mock(side_effect=RuntimeError('display closed'))
self.enqueue();self.bot.poll_once()
self.assertEqual(len(self.sender.calls),1)
self.assertEqual(self.bot.reply_count,1)
def test_duplicate_event_only_sent_once(self):
self.enqueue();self.db.events=[message()];self.bot.poll_once();self.assertEqual(len(self.sender.calls),1)
def test_only_current_account_processed(self):
self.enqueue(message(account='101',conv='S:101_200'));self.gen.assert_not_called();self.assertFalse(self.sender.calls)
def test_same_name_conversations_use_distinct_ids(self):
self.db.add(message(conv='S:100_201'));self.db.add(message());self.bot.poll_once()
self.assertEqual({x[2] for x in self.sender.calls},{CONV,'S:100_201'})
def test_review_requires_approval(self):
self.bot.send_mode='review';self.enqueue();self.assertFalse(self.sender.calls)
key=session_key(ACCOUNT,CONV);self.assertTrue(self.bot._pending[key]['awaiting_review'])
self.bot.approve_pending_replies([key]);self.bot.poll_once();self.assertEqual(len(self.sender.calls),1)
def test_new_message_invalidates_approved_draft(self):
self.bot.send_mode='review';self.enqueue();key=session_key(ACCOUNT,CONV)
self.bot.approve_pending_replies([key]);self.db.add(message(2,text='补充问题'));self.bot.poll_once()
self.assertFalse(self.sender.calls);self.assertTrue(self.bot._pending[key]['awaiting_review'])
def test_manual_reply_during_generation_cancels_send(self):
def generate(ctx):self.db.add(message(2,self=True));return '过时回复'
self.bot.generate=generate;self.enqueue();self.assertFalse(self.sender.calls)
def test_new_incoming_during_generation_discards_old_answer(self):
def generate(ctx):self.db.add(message(2,text='新问题'));return '过时回复'
self.bot.generate=generate;self.enqueue();self.assertFalse(self.sender.calls)
self.assertEqual(self.bot._pending[session_key(ACCOUNT,CONV)]['dedup_key'],message(2)['dedup_key'])
def test_cancel_during_generation_does_not_send(self):
def generate(ctx):self.bot.cancel_pending_replies([session_key(ACCOUNT,CONV)]);return '过时回复'
self.bot.generate=generate;self.enqueue();self.assertFalse(self.sender.calls)
def test_stop_during_generation_does_not_send(self):
def generate(ctx):self.bot.stop_event.set();return '过时回复'
self.bot.generate=generate;self.enqueue();self.assertFalse(self.sender.calls)
def test_pending_batch_window_is_honored(self):
self.bot.message_batch_window_seconds=60;self.enqueue();self.gen.assert_not_called()
def test_media_is_left_for_manual_handling(self):
m=message();m['content_type']=3;self.enqueue(m);self.assertFalse(self.sender.calls);self.gen.assert_not_called()
def test_model_error_can_retry_before_send(self):
self.bot.generate=mock.Mock(side_effect=RuntimeError('offline'));self.enqueue();key=session_key(ACCOUNT,CONV)
self.assertEqual(self.bot._pending[key]['stage'],'error');self.assertFalse(self.sender.calls)
self.bot.generate=self.gen;self.bot.retry_pending_replies([key]);self.bot.poll_once();self.assertEqual(len(self.sender.calls),1)
def test_uncertain_send_is_persisted_and_not_retried(self):
self.sender.error=DeliveryUnknown('timeout');self.enqueue();key=session_key(ACCOUNT,CONV)
self.assertTrue(self.bot.needs_attention);self.assertEqual(len(self.sender.calls),1)
restarted=self.make_bot();restarted.poll_once();self.assertEqual(len(self.sender.calls),1)
self.assertEqual(restarted.retry_pending_replies([key])['protected'],[key])
def test_crash_in_sending_becomes_uncertain(self):
self.bot.message_batch_window_seconds=60;self.enqueue();key=session_key(ACCOUNT,CONV)
self.bot._pending[key]['send_state']='sending';self.bot._save();restarted=self.make_bot()
self.assertEqual(restarted._pending[key]['send_state'],'uncertain')
def test_runtime_uses_protocol_engine_without_visual_construction(self):
import queue
from gui_runtime import BotThread
events=queue.Queue()
fake=mock.Mock(reply_count=0,needs_attention=False)
thread=BotThread(events,'回复',.2,reply_transport='protocol')
fake.poll_once.side_effect=thread.stop_event.set
with mock.patch('gui_runtime.transport_start_blocker',return_value=None), mock.patch('protocol_engine.ProtocolBot',return_value=fake) as factory, mock.patch('wechat_bot.WeChatBot') as visual:
thread.run()
visual.assert_not_called();fake.poll_once.assert_called_once();fake.close.assert_called_once()
recorded=list(events.queue)
self.assertIn(('status','running'),recorded)
connected=('progress','协议已连接 · 正在检查新消息')
self.assertGreater(recorded.index(connected),recorded.index(('status','running')))
factory.call_args.kwargs['progress']('协议监听中 · 等待新消息')
self.assertEqual(list(events.queue)[-1],('progress','协议监听中 · 等待新消息'))
def test_restart_after_confirmed_journal_clears_pending_without_send(self):
self.bot.message_batch_window_seconds=60;self.enqueue();key=session_key(ACCOUNT,CONV)
self.bot._pending[key]['send_state']='sending';self.bot._save()
self.sender.lookup=lambda request:{'status':'confirmed','result':{'serverId':55}}
restarted=self.make_bot();self.assertFalse(restarted._pending);self.assertFalse(self.sender.calls)
def test_ready_flag_alone_cannot_enable_transport(self):
from reply_transport import protocol_ready
self.assertFalse(protocol_ready({'canSend':True}))
self.assertFalse(protocol_ready({'canSend':True,'status':'native_ready'}))
self.assertTrue(protocol_ready(dict(status='native_ready',nativeAdapter='wxwork-5.0.10.6023-x86',canSend=True,loginVerified=True,adapterInstalled=True,sendVerified=True,receiptVerified=True,databaseReady=True)))
def test_memory_setting_preserves_only_unanswered_batch_when_disabled(self):
from protocol_engine import model_context_text
import ai_config
ctx={'messages':[message(1,text='历史问题'),message(2,self=True,text='历史回复'),message(3,text='新问题'),message(4,text='新补充')],'display_name':'客户'}
with mock.patch.object(ai_config,'AI_CONTEXT_ENABLED',False):text=model_context_text(ctx)
self.assertNotIn('历史',text);self.assertIn('新问题',text);self.assertIn('新补充',text)
def test_model_control_tokens_are_not_sent(self):
self.bot.generate=lambda ctx:'__NO_INCOMING_MESSAGE__';self.enqueue();self.assertFalse(self.sender.calls)
class JournalTests(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup);self.db=Database();self.calls=0;self.error=None;self.guard=None
outer=self
class Client:
account=ACCOUNT
def __init__(self,*args,**kwargs):pass
def __enter__(self):return self
def __exit__(self,*args):pass
def send(self,a,c,t,*,guard):
if not guard():raise SendCancelled('changed')
outer.calls+=1
if outer.error:raise outer.error
outer.db.add(message(55,self=True,text=t))
return {'serverId':55,'messageId':55,'accountId':a,'conversationId':c}
self.client=Client;self.path=Path(self.tmp.name)/'send.sqlite3'
self.s=NativeSender(self.db,self.path,client_factory=Client,mutex=nullcontext);self.addCleanup(self.s.close)
def send(self,**kw):return self.s.send('event',1,ACCOUNT,CONV,'回复',**kw)
def test_success_receipt_and_repeat_returns_saved_result(self):
first=self.send();self.assertTrue(first['senderVerified']);self.assertEqual(self.send(),first);self.assertEqual(self.calls,1)
def test_reopen_after_success_never_resends(self):
first=self.send();other=NativeSender(self.db,self.path,client_factory=self.client,mutex=nullcontext)
try:self.assertEqual(other.send('event',1,ACCOUNT,CONV,'回复'),first)
finally:other.close()
self.assertEqual(self.calls,1)
def test_unknown_blocks_retry(self):
self.error=DeliveryUnknown('timeout')
with self.assertRaises(DeliveryUnknown):self.send()
with self.assertRaises(DeliveryUnknown):self.send()
self.assertEqual(self.calls,1)
def test_failure_does_not_automatically_retry(self):
self.error=DeliveryFailed('offline')
with self.assertRaises(DeliveryFailed):self.send()
with self.assertRaises(DeliveryUnknown):self.send()
self.assertEqual(self.calls,1)
def test_changed_payload_same_event_is_blocked(self):
self.send()
with self.assertRaises(DeliveryUnknown):self.s.send('event',1,ACCOUNT,CONV,'另一条')
self.assertEqual(self.calls,1)
def test_wrong_account_rejected_before_journaling_or_send(self):
self.client.account='101'
with self.assertRaises(NativeUnavailable):self.send()
self.assertEqual(self.calls,0);self.assertIsNone(self.s.journal.execute('select * from sends').fetchone())
def test_cancelled_before_send_does_not_consume_id(self):
with self.assertRaises(SendCancelled):self.send(guard=lambda:False)
self.assertEqual(self.calls,0);self.send();self.assertEqual(self.calls,1)
def test_missing_conversation_blocks_send(self):
self.db.messages=[]
with self.assertRaises(NativeUnavailable):self.send()
self.assertEqual(self.calls,0)
def test_invalid_text_rejected(self):
for text in ('','x\0y','文'*5000):
with self.assertRaises(ValueError):self.s.send('event',1,ACCOUNT,CONV,text)
self.assertEqual(self.calls,0)
if __name__=='__main__':unittest.main()