Files
xieyi-weixin-/test_review_scope.py
T
2026-09-30 19:30:58 +08:00

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()