268 lines
12 KiB
Python
268 lines
12 KiB
Python
"""Manual-needed protocol episodes: synthetic DB/queue, no native/network I/O."""
|
|
import json
|
|
import sqlite3
|
|
import unittest
|
|
from contextlib import closing
|
|
from unittest import mock
|
|
|
|
from protocol_engine import session_key
|
|
from review_assistant import _fingerprint
|
|
from test_native_protocol_pipeline import ACCOUNT, CONV, message
|
|
import test_protocol_review_assistant as helpers
|
|
|
|
|
|
class ProtocolManualAssistantTests(unittest.TestCase):
|
|
setUp = helpers.ProtocolSharedCoordinatorTests.setUp
|
|
make_bot = helpers.ProtocolReviewAssistantTests.make_bot
|
|
add = helpers.ProtocolSharedCoordinatorTests.add
|
|
|
|
def manual(self, row=2):
|
|
item = self.add(row, text='synthetic image')
|
|
item['content_type'] = 3
|
|
self.bot.poll_once()
|
|
state = self.bot._pending[self.key]
|
|
self.assertTrue(state['manual_required'])
|
|
self.assertTrue(state.get('assistant_review_id'))
|
|
return state
|
|
|
|
def episodes(self):
|
|
with closing(sqlite3.connect(self.coordinator.path)) as conn:
|
|
return [json.loads(row[0]) for row in conn.execute('SELECT data FROM episodes ORDER BY rowid')]
|
|
|
|
def human(self, row=3, **kwargs):
|
|
result = self.add(row, self_reply=True, text='verified synthetic human answer', **kwargs)
|
|
self.bot.poll_once()
|
|
return result
|
|
|
|
def test_manual_media_registers_once_without_an_approvable_draft(self):
|
|
state = self.manual()
|
|
self.bot.poll_once()
|
|
self.assertEqual(len(self.episodes()), 1)
|
|
self.assertEqual(self.episodes()[0]['id'], state['assistant_review_id'])
|
|
self.assertFalse(state['awaiting_review'])
|
|
self.assertFalse(state['reply_text'])
|
|
self.coordinator.enqueue_notifications.assert_called()
|
|
self.generate.assert_not_called()
|
|
self.assertFalse(self.sender.calls)
|
|
self.assertEqual(self.bot.approve_pending_replies([self.key])['not_pending'], [self.key])
|
|
|
|
def test_manual_customer_task_finishes_then_future_safe_message_resumes_auto(self):
|
|
state = self.manual()
|
|
self.human()
|
|
self.assertNotIn(self.key, self.bot._pending)
|
|
self.assertTrue(self.coordinator.resumed(CONV))
|
|
self.assertEqual(self.episodes()[0]['status'], 'completed')
|
|
self.assertEqual(self.bot._seen[self.key], state['dedup_key'])
|
|
self.assertTrue(any('人工已完成' in text for text in self.logs))
|
|
self.assertFalse(self.sender.calls)
|
|
self.add(4, text='new safe synthetic text')
|
|
self.bot.poll_once()
|
|
self.assertEqual(len(self.sender.calls), 1)
|
|
self.assertEqual(self.sender.calls[0][0], message(4)['dedup_key'])
|
|
|
|
def test_new_risk_after_manual_completion_creates_new_review_episode(self):
|
|
first = self.manual()['assistant_review_id']
|
|
self.human()
|
|
self.add(4)
|
|
with mock.patch('review_policy.selective_review_reason', return_value='new synthetic risk'):
|
|
self.bot.poll_once()
|
|
state = self.bot._pending[self.key]
|
|
self.assertTrue(state['awaiting_review'])
|
|
self.assertNotEqual(first, state['assistant_review_id'])
|
|
self.assertFalse(state.get('manual_required'))
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_further_incoming_text_preserves_manual_episode_until_human_reply(self):
|
|
state = self.manual()
|
|
self.add(3, text='additional synthetic detail')
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key], state)
|
|
self.assertEqual(len(self.episodes()), 1)
|
|
self.generate.assert_not_called()
|
|
self.assertFalse(self.sender.calls)
|
|
self.human(4)
|
|
self.assertNotIn(self.key, self.bot._pending)
|
|
|
|
def test_late_human_sync_keeps_question_sent_after_that_human_reply(self):
|
|
self.manual()
|
|
newest = self.add(4, text='later synthetic question')
|
|
self.bot.poll_once()
|
|
self.human(5, seconds=3)
|
|
self.assertEqual(len(self.sender.calls), 1)
|
|
self.assertEqual(self.sender.calls[0][0], newest['dedup_key'])
|
|
self.assertTrue(self.coordinator.resumed(CONV))
|
|
|
|
def test_generation_error_is_notified_and_human_answer_resolves_it(self):
|
|
self.generate.side_effect = RuntimeError('synthetic model unavailable')
|
|
self.add(2)
|
|
self.bot.poll_once()
|
|
state = self.bot._pending[self.key]
|
|
self.assertEqual(state['stage'], 'error')
|
|
self.assertTrue(state.get('assistant_review_id'))
|
|
self.human()
|
|
self.assertNotIn(self.key, self.bot._pending)
|
|
self.assertTrue(self.coordinator.resumed(CONV))
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_restart_preserves_manual_episode_and_completes_verified_reply(self):
|
|
state = self.manual()
|
|
self.add(3, self_reply=True, text='human reply while listener absent')
|
|
self.db.events.clear()
|
|
restored = self.make_bot()
|
|
restored.poll_once()
|
|
self.assertNotIn(self.key, restored._pending)
|
|
self.assertEqual(len(self.episodes()), 1)
|
|
self.assertEqual(self.episodes()[0]['id'], state['assistant_review_id'])
|
|
self.assertEqual(self.episodes()[0]['status'], 'completed')
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_other_account_or_bot_outbound_does_not_finish_manual_task(self):
|
|
state = self.manual()
|
|
self.coordinator.record_automated_send(state, {'status':'confirmed','serverId':'3'})
|
|
self.human()
|
|
self.assertIs(self.bot._pending[self.key], state)
|
|
self.assertFalse(self.coordinator.resumed(CONV))
|
|
self.db.add({**message(4, self=True), 'sender_id':'different-account', 'send_time':self.base_time+4})
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key], state)
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_cancelled_manual_task_does_not_restore_global_auto_mode(self):
|
|
self.manual()
|
|
self.bot.cancel_pending_replies([self.key])
|
|
self.human()
|
|
self.assertFalse(self.coordinator.resumed(CONV))
|
|
self.assertEqual(self.episodes()[0]['status'], 'cancelled')
|
|
self.add(4)
|
|
self.bot.poll_once()
|
|
self.assertTrue(self.bot._pending[self.key]['awaiting_review'])
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_explicit_disabled_or_cancel_requested_tasks_are_not_resumed(self):
|
|
state = self.manual()
|
|
state.update(stage='disabled', cancel_requested=True)
|
|
self.bot._save()
|
|
self.add(3, self_reply=True, text='synthetic human reply')
|
|
self.bot.poll_once()
|
|
self.add(4, text='new synthetic customer message')
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key], state)
|
|
self.assertFalse(self.coordinator.resumed(CONV))
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def terminal(self, status='uncertain', stage='receipt_check'):
|
|
state = self.manual()
|
|
state.update(send_state=status, stage=stage, reply_text='unconfirmed synthetic AI draft',
|
|
staged_reply_text='unconfirmed synthetic AI draft', manual_required=False)
|
|
self.bot._save()
|
|
return state
|
|
|
|
def test_terminal_unknown_is_completed_by_new_human_reply_without_replaying_or_altering_journal(self):
|
|
state = self.terminal()
|
|
journal = self.root / 'protocol_sends.sqlite3'
|
|
with closing(sqlite3.connect(journal)) as conn, conn:
|
|
conn.execute('CREATE TABLE sends(request_id TEXT,fingerprint TEXT,status TEXT,result TEXT,created REAL)')
|
|
conn.execute('INSERT INTO sends VALUES(?,?,?,?,?)', ('old-request',_fingerprint(ACCOUNT,CONV,state['reply_text']),'unknown','{}',self.base_time))
|
|
original = journal.read_bytes()
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key], state)
|
|
self.assertFalse(self.sender.calls)
|
|
self.human()
|
|
self.assertNotIn(self.key, self.bot._pending)
|
|
self.assertFalse(self.sender.calls)
|
|
saved=json.loads(self.bot.path.read_text(encoding='utf-8'))
|
|
handoff=saved['manual_handoffs'][self.key]
|
|
self.assertTrue(handoff['completed_by_human'])
|
|
self.assertFalse(handoff['delivery_confirmed'])
|
|
self.assertEqual(handoff['state']['send_state'],'uncertain')
|
|
self.assertTrue(handoff['evidence']['completed_by_human'])
|
|
self.assertEqual(journal.read_bytes(),original)
|
|
self.add(4)
|
|
self.bot.poll_once()
|
|
self.assertEqual(len(self.sender.calls),1)
|
|
self.assertEqual(self.sender.calls[0][0],message(4)['dedup_key'])
|
|
|
|
def test_failed_send_can_finish_only_on_later_human_evidence(self):
|
|
self.terminal('failed','failed')
|
|
self.bot.poll_once()
|
|
self.assertFalse(self.sender.calls)
|
|
self.human()
|
|
self.assertNotIn(self.key,self.bot._pending)
|
|
self.assertTrue(self.coordinator.resumed(CONV))
|
|
self.assertEqual(self.bot._manual_handoffs[self.key]['state']['send_state'],'failed')
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_active_send_and_unresolved_receipt_phase_never_complete(self):
|
|
state=self.manual()
|
|
for status, stage in [('sending','sending'),('','sending'),('','receipt_check')]:
|
|
with self.subTest(status=status,stage=stage):
|
|
state.update(send_state=status,stage=stage)
|
|
self.add(3,self_reply=True,text='synthetic human reply')
|
|
self.db.events.clear()
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key],state)
|
|
self.assertFalse(self.coordinator.resumed(CONV))
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_unconfirmed_ai_draft_echo_cannot_be_used_as_manual_completion(self):
|
|
state=self.terminal()
|
|
self.add(3,self_reply=True,text=state['reply_text'])
|
|
self.bot.poll_once()
|
|
self.assertIs(self.bot._pending[self.key],state)
|
|
self.assertFalse(self.coordinator.resumed(CONV))
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
|
|
def test_new_unknown_send_registers_manual_notification_then_only_human_finishes(self):
|
|
from wecom_native_sender import DeliveryUnknown
|
|
self.bot.send_mode='auto'
|
|
self.sender.error=DeliveryUnknown('synthetic receipt unconfirmed')
|
|
self.add(2)
|
|
self.bot.poll_once()
|
|
state=self.bot._pending[self.key]
|
|
self.assertEqual(state['send_state'],'uncertain')
|
|
self.assertTrue(state.get('assistant_review_id'))
|
|
self.assertEqual(self.episodes()[0]['handling_kind'],'manual')
|
|
self.assertEqual(len(self.sender.calls),1)
|
|
self.bot.poll_once()
|
|
self.assertEqual(len(self.sender.calls),1)
|
|
self.human()
|
|
self.assertNotIn(self.key,self.bot._pending)
|
|
self.assertEqual(len(self.sender.calls),1)
|
|
self.assertFalse(self.bot.needs_attention)
|
|
|
|
def test_terminal_completion_queue_save_failure_restores_evidence_before_retry(self):
|
|
state=self.terminal()
|
|
self.add(3,self_reply=True,text='synthetic human answer')
|
|
self.db.events.clear()
|
|
with mock.patch.object(self.bot,'_save',side_effect=OSError('synthetic full disk')):
|
|
with self.assertRaises(OSError):
|
|
self.bot._reconcile_assistant_review(self.key,state)
|
|
self.assertIs(self.bot._pending[self.key],state)
|
|
self.assertNotIn(self.key,self.bot._manual_handoffs)
|
|
self.assertTrue(self.bot._reconcile_assistant_review(self.key,state))
|
|
self.assertNotIn(self.key,self.bot._pending)
|
|
self.assertEqual(self.bot._manual_handoffs[self.key]['state']['send_state'],'uncertain')
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
def test_legacy_manual_task_with_exact_trigger_can_verify_reply_after_restart(self):
|
|
self.settings['review_assistant_accounts'][ACCOUNT]['enabled']=False
|
|
original=self.add(2,text='legacy synthetic image')
|
|
original['content_type']=3
|
|
self.bot.poll_once()
|
|
state=self.bot._pending[self.key]
|
|
self.assertTrue(state['manual_required'])
|
|
self.assertFalse(state.get('assistant_review_id'))
|
|
self.add(3,self_reply=True,text='human answer before upgraded listener')
|
|
self.db.events.clear()
|
|
self.settings['review_assistant_accounts'][ACCOUNT]['enabled']=True
|
|
restored=self.make_bot()
|
|
restored.poll_once()
|
|
self.assertNotIn(self.key,restored._pending)
|
|
self.assertTrue(self.coordinator.resumed(CONV))
|
|
self.assertEqual(self.episodes()[0]['baseline_source'],'task_event')
|
|
self.assertFalse(self.sender.calls)
|
|
|
|
|
|
if __name__=='__main__':unittest.main()
|