250 lines
12 KiB
Python
250 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""审核后发送的审核范围:每条都审核 / 按原规则(医疗助理人工回复后该会话恢复自动)。
|
|
|
|
管理后台「客户端配置」统一下发 AI_REVIEW_EVERY_REPLY;本机可以跟随(默认)或单独设为
|
|
every / rules。只用内存数据。wechat_bot / protocol_engine 的相关方法按 AST 从源码单独编译,
|
|
不导入整个模块(导入会初始化运行目录,源码运行时会改写源码目录);请在临时副本里运行。
|
|
"""
|
|
|
|
import ast
|
|
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
from types import ModuleType, SimpleNamespace
|
|
from unittest import mock
|
|
|
|
import review_assistant
|
|
import review_assistant_contacts
|
|
import review_policy
|
|
|
|
ROOT = Path(__file__).resolve().parent
|
|
|
|
|
|
def _compile(path, class_name, names):
|
|
tree = ast.parse((ROOT / path).read_text(encoding="utf-8-sig"), filename=str(ROOT / path))
|
|
original = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == class_name)
|
|
methods = [node for node in original.body if isinstance(node, ast.FunctionDef) and node.name in names]
|
|
missing = set(names) - {node.name for node in methods}
|
|
if missing:
|
|
raise AssertionError(f"{path} 缺少方法:{missing!r}")
|
|
assigns = [node for node in tree.body if isinstance(node, ast.Assign)
|
|
and any(isinstance(t, ast.Name) and t.id in {"SEND_MODE_AUTO", "SEND_MODE_REVIEW"} for t in node.targets)]
|
|
cls = ast.ClassDef(name=class_name, bases=[], keywords=[], body=methods, decorator_list=[])
|
|
module = ast.Module(body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0),
|
|
*assigns, cls], type_ignores=[])
|
|
namespace = {}
|
|
exec(compile(ast.fix_missing_locations(module), str(ROOT / path), "exec"), namespace)
|
|
return namespace[class_name]
|
|
|
|
|
|
def _admin_config(every):
|
|
"""后台下发到本机 ai_config 的那一项。"""
|
|
config = ModuleType("ai_config")
|
|
config.AI_REVIEW_RULES = []
|
|
config.AI_REVIEW_EVERY_REPLY = every
|
|
return mock.patch.dict(sys.modules, {"ai_config": config})
|
|
|
|
|
|
class _Assistant:
|
|
def __init__(self, resumed=False, pending=False):
|
|
self._resumed, self._pending = resumed, pending
|
|
|
|
def has_pending(self, conv_id):
|
|
return self._pending
|
|
|
|
def resumed(self, conv_id):
|
|
return self._resumed
|
|
|
|
|
|
class ScopeRuleTest(unittest.TestCase):
|
|
"""本机选了就按本机,否则跟随后台;只有明确的 True 才算每条都审核。"""
|
|
|
|
def test_normalize(self):
|
|
for value, expected in (("follow", "follow"), ("every", "every"), ("rules", "rules"), (" EVERY ", "every"),
|
|
(True, "every"), (False, "follow"), (None, "follow"), ("", "follow"), ("x", "follow")):
|
|
with self.subTest(value=value):
|
|
self.assertEqual(review_policy.normalize_review_scope(value), expected)
|
|
|
|
def test_effective_value(self):
|
|
cases = [("follow", True, True), ("follow", False, False), ("follow", None, False), ("follow", "true", False),
|
|
("every", False, True), ("every", True, True), ("rules", True, False), ("rules", False, False),
|
|
("bogus", True, True)]
|
|
for scope, admin, expected in cases:
|
|
with self.subTest(scope=scope, admin=admin):
|
|
self.assertIs(review_policy.review_every_reply(scope, admin), expected)
|
|
|
|
|
|
class VisualDecisionTest(unittest.TestCase):
|
|
"""视觉链路发送闸:blanket = 审核后发送 且(每条都审核 或 会话没有恢复自动)。"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.bot_class = _compile("wechat_bot.py", "WeChatBot",
|
|
{"_reply_review_decision", "_review_mode_enabled", "_review_every_reply"})
|
|
|
|
def decide(self, send_mode, scope, admin, resumed, pending=False):
|
|
bot = self.bot_class.__new__(self.bot_class)
|
|
bot.send_mode = send_mode
|
|
bot.review_scope = scope
|
|
assistant = _Assistant(resumed=resumed, pending=pending)
|
|
bot._get_review_assistant = lambda verify=False: assistant
|
|
bot._review_assistant_context = lambda state: {"conv_id": "conv-1", "account": "acct"}
|
|
bot._reply_needs_review = lambda state, customer, reply: (False, "")
|
|
with _admin_config(admin):
|
|
return bot._reply_review_decision({}, "客户原话", "回复")
|
|
|
|
def test_follow_uses_the_admin_setting(self):
|
|
self.assertTrue(self.decide("review", "follow", True, resumed=True)[0])
|
|
self.assertFalse(self.decide("review", "follow", False, resumed=True)[0])
|
|
|
|
def test_local_choice_overrides_the_admin_setting(self):
|
|
self.assertTrue(self.decide("review", "every", False, resumed=True)[0])
|
|
self.assertFalse(self.decide("review", "rules", True, resumed=True)[0])
|
|
|
|
def test_review_mode_without_resume_always_holds(self):
|
|
for scope in ("follow", "every", "rules"):
|
|
for admin in (False, True):
|
|
with self.subTest(scope=scope, admin=admin):
|
|
self.assertTrue(self.decide("review", scope, admin, resumed=False)[0])
|
|
|
|
def test_auto_mode_ignores_the_scope(self):
|
|
for scope in ("follow", "every", "rules"):
|
|
with self.subTest(scope=scope):
|
|
self.assertFalse(self.decide("auto", scope, True, resumed=True)[0])
|
|
self.assertFalse(self.decide("auto", scope, True, resumed=False)[0])
|
|
|
|
def test_pending_review_still_holds(self):
|
|
blanket, held, reason = self.decide("review", "rules", False, resumed=True, pending=True)
|
|
self.assertTrue(blanket) # has_pending 时 resumed 不成立
|
|
self.assertTrue(held)
|
|
self.assertIn("待审核", reason)
|
|
|
|
def test_missing_local_scope_follows_the_admin_setting(self):
|
|
bot = self.bot_class.__new__(self.bot_class)
|
|
bot.send_mode = "review"
|
|
with _admin_config(True):
|
|
self.assertTrue(bot._review_every_reply())
|
|
bot.send_mode = "auto"
|
|
with _admin_config(True):
|
|
self.assertFalse(bot._review_every_reply())
|
|
|
|
|
|
class ProtocolDecisionTest(unittest.TestCase):
|
|
"""协议链路 _needs_review:同一条规则。"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.bot_class = _compile("protocol_engine.py", "ProtocolBot", {"_needs_review", "_review_every_reply"})
|
|
|
|
def decide(self, send_mode, scope, admin, resumed):
|
|
bot = self.bot_class.__new__(self.bot_class)
|
|
bot.send_mode = send_mode
|
|
bot.review_scope = scope
|
|
bot._assistant_pending = lambda state: False
|
|
bot._assistant_call = lambda name, *args, **kwargs: resumed if name == "resumed" else None
|
|
with _admin_config(admin):
|
|
return bot._needs_review({"conv_id": "conv-1", "staged_user_text": "在吗", "reply_text": "在的"})
|
|
|
|
def test_follow_uses_the_admin_setting(self):
|
|
review, reason = self.decide("review", "follow", True, resumed=True)
|
|
self.assertTrue(review)
|
|
self.assertIn("通过并发送", reason)
|
|
self.assertEqual(self.decide("review", "follow", False, resumed=True), (False, ""))
|
|
|
|
def test_local_choice_overrides_the_admin_setting(self):
|
|
self.assertTrue(self.decide("review", "every", False, resumed=True)[0])
|
|
self.assertEqual(self.decide("review", "rules", True, resumed=True), (False, ""))
|
|
|
|
def test_auto_mode_ignores_the_scope(self):
|
|
self.assertEqual(self.decide("auto", "every", True, resumed=False), (False, ""))
|
|
|
|
|
|
class NotificationWordingTest(unittest.TestCase):
|
|
"""发给医疗助理的提醒、界面状态和提醒示例都要说清人工回复后会不会恢复自动。"""
|
|
|
|
def episode(self, **extra):
|
|
return {"id": "0123456789abcdef", "account": "acct", "name": "客户", "conv": "conv-1",
|
|
"created": 0, "handling_kind": "review", "reason": "人工审核", "context": "客户:在吗",
|
|
"draft": "在的", **extra}
|
|
|
|
def test_rules_scope_keeps_the_resume_sentence(self):
|
|
text = review_assistant.notification_text(self.episode())
|
|
self.assertIn("后续新消息恢复自动回复", text)
|
|
self.assertEqual(text, review_assistant.notification_text(self.episode(resume_after_manual=True)))
|
|
|
|
def test_every_reply_scope_says_review_continues(self):
|
|
text = review_assistant.notification_text(self.episode(resume_after_manual=False))
|
|
self.assertNotIn("恢复自动回复", text)
|
|
self.assertIn("每条都审核", text)
|
|
|
|
def test_preview_follows_the_scope(self):
|
|
self.assertIn("后续自动回复仍逐条风控", review_assistant_contacts.notification_preview("acct"))
|
|
preview = review_assistant_contacts.notification_preview("acct", every_reply=True)
|
|
self.assertIn("每条都审核", preview)
|
|
self.assertNotIn("后续自动回复", preview)
|
|
|
|
|
|
class SettingsPlumbingTest(unittest.TestCase):
|
|
"""本机设置归一化、运行中切换、后台下发项,以及待发任务落盘带上这次用的审核范围。"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
tree = ast.parse((ROOT / "gui_runtime.py").read_text(encoding="utf-8-sig"))
|
|
func = next(node for node in tree.body if isinstance(node, ast.FunctionDef)
|
|
and node.name == "normalize_review_scope")
|
|
thread = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "BotThread")
|
|
setter = next(node for node in thread.body if isinstance(node, ast.FunctionDef)
|
|
and node.name == "set_review_scope")
|
|
cls_node = ast.ClassDef(name="BotThread", bases=[], keywords=[], body=[setter], decorator_list=[])
|
|
namespace = {}
|
|
exec(compile(ast.fix_missing_locations(ast.Module(body=[func, cls_node], type_ignores=[])), "gui_runtime", "exec"),
|
|
namespace)
|
|
cls.normalize = staticmethod(namespace["normalize_review_scope"])
|
|
cls.thread_class = namespace["BotThread"]
|
|
|
|
def test_gui_runtime_uses_the_shared_normalization(self):
|
|
for value in ("follow", "every", "rules", True, False, None, "bogus"):
|
|
with self.subTest(value=value):
|
|
self.assertEqual(self.normalize(value), review_policy.normalize_review_scope(value))
|
|
|
|
def test_running_thread_updates_its_bot(self):
|
|
thread = self.thread_class.__new__(self.thread_class)
|
|
thread.bot = SimpleNamespace(review_scope="follow")
|
|
thread.set_review_scope("every")
|
|
self.assertEqual(thread.review_scope, "every")
|
|
self.assertEqual(thread.bot.review_scope, "every")
|
|
thread.bot = None
|
|
thread.set_review_scope("bogus")
|
|
self.assertEqual(thread.review_scope, "follow")
|
|
|
|
def test_admin_setting_is_synced_into_ai_config(self):
|
|
tree = ast.parse((ROOT / "ai_config.py").read_text(encoding="utf-8-sig"))
|
|
keys = next(node.value for node in tree.body if isinstance(node, ast.Assign)
|
|
and any(isinstance(t, ast.Name) and t.id == "CONFIGURABLE_KEYS" for t in node.targets))
|
|
self.assertIn("AI_REVIEW_EVERY_REPLY", [elt.value for elt in keys.elts])
|
|
default = next(node for node in tree.body if isinstance(node, ast.AnnAssign)
|
|
and getattr(node.target, "id", "") == "AI_REVIEW_EVERY_REPLY")
|
|
self.assertIs(default.value.value, False)
|
|
|
|
def test_pending_state_persists_the_scope(self):
|
|
tree = ast.parse((ROOT / "wechat_bot.py").read_text(encoding="utf-8-sig"))
|
|
bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot")
|
|
for name in ("_persist_pending_replies_unlocked", "_load_pending_replies"):
|
|
method = next(node for node in bot.body if isinstance(node, ast.FunctionDef) and node.name == name)
|
|
keys = {node.value for node in ast.walk(method) if isinstance(node, ast.Constant) and isinstance(node.value, str)}
|
|
with self.subTest(method=name):
|
|
self.assertIn("review_every_reply", keys)
|
|
|
|
def test_gate_records_the_scope_used_for_the_hold(self):
|
|
tree = ast.parse((ROOT / "wechat_bot.py").read_text(encoding="utf-8-sig"))
|
|
bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot")
|
|
gate = next(node for node in bot.body if isinstance(node, ast.FunctionDef) and node.name == "_send_reply_inner")
|
|
assigned = [node for node in ast.walk(gate) if isinstance(node, ast.Assign)
|
|
and any(isinstance(t, ast.Subscript) and isinstance(t.slice, ast.Constant)
|
|
and t.slice.value == "review_every_reply" for t in node.targets)]
|
|
self.assertTrue(assigned, "发送闸没有记录这次审核用的范围")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|