255 lines
16 KiB
Python
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() |