504 lines
30 KiB
Python
504 lines
30 KiB
Python
"""Isolated reminder recipient/settings/UI checks; never send a real message."""
|
|
import contextlib
|
|
import json
|
|
from pathlib import Path
|
|
import sqlite3
|
|
import sys
|
|
import tempfile
|
|
from types import MethodType, SimpleNamespace, ModuleType
|
|
from unittest import TestCase, mock
|
|
|
|
import review_assistant_contacts as contacts
|
|
import wechat_gui_qt as qt
|
|
from PySide6.QtCore import QEventLoop, QTimer
|
|
from PySide6.QtWidgets import QApplication, QMainWindow, QDialog
|
|
|
|
ACCOUNT = '168800000000001'
|
|
OTHER = '168800000000002'
|
|
ACTIVE = {'ready': True, 'account_id': ACCOUNT, 'account_name': '合成托管账号', 'reason': ''}
|
|
RECIPIENT_ID = f'S:{ACCOUNT}_10001'
|
|
RECIPIENT = {'id': RECIPIENT_ID, 'peer_id': '10001', 'name': '合成医疗助理', 'kind': '企业微信客户',
|
|
'recipient_kind': 'wecom_customer', 'identityLabel': '企业微信客户 · 客户编号 10001'}
|
|
|
|
|
|
class ReminderContactTest(TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.root = Path(self.temp.name)
|
|
self.folder = self.root / ACCOUNT
|
|
self.folder.mkdir()
|
|
self._seed(self.folder)
|
|
patch = mock.patch.object(contacts, 'active_context', return_value=ACTIVE)
|
|
self.context = patch.start(); self.addCleanup(patch.stop)
|
|
contacts._CACHE.clear()
|
|
|
|
def _seed(self, folder):
|
|
with contextlib.closing(sqlite3.connect(folder / 'message.db')) as db, db:
|
|
db.execute('CREATE TABLE message_table(conversation_id TEXT, send_time REAL, content TEXT)')
|
|
db.executemany('INSERT INTO message_table VALUES(?,?,?)', [
|
|
(RECIPIENT_ID, 1700000000, 'PRIVATE_BODY_NEVER_LOADED'),
|
|
('M:10002', 1700000100, 'PRIVATE_BODY_NEVER_LOADED'),
|
|
('R:100', 1700000200, 'group'), ('S:1_2', 1700000300, 'internal'),
|
|
('M:not-valid', 1700000400, 'invalid'), ('Y:100', 1700000500, 'system')])
|
|
with contextlib.closing(sqlite3.connect(folder / 'user.db')) as db, db:
|
|
db.execute('CREATE TABLE user_table(id TEXT,name TEXT)')
|
|
db.executemany('INSERT INTO user_table VALUES(?,?)', [(ACCOUNT, '合成账号'), ('10001','同名助理'), ('10002','同名助理')])
|
|
db.execute('CREATE TABLE external_user_relation_v3(user_id TEXT,status INTEGER,add_customer_time INTEGER,stranger_type INTEGER,remarks TEXT,real_remarks TEXT)')
|
|
db.executemany('INSERT INTO external_user_relation_v3 VALUES(?,?,?,?,?,?)', [
|
|
('10001',2049,1700000000,0,'',''), ('10002',2049,1700000000,0,'','')])
|
|
db.execute('CREATE TABLE wechat_contactV1(wxid TEXT,name TEXT)')
|
|
db.execute("INSERT INTO wechat_contactV1 VALUES('wxid_unrelated','不属于我的客户')")
|
|
with contextlib.closing(sqlite3.connect(folder / 'session.db')) as db, db:
|
|
db.execute('CREATE TABLE conversation_table(id TEXT,name TEXT)')
|
|
|
|
def listing(self, *args, **kwargs):
|
|
return contacts.list_recipients(ACCOUNT, *args, cache_roots=[self.root], **kwargs)
|
|
|
|
def test_lists_relation_customers_with_s_and_m_chats_without_message_content(self):
|
|
result = self.listing()
|
|
self.assertTrue(result['ready'])
|
|
self.assertEqual({row['id'] for row in result['items']}, {RECIPIENT_ID,'M:10002'})
|
|
self.assertNotIn('PRIVATE_BODY_NEVER_LOADED', json.dumps(result))
|
|
self.assertEqual(result['account_name'], '合成账号')
|
|
|
|
def test_duplicate_names_remain_separate_and_identifiable(self):
|
|
result = self.listing('同名助理')
|
|
self.assertEqual(result['total'], 2)
|
|
self.assertEqual(len({row['identityLabel'] for row in result['items']}), 2)
|
|
|
|
def test_search_and_pagination_are_independent_of_message_preview(self):
|
|
first = self.listing(limit=1)
|
|
second = self.listing(limit=1, offset=1)
|
|
self.assertTrue(first['has_more']); self.assertFalse(second['has_more'])
|
|
self.assertNotEqual(first['items'][0]['id'], second['items'][0]['id'])
|
|
self.assertEqual(self.listing('PRIVATE_BODY')['total'], 0)
|
|
|
|
def test_missing_account_does_not_fall_back_to_another_account(self):
|
|
self.context.return_value = {**ACTIVE, 'account_id': OTHER}
|
|
result = contacts.list_recipients(OTHER, cache_roots=[self.root])
|
|
self.assertFalse(result['ready']); self.assertEqual(result['items'], [])
|
|
self.assertEqual(result['account_id'], OTHER)
|
|
|
|
def test_account_mismatch_never_reads_the_old_accounts_database(self):
|
|
self.context.return_value = {**ACTIVE, 'account_id': OTHER}
|
|
with mock.patch.object(contacts, '_contacts') as read:
|
|
result = self.listing()
|
|
self.assertFalse(result['ready']); read.assert_not_called()
|
|
|
|
def test_recipient_validation_uses_id_and_rechecks_identity(self):
|
|
result = contacts.validate_recipient(ACCOUNT, RECIPIENT_ID, cache_roots=[self.root])
|
|
self.assertTrue(result['ok']); self.assertEqual(result['recipient']['id'], RECIPIENT_ID)
|
|
self.assertGreaterEqual(self.context.call_count, 2)
|
|
|
|
def test_account_switch_during_validation_rejects_selection(self):
|
|
self.context.side_effect = [ACTIVE, {**ACTIVE, 'account_id': OTHER}]
|
|
result = contacts.validate_recipient(ACCOUNT, RECIPIENT_ID, cache_roots=[self.root])
|
|
self.assertFalse(result['ok']); self.assertIsNone(result['recipient'])
|
|
|
|
def test_group_internal_or_unknown_recipient_cannot_be_saved(self):
|
|
for identity in ('R:100', 'S:1_2', '同名助理', 'M:99999', 'M:../../x'):
|
|
with self.subTest(identity=identity):
|
|
self.assertFalse(contacts.validate_recipient(ACCOUNT, identity, cache_roots=[self.root])['ok'])
|
|
|
|
def test_queries_are_read_only_and_do_not_initialize_or_modify_databases(self):
|
|
before = {path.name: path.read_bytes() for path in self.folder.glob('*.db')}
|
|
self.listing(); contacts.validate_recipient(ACCOUNT, RECIPIENT_ID, cache_roots=[self.root])
|
|
self.assertEqual(before, {path.name:path.read_bytes() for path in self.folder.glob('*.db')})
|
|
with contextlib.closing(contacts._open(self.folder / 'message.db')) as db:
|
|
with self.assertRaises(sqlite3.OperationalError):
|
|
db.execute("INSERT INTO message_table VALUES('M:42',0,'forbidden')")
|
|
|
|
def test_preview_is_static_and_does_not_load_real_customer_data(self):
|
|
with mock.patch.object(contacts, '_contacts') as read, mock.patch.object(contacts, 'active_context') as current:
|
|
preview = contacts.notification_preview('合成账号', RECIPIENT)
|
|
self.assertIn('示例客户', preview); self.assertIn('不会发送', preview)
|
|
read.assert_not_called(); current.assert_not_called()
|
|
|
|
|
|
class ImmediateThread:
|
|
def __init__(self, *, target, **_kwargs): self.target=target
|
|
def start(self): self.target()
|
|
|
|
|
|
def host_fixture():
|
|
host = SimpleNamespace(runtime_settings={'review_assistant_accounts': {}},
|
|
_review_assistant_state=dict(ACTIVE), _review_assistant_busy=False,
|
|
_review_assistant_available=lambda:(True,''), _schedule_console_push=mock.Mock(),
|
|
_push_console_state=mock.Mock(), append_log=mock.Mock())
|
|
for name in ('_review_assistant_console_state','_refresh_review_assistant','_save_review_assistant','_review_assistant_updated'):
|
|
setattr(host,name,MethodType(getattr(qt.MainWindow,name),host))
|
|
host.reviewAssistantUpdated=SimpleNamespace(emit=host._review_assistant_updated)
|
|
def persist(settings): host.runtime_settings.update(settings); return True
|
|
host.save_runtime_settings=mock.Mock(side_effect=persist)
|
|
return host
|
|
|
|
|
|
class ReminderSettingsTest(TestCase):
|
|
def setUp(self):
|
|
self.host=host_fixture()
|
|
self.thread=mock.patch.object(qt.threading,'Thread',ImmediateThread)
|
|
self.thread.start(); self.addCleanup(self.thread.stop)
|
|
self.validation=mock.patch.object(contacts,'validate_recipient',return_value={
|
|
'ok':True,'account_id':ACCOUNT,'account_name':'合成账号','recipient':RECIPIENT})
|
|
self.validate=self.validation.start(); self.addCleanup(self.validation.stop)
|
|
|
|
def test_default_disabled_and_cannot_enable_without_recipient(self):
|
|
self.assertFalse(self.host._review_assistant_console_state()['enabled'])
|
|
result=self.host._save_review_assistant(ACCOUNT,enabled=True)
|
|
self.assertFalse(result['ok']); self.validate.assert_not_called()
|
|
self.host.save_runtime_settings.assert_not_called()
|
|
|
|
def test_selection_persists_exact_verified_recipient_and_stays_off(self):
|
|
self.host._save_review_assistant(ACCOUNT,recipient={**RECIPIENT,'name':'forged name'})
|
|
config=self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]
|
|
self.assertEqual(config['recipient_conv_id'],RECIPIENT_ID)
|
|
self.assertEqual(config['recipient_name'],RECIPIENT['name'])
|
|
self.assertFalse(config['enabled'])
|
|
|
|
def test_enable_revalidates_target_and_does_not_change_other_accounts(self):
|
|
self.host.runtime_settings['review_assistant_accounts']={
|
|
ACCOUNT:{'enabled':False,'recipient_conv_id':RECIPIENT_ID}, OTHER:{'enabled':False,'recipient_conv_id':'M:20002'}}
|
|
self.host._save_review_assistant(ACCOUNT,enabled=True)
|
|
self.validate.assert_called_once_with(ACCOUNT,RECIPIENT_ID)
|
|
self.assertTrue(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]['enabled'])
|
|
self.assertEqual(self.host.runtime_settings['review_assistant_accounts'][OTHER]['recipient_conv_id'],'M:20002')
|
|
|
|
def test_s_recipient_round_trip_preserves_raw_id_and_customer_kind(self):
|
|
raw = f'S:10001_{ACCOUNT}'
|
|
verified = {**RECIPIENT, 'id': raw, 'peer_id': '10001'}
|
|
self.validate.return_value = {'ok': True, 'account_id': ACCOUNT, 'recipient': verified}
|
|
self.host._save_review_assistant(ACCOUNT, recipient=verified)
|
|
self.validate.assert_called_once_with(ACCOUNT, raw)
|
|
saved = self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]
|
|
self.assertEqual(saved['recipient_conv_id'], raw)
|
|
self.assertEqual(saved['recipient_kind'], '企业微信客户')
|
|
state = self.host._review_assistant_console_state()
|
|
self.assertEqual(state['accountId'], ACCOUNT)
|
|
self.assertEqual(state['recipient']['id'], raw)
|
|
self.assertIn('10001', state['recipient']['label'])
|
|
self.assertNotIn(ACCOUNT, state['recipient']['label'])
|
|
|
|
def test_rejected_legacy_m_recipient_is_not_silently_replaced_by_s_chat(self):
|
|
original = {'enabled': False, 'recipient_conv_id': 'M:10001', 'recipient_name': '旧助理'}
|
|
self.host.runtime_settings['review_assistant_accounts'][ACCOUNT] = dict(original)
|
|
self.validate.return_value = {'ok': False, 'reason': '旧会话不属于当前我的客户', 'recipient': None}
|
|
self.host._save_review_assistant(ACCOUNT, enabled=True)
|
|
self.validate.assert_called_once_with(ACCOUNT, 'M:10001')
|
|
self.host.save_runtime_settings.assert_not_called()
|
|
self.assertEqual(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT], original)
|
|
|
|
def test_replacing_an_enabled_contact_requires_explicit_reenable(self):
|
|
self.host.runtime_settings['review_assistant_accounts']={ACCOUNT:{'enabled':True,'recipient_conv_id':'M:10002'}}
|
|
self.host._save_review_assistant(ACCOUNT,recipient=RECIPIENT)
|
|
self.assertFalse(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]['enabled'])
|
|
|
|
def test_expected_account_mismatch_or_validation_failure_never_saves(self):
|
|
self.assertFalse(self.host._save_review_assistant(OTHER,recipient=RECIPIENT)['ok'])
|
|
self.validate.return_value={'ok':False,'reason':'账号已变化','recipient':None}
|
|
self.host._save_review_assistant(ACCOUNT,recipient=RECIPIENT)
|
|
self.host.save_runtime_settings.assert_not_called()
|
|
self.assertFalse(self.host._review_assistant_state['ready'])
|
|
|
|
def test_explicit_disable_only_needs_current_account_not_deleted_contact(self):
|
|
self.host.runtime_settings['review_assistant_accounts']={ACCOUNT:{'enabled':True,'recipient_conv_id':'M:99999'}}
|
|
with mock.patch.object(contacts,'active_context',return_value=ACTIVE):
|
|
self.host._save_review_assistant(ACCOUNT,enabled=False)
|
|
self.validate.assert_not_called()
|
|
self.assertFalse(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]['enabled'])
|
|
|
|
def test_successful_reselection_clears_matching_warning_without_enabling(self):
|
|
self.host.runtime_settings['review_assistant_accounts'][ACCOUNT] = {
|
|
'enabled': False, 'recipient_conv_id': RECIPIENT_ID, 'recipient_name': RECIPIENT['name']}
|
|
self.host._review_assistant_state['recipient_check'] = {
|
|
'id': RECIPIENT_ID, 'ok': False, 'reason': '旧核验状态不可用'}
|
|
self.assertTrue(self.host._review_assistant_console_state()['recipientWarning'])
|
|
self.host._save_review_assistant(ACCOUNT, recipient=RECIPIENT)
|
|
self.assertEqual(self.host._review_assistant_console_state()['recipientWarning'], '')
|
|
self.assertFalse(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]['enabled'])
|
|
self.assertEqual(self.host.runtime_settings['review_assistant_accounts'][ACCOUNT]['recipient_conv_id'], RECIPIENT_ID)
|
|
|
|
def test_persist_failure_does_not_claim_config_is_enabled(self):
|
|
self.host.save_runtime_settings=mock.Mock(return_value=False)
|
|
self.host._save_review_assistant(ACCOUNT,recipient=RECIPIENT)
|
|
self.assertEqual(self.host.runtime_settings['review_assistant_accounts'],{})
|
|
self.assertIn('保存失败',self.host._review_assistant_state['message'])
|
|
|
|
def test_snapshot_does_not_probe_scan_or_query_databases(self):
|
|
with mock.patch.object(contacts,'active_context') as active, mock.patch.object(contacts,'_contacts') as read:
|
|
for _ in range(10): self.host._review_assistant_console_state()
|
|
active.assert_not_called(); read.assert_not_called()
|
|
|
|
def test_stale_async_reply_and_shutdown_do_not_save(self):
|
|
self.host._review_assistant_serial=2
|
|
self.host._review_assistant_updated({'_serial':1,'ok':True})
|
|
self.host._exit_requested=True
|
|
self.host._review_assistant_updated({'_serial':2,'ok':True})
|
|
self.host.save_runtime_settings.assert_not_called()
|
|
|
|
def test_runtime_save_preserves_other_account_mapping_and_rolls_back_failure(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
settings={**qt.MainWindow._runtime_defaults(),'review_assistant_accounts':{ACCOUNT:{'enabled':True,'recipient_conv_id':RECIPIENT_ID}}}
|
|
host=SimpleNamespace(runtime_settings=settings, _runtime_defaults=qt.MainWindow._runtime_defaults,
|
|
settings_page=SimpleNamespace(values=lambda:{}), _thread=None,
|
|
_broadcast_save_result=mock.Mock(), append_log=mock.Mock(), _sync_auto_launch=mock.Mock())
|
|
path=Path(folder)/'app_settings.json'
|
|
with mock.patch.object(qt,'APP_SETTINGS_FILE',path):
|
|
self.assertTrue(qt.MainWindow.save_runtime_settings(host,{'poll_interval':3}))
|
|
self.assertTrue(json.loads(path.read_text(encoding='utf-8'))['review_assistant_accounts'][ACCOUNT]['enabled'])
|
|
previous=host.runtime_settings
|
|
with mock.patch.object(qt.os,'replace',side_effect=OSError('test')):
|
|
self.assertFalse(qt.MainWindow.save_runtime_settings(host,{'review_assistant_accounts':{}}))
|
|
self.assertIs(host.runtime_settings,previous)
|
|
|
|
|
|
class ReminderWebTest(TestCase):
|
|
@classmethod
|
|
def setUpClass(cls): cls.app=QApplication.instance() or QApplication([])
|
|
|
|
def test_setting_panel_disables_until_verified_and_uses_exact_account_for_toggle(self):
|
|
owner=QMainWindow();owner._push_console_state=mock.Mock()
|
|
shell=qt.ConsoleShell(owner);owner.setCentralWidget(shell);owner.resize(1440,1000);owner.show()
|
|
self.addCleanup(owner.deleteLater);self.addCleanup(owner.close)
|
|
if not shell.page_ready:
|
|
results=[];loop=QEventLoop()
|
|
def ready(ok):results.append(ok);loop.quit()
|
|
shell.loadFinished.connect(ready);QTimer.singleShot(10000,loop.quit);loop.exec()
|
|
shell.loadFinished.disconnect(ready);self.assertEqual(results,[True])
|
|
def js(script):
|
|
values=[];loop=QEventLoop()
|
|
def done(value):values.append(value);loop.quit()
|
|
shell.page().runJavaScript(script,done);QTimer.singleShot(5000,loop.quit);loop.exec()
|
|
self.assertEqual(len(values),1);return values[0]
|
|
state={'view':'automation','ready':True,'demo':False,'automation':{'transport':'visual','reviewAssistant':{
|
|
'supported':False,'ready':False,'enabled':False,'reason':'当前版本不支持协议审核提醒'}}}
|
|
js('window.applyState('+json.dumps(state)+');render("automation");')
|
|
self.assertTrue(js('document.querySelector("[data-action=review-assistant-toggle]").disabled'))
|
|
self.assertTrue(js('document.querySelector("[data-action=review-assistant-choose]").disabled'))
|
|
self.assertIn('当前版本不支持',js('document.body.textContent'))
|
|
state['automation']['reviewAssistant']=self.make_state()
|
|
js('window.applyState('+json.dumps(state)+');render("automation");')
|
|
self.assertFalse(js('document.querySelector("[data-action=review-assistant-toggle]").disabled'))
|
|
self.assertEqual(js('document.querySelectorAll("img[data-injected]").length'),0)
|
|
js('window.captured=[]; window.qtBridge={setReviewAssistantEnabled:(payload,cb)=>{window.captured.push(JSON.parse(payload)); cb(JSON.stringify({ok:true,message:"test"}));}}; document.querySelector("[data-action=review-assistant-toggle]").click();')
|
|
captured=json.loads(js('JSON.stringify(window.captured)'))
|
|
self.assertEqual(captured,[{'expected_account':ACCOUNT,'enabled':True}])
|
|
self.assertNotIn('测试发送',js('document.querySelector("#main").textContent'))
|
|
# Let the real offscreen compositor paint after HTML and viewport changes.
|
|
js('window.fit(); document.querySelector("details").open=true;')
|
|
loop=QEventLoop(); QTimer.singleShot(700,loop.quit); loop.exec()
|
|
self.assertGreaterEqual(js('innerWidth'),1000)
|
|
self.assertGreater(js('document.querySelector("#stage").getBoundingClientRect().width'),1000)
|
|
suffix='production' if hasattr(qt,'PROTOCOL') else 'source'
|
|
self.assertTrue(shell.grab().save('C:/kefu/deploy/customer-picker-20260918/assistant-settings-'+suffix+'.png'))
|
|
|
|
def make_state(self):
|
|
return {'supported':True,'ready':True,'enabled':False,'busy':False,'accountId':ACCOUNT,'accountName':'合成账号',
|
|
'recipient':{'id':RECIPIENT_ID,'name':'同名助理 <img data-injected src=x>','label':'编号10001'},
|
|
'notification':{'message':'已发送提醒，等待人工直接回复客户'},
|
|
'preview':contacts.notification_preview('合成账号')}
|
|
|
|
|
|
class ReminderIdentityTest(TestCase):
|
|
def test_active_identity_only_uses_native_readonly_scope(self):
|
|
events=[]
|
|
native=ModuleType('wecom_native_sender')
|
|
@contextlib.contextmanager
|
|
def scope():
|
|
events.append('readonly-enter')
|
|
yield
|
|
events.append('readonly-exit')
|
|
def discover():
|
|
events.append('discover')
|
|
return {'accountId':ACCOUNT,'pid':123}
|
|
native.discover=discover;native.readonly_build_validation_scope=scope
|
|
with mock.patch.dict(sys.modules,{'wecom_native_sender':native}):
|
|
result=contacts.active_context()
|
|
self.assertTrue(result['ready']);self.assertEqual(result['account_id'],ACCOUNT)
|
|
self.assertEqual(events,['readonly-enter','discover','readonly-exit'])
|
|
|
|
def test_native_unavailable_is_clear_and_does_not_use_another_account(self):
|
|
with mock.patch.dict(sys.modules,{'wecom_native_sender':None}):
|
|
result=contacts.active_context()
|
|
self.assertFalse(result['ready']);self.assertEqual(result['account_id'],'')
|
|
self.assertIn('不支持',result['reason'])
|
|
|
|
|
|
class ReminderPickerTest(TestCase):
|
|
@classmethod
|
|
def setUpClass(cls): cls.app=QApplication.instance() or QApplication([])
|
|
|
|
def setUp(self):
|
|
# Exercise real Qt widgets but never schedule an unmocked native probe.
|
|
with mock.patch.object(qt.QTimer,'singleShot'):
|
|
self.dialog=qt.ReviewAssistantPicker(ACCOUNT)
|
|
self.addCleanup(self.dialog.deleteLater)
|
|
self.addCleanup(self.dialog.reject)
|
|
self.threads=mock.patch.object(qt.threading,'Thread',ImmediateThread)
|
|
self.threads.start();self.addCleanup(self.threads.stop)
|
|
self.listing=mock.patch.object(contacts,'list_recipients',return_value={
|
|
**ACTIVE,'items':[RECIPIENT,{**RECIPIENT,'id':'M:10002','identityLabel':'编号10002'}],
|
|
'total':2,'offset':0,'has_more':False})
|
|
self.list_mock=self.listing.start();self.addCleanup(self.listing.stop)
|
|
|
|
def test_same_name_rows_keep_exact_identity_and_validate_selected_one(self):
|
|
self.dialog._load()
|
|
self.assertEqual(self.dialog.contacts.count(),2)
|
|
self.dialog.contacts.setCurrentRow(1)
|
|
verified={**RECIPIENT,'id':'M:10002'}
|
|
with mock.patch.object(contacts,'validate_recipient',return_value={
|
|
'ok':True,'account_id':ACCOUNT,'recipient':verified}) as validate:
|
|
self.dialog._choose()
|
|
validate.assert_called_once_with(ACCOUNT,'M:10002')
|
|
self.assertEqual(self.dialog.result(),QDialog.DialogCode.Accepted)
|
|
self.assertEqual(self.dialog.recipient['id'],'M:10002')
|
|
|
|
def test_stale_list_and_late_validation_after_cancel_are_ignored(self):
|
|
self.dialog._serial=5
|
|
self.dialog._loaded({**ACTIVE,'_serial':4,'items':[RECIPIENT]})
|
|
self.assertEqual(self.dialog.contacts.count(),0)
|
|
self.dialog.reject()
|
|
self.dialog._validated({'ok':True,'account_id':ACCOUNT,'recipient':RECIPIENT})
|
|
self.assertIsNone(self.dialog.recipient)
|
|
self.assertEqual(self.dialog.result(),QDialog.DialogCode.Rejected)
|
|
|
|
def test_wrong_account_cannot_load_or_accept_and_retry_stays_available(self):
|
|
self.dialog._serial=1
|
|
self.dialog._loaded({**ACTIVE,'account_id':OTHER,'_serial':1,'items':[RECIPIENT]})
|
|
self.assertEqual(self.dialog.contacts.count(),0)
|
|
self.dialog._load();self.dialog.contacts.setCurrentRow(0)
|
|
with mock.patch.object(contacts,'validate_recipient',return_value={
|
|
'ok':False,'reason':'当前账号已变化','recipient':None}):
|
|
self.dialog._choose()
|
|
self.assertIsNone(self.dialog.recipient)
|
|
self.assertTrue(self.dialog.choose.isEnabled())
|
|
self.assertIn('账号已变化',self.dialog.status.text())
|
|
|
|
|
|
def test_unmapped_contact_is_visible_but_cannot_be_accepted(self):
|
|
reason = '此客户尚无可核验的单聊会话，请刷新我的客户和本机缓存。'
|
|
unavailable = {**RECIPIENT, 'id': 'customer:123456789012345', 'peer_id': '123456789012345', 'kind': '企业微信客户',
|
|
'identityLabel': '企业微信客户 · 客户编号 123456789012345', 'selectable': False,
|
|
'unavailableReason': reason, 'lastTime': ''}
|
|
self.list_mock.return_value = {**ACTIVE, 'items': [unavailable, RECIPIENT],
|
|
'total': 2, 'selectable_total': 1, 'contact_total': 1}
|
|
self.dialog._load()
|
|
item = self.dialog.contacts.item(0)
|
|
self.assertNotIn('123456789012345', item.text())
|
|
self.assertNotIn(reason, item.text())
|
|
self.assertTrue(item.flags() & qt.Qt.ItemFlag.ItemIsSelectable)
|
|
self.assertTrue(item.flags() & qt.Qt.ItemFlag.ItemIsEnabled)
|
|
self.assertIn('(1)', self.dialog.filter_buttons['sendable'].text())
|
|
self.assertIn('(1)', self.dialog.filter_buttons['directory'].text())
|
|
# Unlinked entries can be highlighted and inspected but cannot be saved.
|
|
self.dialog.contacts.setCurrentItem(item)
|
|
self.dialog._selection_changed(item)
|
|
self.assertIn('123456789012345', self.dialog.details_identity.text())
|
|
self.assertIn(reason, self.dialog.details_reason.text())
|
|
self.assertTrue(item.isSelected())
|
|
self.assertFalse(self.dialog.choose.isEnabled())
|
|
with mock.patch.object(contacts, 'validate_recipient') as validate:
|
|
self.dialog._choose()
|
|
validate.assert_not_called()
|
|
self.assertIsNone(self.dialog.recipient)
|
|
self.assertNotEqual(self.dialog.result(), QDialog.DialogCode.Accepted)
|
|
|
|
def test_refresh_rereads_cached_list_and_preserves_query_from_first_page(self):
|
|
self.dialog._load()
|
|
self.dialog.query.setText('备注或联系编号')
|
|
self.dialog._offset = 50
|
|
self.list_mock.reset_mock()
|
|
self.dialog.refresh.click()
|
|
self.list_mock.assert_called_once_with(ACCOUNT, '备注或联系编号', 50, 0, status='all', order='recent')
|
|
self.assertEqual(self.dialog._offset, 0)
|
|
self.assertFalse(self.dialog._search_timer.isActive())
|
|
self.assertTrue(self.dialog.refresh.isEnabled())
|
|
self.assertIn('备注', self.dialog.query.placeholderText())
|
|
self.assertIn('编号', self.dialog.query.placeholderText())
|
|
|
|
def test_refresh_remains_available_after_account_or_cache_error(self):
|
|
self.list_mock.return_value = {**ACTIVE, 'ready': False, 'reason': '请刷新消息库', 'items': []}
|
|
self.dialog._load()
|
|
self.assertTrue(self.dialog.refresh.isEnabled())
|
|
self.assertFalse(self.dialog.choose.isEnabled())
|
|
self.list_mock.return_value = {**ACTIVE, 'items': [RECIPIENT], 'total': 1}
|
|
self.dialog.refresh.click()
|
|
self.assertEqual(self.dialog.contacts.count(), 1)
|
|
self.assertFalse(self.dialog.choose.isEnabled())
|
|
|
|
def test_refresh_cannot_race_pending_recipient_validation(self):
|
|
self.dialog._load()
|
|
self.dialog.contacts.setCurrentRow(0)
|
|
queued = []
|
|
class DeferredThread:
|
|
def __init__(self, *, target, **kwargs): queued.append(target)
|
|
def start(self): pass
|
|
with mock.patch.object(qt.threading, 'Thread', DeferredThread):
|
|
self.dialog._choose()
|
|
self.assertFalse(self.dialog.refresh.isEnabled())
|
|
serial = self.dialog._serial
|
|
self.list_mock.reset_mock()
|
|
self.dialog._load(reset=True)
|
|
self.dialog.refresh.click()
|
|
self.list_mock.assert_not_called()
|
|
self.assertEqual(self.dialog._serial, serial)
|
|
with mock.patch.object(contacts, 'validate_recipient', return_value={
|
|
'ok': False, 'reason': '请重新核对联系人'}):
|
|
queued[0]()
|
|
self.assertTrue(self.dialog.refresh.isEnabled())
|
|
self.assertTrue(self.dialog.choose.isEnabled())
|
|
|
|
def test_stale_validation_result_cannot_accept_after_a_newer_request(self):
|
|
self.dialog._serial = 8
|
|
self.dialog._validated({'_serial': 7, 'ok': True, 'account_id': ACCOUNT, 'recipient': RECIPIENT})
|
|
self.assertIsNone(self.dialog.recipient)
|
|
self.assertNotEqual(self.dialog.result(), QDialog.DialogCode.Accepted)
|
|
|
|
|
|
|
|
class ReminderRefreshTest(TestCase):
|
|
def test_refresh_warns_for_invalid_saved_m_without_rewriting_or_disabling_it(self):
|
|
import review_assistant
|
|
host = host_fixture()
|
|
old = {'enabled': True, 'recipient_conv_id': 'M:10001', 'recipient_name': '旧助理'}
|
|
host.runtime_settings['review_assistant_accounts'][ACCOUNT] = dict(old)
|
|
with mock.patch.object(qt.threading, 'Thread', ImmediateThread), \
|
|
mock.patch.object(contacts, 'active_context', return_value=ACTIVE), \
|
|
mock.patch.object(contacts, 'list_recipients', return_value={**ACTIVE, 'items': []}), \
|
|
mock.patch.object(contacts, 'validate_recipient', return_value={
|
|
'ok': False, 'reason': '已保存联系人不在我的客户中', 'recipient': None}) as validate, \
|
|
mock.patch.object(review_assistant, 'notification_summary', return_value={}):
|
|
host._refresh_review_assistant()
|
|
validate.assert_called_once_with(ACCOUNT, 'M:10001')
|
|
state = host._review_assistant_console_state()
|
|
self.assertIn('不在我的客户', state['recipientWarning'])
|
|
self.assertEqual(state['recipient']['id'], 'M:10001')
|
|
self.assertEqual(host.runtime_settings['review_assistant_accounts'][ACCOUNT], old)
|
|
host.save_runtime_settings.assert_not_called()
|
|
|
|
def test_warning_for_old_target_is_not_applied_to_new_target_or_other_account(self):
|
|
host = host_fixture()
|
|
host.runtime_settings['review_assistant_accounts'] = {
|
|
ACCOUNT: {'enabled': False, 'recipient_conv_id': RECIPIENT_ID},
|
|
OTHER: {'enabled': False, 'recipient_conv_id': f'S:{OTHER}_10001'}}
|
|
host._review_assistant_state['recipient_check'] = {'id': 'M:10001', 'ok': False, 'reason': '旧目标无效'}
|
|
self.assertEqual(host._review_assistant_console_state()['recipientWarning'], '')
|
|
host._review_assistant_state['account_id'] = OTHER
|
|
self.assertEqual(host._review_assistant_console_state()['recipientWarning'], '')
|
|
self.assertEqual(host._review_assistant_console_state()['recipient']['id'], f'S:{OTHER}_10001')
|
|
|
|
def test_only_explicit_refresh_reads_notification_summary(self):
|
|
import review_assistant
|
|
host=host_fixture()
|
|
with mock.patch.object(qt.threading,'Thread',ImmediateThread), \
|
|
mock.patch.object(contacts,'active_context',return_value=ACTIVE), \
|
|
mock.patch.object(contacts,'list_recipients',return_value={**ACTIVE,'items':[]}), \
|
|
mock.patch.object(review_assistant,'notification_summary',return_value={
|
|
'status':'sent','message':'已发送提醒','updated_at':123}) as summary:
|
|
host._refresh_review_assistant()
|
|
summary.assert_called_once_with(qt.SCRIPT_DIR,ACCOUNT)
|
|
for _ in range(5):
|
|
state=host._review_assistant_console_state()
|
|
self.assertEqual(summary.call_count,1)
|
|
self.assertEqual(state['notification']['status'],'sent')
|