# -*- coding: utf-8 -*- """自动回复短句净化、验证页识别与发送节流测试。""" import io import json import os import tempfile import threading import time from collections import deque from contextlib import ExitStack, redirect_stdout from unittest import SkipTest, TestCase, main, mock import numpy as np from ai_chat import ( _dify_query_from_chat, _history_messages, _humanize, _finalize_vision_reply, _parse_ui_guard_decision, _parse_wecom_layout_decision, _repair_obvious_mismatch, _user_turn, classify_wecom_ui, call_ai_vision, detect_media_types, latest_customer_message, latest_customer_turn, media_archive_text, media_text_content, safe_media_reply, VISION_NO_INCOMING, VISION_VOICE_NEEDS_TEXT, _vision_chat_prompt, ) import wechat_bot from conversation_store import ConversationStore from test_support import queue_log_redirect from registration_store import RegistrationStore, process_registration_reply from wechat_bot import ( CHAT_BOTTOM_FROM_BOTTOM, INPUT_Y_FROM_BOTTOM, WeChatBot, composer_divider_matches, find_blocking_modal_close, find_wx_hwnd, infer_composer_top, infer_chat_pane_right, infer_navigation_width, infer_session_list_width, looks_like_modal_scrim, looks_like_security_verification, fit_window_inside_work_area, window_spans_multiple_displays, window_looks_rendered, ) class ReplyStyleTest(TestCase): CHAT_SAMPLE = ( "高兴亮 7/28 15:54:54\n" "抱歉刚才说得太复杂了，就是让您多休息，别太累着\n" "一个小迷糊@微信@微信联系人 7/28 15:55:08\n" "你多大了" ) def test_removes_markdown_canned_closing_and_extra_questions(self): reply = _humanize( "### 回复\n" "1. 您好，先别太着急，今天血糖大概多少？\n" "2. 是空腹还是餐后测的？\n" "3. 希望以上建议能帮到您。" ) self.assertNotIn("###", reply) self.assertNotIn("希望以上建议能帮到您", reply) self.assertNotIn("您好", reply) self.assertEqual(reply.count("？") + reply.count("?"), 1) self.assertLessEqual(len(reply), 100) def test_emergency_reply_keeps_three_short_sentences(self): reply = _humanize("先别慌。现在立即拨打120。不要自己开车。之后再联系我。") self.assertIn("120", reply) self.assertIn("不要自己开车", reply) self.assertNotIn("之后再联系我", reply) def test_extracts_the_real_latest_customer_sentence(self): self.assertEqual(latest_customer_message(self.CHAT_SAMPLE), "你多大了") def test_merges_five_consecutive_customer_bubbles_as_one_turn(self): chat = ( "贴心管家 7/29 10:00:00\n您想问哪方面呢\n" "客户甲 7/29 10:00:03\n我这两天总口渴\n" "客户甲 7/29 10:00:07\n晚上也睡不好\n" "客户甲 7/29 10:00:11\n空腹是8.6\n" "客户甲 7/29 10:00:16\n饭后是12\n" "客户甲 7/29 10:00:20\n应该怎么办" ) merged = latest_customer_turn(chat) self.assertEqual( merged, "我这两天总口渴\n晚上也睡不好\n空腹是8.6\n饭后是12\n应该怎么办", ) self.assertNotIn("您想问哪方面", merged) prompt = _user_turn(chat)["content"] self.assertIn("客户本轮连续消息｜统一回答对象", prompt) self.assertIn("我这两天总口渴\n晚上也睡不好", prompt) def test_old_raw_history_does_not_relabel_staff_reply_as_customer(self): with mock.patch("ai_chat.ai_config.AI_CONTEXT_ENABLED", True): messages = _history_messages([ {"role": "user", "content": self.CHAT_SAMPLE}, {"role": "assistant", "content": "四十来岁啦。"}, ]) self.assertEqual(messages[0]["content"], "你多大了") def test_age_question_mismatch_is_repaired(self): reply = _repair_obvious_mismatch( "您别管我多大，把身体养好才是正经事。", self.CHAT_SAMPLE, ) self.assertEqual(reply, "四十来岁啦，怎么突然问这个？") def test_casual_tired_message_is_not_redirected_to_hospital(self): reply = _repair_obvious_mismatch( "血糖波动会让人乏力，建议去医院让医生调整方案。", "一个小迷糊 7/28 14:55:43\n好困啊", ) self.assertEqual(reply, "困了就先眯一会儿，别硬撑着。") def test_low_information_customer_turn_never_guesses_phone_mistouch(self): chat = ( "一个小迷糊@微信@微信联系人 7/30 11:58:01\n！\n" "一个小迷糊@微信@微信联系人 7/30 11:58:08\n啊\n" "一个小迷糊@微信@微信联系人 7/30 11:58:15\n啊" ) reply = _repair_obvious_mismatch( "这是怎么啦，是不是不小心碰到手机了？", chat, ) self.assertEqual(reply, "我在呢，您慢慢说，怎么啦？") self.assertIn("【本轮信息很少】", _dify_query_from_chat(chat, history=[])) def test_dify_query_marks_latest_message_as_only_target(self): query = _dify_query_from_chat(self.CHAT_SAMPLE, history=[]) self.assertIn("【本轮是日常闲聊】", query) self.assertIn("【客户本轮连续消息｜统一回答对象】\n你多大了", query) def test_clarification_does_not_ask_customer_to_repeat(self): reply = _repair_obvious_mismatch( "刚才没听清，您能再说一遍吗？", "测试客户 7/28 15:54:46\n什么", history=[ {"role": "user", "content": "好困啊"}, {"role": "assistant", "content": "困了就先眯一会儿，别硬撑着。"}, ], ) self.assertEqual(reply, "我是说，困了就先眯一会儿，别硬撑着。") class MediaReplyTest(TestCase): def test_media_markers_are_detected_but_unicode_emoji_stays_text(self): self.assertEqual(detect_media_types("[图片]，这个处方天数改成15天吧"), {"image"}) self.assertEqual(detect_media_types("[动画表情]"), {"sticker"}) self.assertEqual(detect_media_types("[表情包]"), {"sticker"}) self.assertEqual(detect_media_types("[语音]"), {"voice"}) self.assertEqual(detect_media_types("[语音 5秒]"), {"voice"}) self.assertEqual(detect_media_types("[语音消息 00:05]"), {"voice"}) self.assertEqual(detect_media_types("今天挺开心的😊"), set()) self.assertEqual( media_text_content("客户甲 10:00:00\n[图片]，这个处方天数改成15天吧"), "这个处方天数改成15天吧", ) def test_voice_duration_is_not_mistaken_for_transcription(self): self.assertEqual( media_text_content("客户甲 10:00:00\n[语音] 00:05"), "", ) self.assertEqual( media_text_content("客户甲 10:00:00\n[语音]\n00:05\n明天下午可以吗"), "明天下午可以吗", ) self.assertEqual( media_text_content("客户甲 10:00:00\n先说\n语音 5秒\n再说"), "先说\n再说", ) archived = media_archive_text( "客户甲 10:00:00\n[语音]\n00:05\n明天下午可以吗", media_types={"voice"}, ) self.assertIn("可见文字/转写", archived) self.assertNotIn("未取得转写", archived) def test_explicit_empty_media_set_does_not_rescan_old_history(self): full = ( "客户甲 09:00:00\n[语音]\n" "贴心管家 09:00:05\n麻烦打字说一下\n" "客户甲 10:00:00\n今天挺开心的😊" ) prompt = _vision_chat_prompt(full, media_types=set()) self.assertIn("【剪贴板检测到的媒体】剪贴板未识别具体类型", prompt) archived = media_archive_text(full, media_types=set()) self.assertEqual(archived, "今天挺开心的😊") self.assertNotIn("语音", archived) def test_mixed_vision_without_contains_voice_is_rejected(self): raw = ( '{"has_new_customer_message":true,"media_type":"mixed",' '"voice_transcribed":false,"reply":"我看到了"}' ) self.assertEqual( _finalize_vision_reply( raw, chat_text="客户甲 10:00:00\n帮我看看", media_types=set(), ), "", ) def test_vision_parser_ignores_analysis_json_before_protocol_result(self): raw = ( '{"analysis":"先确认最末端左侧气泡"}\n' '{"has_new_customer_message":true,"media_type":"image",' '"media_types":["image"],"contains_voice":false,' '"voice_transcribed":false,"reply":"图片收到了，您想重点看哪一处？"}' ) reply = _finalize_vision_reply(raw, chat_text="", media_types=set()) self.assertEqual(reply, "图片收到了，您想重点看哪一处？") self.assertEqual(set(reply.media_types), {"image"}) def test_vision_parser_uses_last_protocol_object(self): raw = ( '{"has_new_customer_message":false,"media_type":"unknown",' '"reply":""}\n' '{"has_new_customer_message":true,"media_type":"sticker",' '"media_types":["sticker"],"contains_voice":false,' '"voice_transcribed":false,"reply":"看到您发的表情啦。"}' ) reply = _finalize_vision_reply(raw, chat_text="", media_types=set()) self.assertEqual(reply, "看到您发的表情啦。") self.assertEqual(set(reply.media_types), {"sticker"}) def test_nested_diagnostic_object_cannot_override_protocol_result(self): raw = ( '{"has_new_customer_message":true,"media_type":"image",' '"media_types":["image"],"contains_voice":false,' '"voice_transcribed":false,"reply":"图片收到了。",' '"diagnostic":{"has_new_customer_message":false}}' ) reply = _finalize_vision_reply(raw, chat_text="", media_types=set()) self.assertEqual(reply, "图片收到了。") self.assertEqual(set(reply.media_types), {"image"}) def test_vision_protocol_conflicts_fail_closed(self): conflicting_types = ( '{"has_new_customer_message":true,"media_type":"image",' '"media_types":["sticker"],"contains_voice":false,' '"voice_transcribed":false,"reply":"我已经看懂了"}' ) self.assertEqual( _finalize_vision_reply( conflicting_types, chat_text="客户甲 10:00:00\n[图片]", media_types={"image"}, ), "", ) invalid_boolean = ( '{"has_new_customer_message":"maybe","media_type":"image",' '"media_types":["image"],"contains_voice":false,' '"voice_transcribed":false,"reply":"不应发送"}' ) self.assertEqual( _finalize_vision_reply(invalid_boolean, chat_text="", media_types=set()), "", ) impossible_transcript = ( '{"has_new_customer_message":true,"media_type":"text",' '"media_types":[],"contains_voice":false,' '"voice_transcribed":true,"reply":"不应发送"}' ) self.assertEqual( _finalize_vision_reply(impossible_transcript, chat_text="有文字", media_types=set()), "", ) def test_voice_safety_result_preserves_other_mixed_media_types(self): raw = ( '{"has_new_customer_message":true,"media_type":"mixed",' '"media_types":["voice","image"],"contains_voice":true,' '"voice_transcribed":false,"reply":"不应采用模型对语音的猜测"}' ) reply = _finalize_vision_reply( raw, chat_text="客户甲 10:00:00\n[语音] 00:05\n[图片]", media_types={"voice", "image"}, ) self.assertEqual(reply, VISION_VOICE_NEEDS_TEXT) self.assertEqual(set(reply.media_types), {"voice", "image"}) def test_voice_control_labels_are_not_treated_as_transcription(self): for marker in ( "语音消息 00:05", "音频：5秒", "audio 5s", "语音 5′", ): self.assertEqual(detect_media_types(marker), {"voice"}) self.assertEqual( media_text_content("客户甲 10:00:00\n[语音] 00:05\n转文字"), "", ) self.assertEqual( media_text_content("客户甲 10:00:00\n[语音]\n识别中…"), "", ) self.assertEqual( media_text_content("客户甲 10:00:00\n[语音]\n正在转文字…"), "", ) def test_repeated_identical_media_blocks_remain_a_nonempty_delta(self): previous = ["客户甲 10:00:00", "[图片]"] current = previous + ["客户甲 10:00:00", "[图片]"] self.assertEqual(WeChatBot._delta_lines(previous, current), previous) def test_animated_sticker_frames_keep_one_layout_signature(self): first = np.full((360, 480, 4), 245, dtype=np.uint8) first[:, :, 3] = 255 second = first.copy() # 透明画布里的动画主体水平移动；原始像素和可见包围盒都会变化。 yy, xx = np.ogrid[:360, :480] first[((yy - 135) ** 2 + (xx - 85) ** 2) < 45 ** 2, :3] = (40, 90, 220) second[((yy - 135) ** 2 + (xx - 105) ** 2) < 45 ** 2, :3] = (30, 200, 80) self.assertEqual( WeChatBot._chat_layout_signature(first), WeChatBot._chat_layout_signature(second), ) with_new_bubble = second.copy() with_new_bubble[270:315, 300:455, :3] = 180 self.assertNotEqual( WeChatBot._chat_layout_signature(second), WeChatBot._chat_layout_signature(with_new_bubble), ) def test_selected_row_preview_detects_same_layout_media_replacement(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.session_item_h = 64 old = np.full((96, 230, 4), 245, dtype=np.uint8) old[:, :, 3] = 255 changed_preview = old.copy() # 第二行预览发生变化，代表新图片/表情到达；聊天区即使滚动后布局相同， # 这个独立信号也必须变化。 old[40:45, 82:116, :3] = 25 changed_preview[47:52, 126:168, :3] = 25 # 第一行右侧时间自行变化不能触发回复。 time_only = old.copy() time_only[40:55, 182:220, :3] = 25 self.assertNotEqual( bot._session_row_activity_signature(old, 32), bot._session_row_activity_signature(changed_preview, 32), ) self.assertEqual( bot._session_row_activity_signature(old, 32), bot._session_row_activity_signature(time_only, 32), ) def test_selected_row_preview_is_stable_when_row_moves(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.session_item_h = 64 image = np.full((128, 230, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 image[40:45, 82:116, :3] = 25 image[72:77, 82:116, :3] = 25 self.assertEqual( bot._session_row_activity_signature(image, 32), bot._session_row_activity_signature(image, 64), ) def test_selected_row_detection_flicker_reuses_same_session_cache(self): bot = WeChatBot.__new__(WeChatBot) fp = b"f" * 40 bot.hwnd = 100 bot.scale = 1.0 bot.session_item_h = 64 bot._list_x = bot._list_y = 0 bot._list_w = 230 bot._list_h = 96 bot._chat_rel_x = 230 bot._chat_rel_y = 0 bot._chat_rel_w = 480 bot._chat_rel_h = 360 bot._active_session_fp = fp bot._row_activity_cache = {} session_list = np.full((96, 230, 4), 245, dtype=np.uint8) session_list[:, :, 3] = 255 session_list[40:45, 82:116, :3] = 25 chat = np.full((360, 480, 4), 245, dtype=np.uint8) chat[:, :, 3] = 255 chat[120:180, 40:120, :3] = 80 full = np.full((360, 710, 4), 245, dtype=np.uint8) full[:, :, 3] = 255 full[:96, :230] = session_list full[:, 230:710] = chat bot._capture_full_window = mock.Mock(return_value=full) bot.detect_selected_row = mock.Mock(side_effect=[32, -1]) bot._session_fingerprint = mock.Mock(return_value=fp) first = bot._chat_surface_signature() second = bot._chat_surface_signature() self.assertEqual(first, second) def test_openai_vision_receives_current_text_history_and_chat_screenshot(self): response = mock.Mock() response.raise_for_status = mock.Mock() response.json.return_value = { "choices": [{"message": {"content": ( '{"has_new_customer_message":true,"media_type":"image",' '"voice_transcribed":false,"reply":"我看到了，先帮您核对具体信息。"}' )}}] } history = [ {"role": "user", "content": "上次发过处方"}, {"role": "assistant", "content": "我看到了"}, ] with ( mock.patch("ai_chat.ai_config.AI_PROVIDER_TYPE", "openai"), mock.patch("ai_chat.ai_config.AI_API_BASE", "https://api.example/v1"), mock.patch("ai_chat.ai_config.AI_API_KEY", "secret"), mock.patch("ai_chat.ai_config.AI_MODEL", "vision-model"), mock.patch("ai_chat.ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.requests.post", return_value=response) as post, ): reply = call_ai_vision( b"png-data", history=history, chat_text="客户甲 10:00:00\n[图片]，这个处方天数改成15天吧", media_types={"image"}, ) self.assertIn("先帮您核对", reply) payload = post.call_args.kwargs["json"] self.assertEqual(payload["messages"][1]["content"], "上次发过处方") prompt = payload["messages"][-1]["content"][0]["text"] self.assertIn("这个处方天数改成15天吧", prompt) self.assertIn("不得仅凭图片声称已经修改、提交", prompt) image_url = payload["messages"][-1]["content"][1]["image_url"]["url"] self.assertTrue(image_url.startswith("data:image/png;base64,")) def test_unknown_visual_result_cannot_guess_untranscribed_voice(self): voice_result = ( '{"has_new_customer_message":true,"media_type":"voice",' '"voice_transcribed":false,"reply":"我猜你在问血糖"}' ) self.assertEqual( _finalize_vision_reply(voice_result, chat_text="", media_types=set()), VISION_VOICE_NEEDS_TEXT, ) self.assertEqual( _finalize_vision_reply("我猜你在问血糖", chat_text="", media_types=set()), "", ) self.assertEqual( _finalize_vision_reply( '{"has_new_customer_message":false,"media_type":"unknown",' '"voice_transcribed":false,"reply":"不应发送"}', chat_text="", media_types=set(), ), VISION_NO_INCOMING, ) self.assertEqual( _finalize_vision_reply( '{"has_new_customer_message":true,"media_type":"mixed",' '"voice_transcribed":false,"reply":"按我猜的语音回复"}', chat_text="客户甲 10:00:00\n[语音]\n还有一张图", media_types={"voice", "image"}, ), VISION_VOICE_NEEDS_TEXT, ) def test_non_json_vision_text_is_never_treated_as_new_message_proof(self): self.assertEqual( _finalize_vision_reply( "我看到了，已经帮您改好。", chat_text="客户甲 10:00:00\n[图片]，改成15天", media_types={"image"}, ), "", ) def test_dify_vision_query_contains_current_text_and_archive_history(self): history = [ {"role": "user", "content": "上次的问题"}, {"role": "assistant", "content": "上次的回复"}, ] with ( mock.patch("ai_chat.ai_config.AI_PROVIDER_TYPE", "dify"), mock.patch("ai_chat.ai_config.AI_API_BASE", "https://dify.example/v1"), mock.patch("ai_chat.ai_config.AI_CONTEXT_ENABLED", True), mock.patch( "ai_chat._call_dify_with_image", return_value=( '{"has_new_customer_message":true,"media_type":"image",' '"voice_transcribed":false,"reply":"看到了，您想让我重点核对哪一处？"}' ), ) as call, ): call_ai_vision( b"png-data", history=history, chat_text="客户甲 10:00:00\n[图片]，请看这里", media_types={"image"}, ) query = call.call_args.args[0] self.assertIn("上次的问题", query) self.assertIn("请看这里", query) self.assertIn("媒体识别规则", query) self.assertEqual(call.call_args.args[1], b"png-data") def test_image_and_text_batch_automatically_uses_mixed_vision(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media001" batch = "客户甲 10:00:00\n[图片]，这个处方天数改成15天吧" bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value=batch) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value="我看到了，先核对后再告诉您。") as get_reply, mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("我看到了，先核对后再告诉您。", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp) self.assertEqual(reply, "我看到了，先核对后再告诉您。") bot.capture_chat_area.assert_called_once() call_text.assert_not_called() kwargs = get_reply.call_args.kwargs self.assertEqual(kwargs["chat_text"], batch) self.assertEqual(kwargs["image_bytes"], b"chat-png") self.assertTrue(kwargs["force_vision"]) self.assertEqual(kwargs["media_types"], {"image"}) self.assertEqual( bot._stage_exchange.call_args.args[1], "（客户发来图片）\n这个处方天数改成15天吧", ) def test_explicit_image_uses_safe_reply_when_chat_capture_fails(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media003" batch = "客户甲 10:00:00\n[图片]" expected = safe_media_reply({"image"}) bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = {fp.hex(): {"batch_ready": True}} bot.extract_context_for = mock.Mock(return_value=batch) bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot.capture_chat_area = mock.Mock(side_effect=RuntimeError("capture failed")) bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply") as get_reply, mock.patch( "registration_store.process_registration_reply", return_value=(expected, None), ), mock.patch("wechat_bot.time.sleep"), ): self.assertEqual(bot._generate_ai_reply(fp), expected) get_reply.assert_not_called() def test_pure_voice_never_asks_a_model_to_guess_audio(self): bot = WeChatBot.__new__(WeChatBot) fp = b"voice001" bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value="客户甲 10:00:00\n[语音]") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() expected = safe_media_reply({"voice"}) with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply") as get_reply, mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=(expected, None), ), mock.patch("wechat_bot.time.sleep"), ): self.assertEqual(bot._generate_ai_reply(fp), expected) bot.capture_chat_area.assert_not_called() get_reply.assert_not_called() call_text.assert_not_called() self.assertEqual( bot._stage_exchange.call_args.args[1], "（客户发来语音，未取得转写）", ) def test_voice_plus_visible_text_answers_text_without_guessing_audio(self): bot = WeChatBot.__new__(WeChatBot) fp = b"voice002" batch = "客户甲 10:00:00\n[语音] 00:05\n明天下午能挂号吗" bot.store = mock.Mock() bot.store.has_record.return_value = True bot.extract_context_for = mock.Mock(return_value=batch) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_VOICE_NEEDS_TEXT), mock.patch("ai_chat.call_ai_text", return_value="明天下午可以，我先帮您登记。") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("明天下午可以，我先帮您登记。", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp) self.assertEqual(reply, "明天下午可以，我先帮您登记。") self.assertIn("不得猜测语音内容", call_text.call_args.args[0]) self.assertIn("明天下午能挂号吗", call_text.call_args.args[0]) def test_confirmed_unread_caption_without_placeholder_still_uses_vision(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media004" batch = "客户甲 10:00:00\n帮我看看这个" bot.store = mock.Mock() bot.store.has_record.return_value = True bot.extract_context_for = mock.Mock(return_value=batch) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value="我看到了，您想重点确认哪一处？") as get_reply, mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("我看到了，您想重点确认哪一处？", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, "我看到了，您想重点确认哪一处？") bot.capture_chat_area.assert_called_once() get_reply.assert_called_once() call_text.assert_not_called() def test_visual_no_incoming_conflict_never_sends_caption_without_media_warning(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media007" batch = "客户甲 10:00:00\n帮我看看这个" bot.store = mock.Mock() bot.store.has_record.return_value = True bot.extract_context_for = mock.Mock(return_value=batch) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_NO_INCOMING), mock.patch("ai_chat.call_ai_text", return_value="您想让我重点看哪一处？") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("您想让我重点看哪一处？", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, "您想让我重点看哪一处？") self.assertIn("不得猜测媒体内容", call_text.call_args.args[0]) def test_second_visual_no_incoming_keeps_confirmed_unread_and_uses_safe_media_reply(self): bot = WeChatBot.__new__(WeChatBot) fp = b"flat0001" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": True, "requires_visual_proof": True, "visual_rejection_count": 1, } } bot._pending_reply_path = "" bot._pending_exchanges = {} bot._flat_visual_proof_fps = {fp.hex()} bot._flat_rejected_session_fps = set() bot.extract_context_for = mock.Mock(return_value="") bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._ensure_session_archive_key = mock.Mock() bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() safe_question = "收到消息，请把重点打字说一下。" with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_NO_INCOMING), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "ai_chat.safe_media_reply", return_value=safe_question, ) as safe_reply, mock.patch( "registration_store.process_registration_reply", return_value=(safe_question, None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, safe_question) state = bot._pending_reply_sessions[fp.hex()] self.assertTrue(state["confirmed_unread"]) self.assertEqual(state["visual_rejection_count"], 1) self.assertFalse(state["requires_visual_proof"]) self.assertNotIn(fp.hex(), bot._flat_rejected_session_fps) self.assertIn(fp.hex(), bot._flat_verified_session_fps) call_text.assert_not_called() safe_reply.assert_called_once_with() def test_second_visual_no_incoming_keeps_reliable_text_pending_and_uses_safe_text(self): bot = WeChatBot.__new__(WeChatBot) fp = b"flat0004" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": False, "requires_visual_proof": True, "visual_rejection_count": 1, } } bot._pending_reply_path = "" bot._pending_exchanges = {} bot._flat_visual_proof_fps = {fp.hex()} bot._flat_rejected_session_fps = set() bot.extract_context_for = mock.Mock( return_value="客户甲 10:00:00\n帮我看看这个" ) bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._ensure_session_archive_key = mock.Mock() bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() safe_text_reply = "您想让我重点看哪一处？" with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_NO_INCOMING), mock.patch( "ai_chat.call_ai_text", return_value=safe_text_reply, ) as call_text, mock.patch("ai_chat.safe_media_reply") as safe_reply, mock.patch( "registration_store.process_registration_reply", return_value=(safe_text_reply, None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply( fp, force_media_check=True, confirmed_unread=False, reliable_text_pending=True, ) self.assertEqual(reply, safe_text_reply) state = bot._pending_reply_sessions[fp.hex()] self.assertEqual(state["visual_rejection_count"], 1) self.assertFalse(state["requires_visual_proof"]) self.assertNotIn(fp.hex(), bot._flat_rejected_session_fps) self.assertIn(fp.hex(), bot._flat_verified_session_fps) self.assertIn("只回答本轮可见文字", call_text.call_args.args[0]) safe_reply.assert_not_called() def test_second_visual_no_incoming_clears_unconfirmed_unreliable_candidate(self): bot = WeChatBot.__new__(WeChatBot) fp = b"flat0005" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": False, "requires_visual_proof": True, "visual_rejection_count": 1, } } bot._pending_reply_path = "" bot._pending_exchanges = {} bot._flat_visual_proof_fps = {fp.hex()} bot._flat_rejected_session_fps = set() bot.extract_context_for = mock.Mock(return_value="") bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._ensure_session_archive_key = mock.Mock() bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_NO_INCOMING), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch("ai_chat.safe_media_reply") as safe_reply, mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply( fp, confirmed_unread=False, reliable_text_pending=False, ) self.assertIsNone(reply) self.assertNotIn(fp.hex(), bot._pending_reply_sessions) self.assertIn(fp.hex(), bot._flat_rejected_session_fps) self.assertNotIn(fp.hex(), bot._flat_visual_proof_fps) call_text.assert_not_called() safe_reply.assert_not_called() bot._stage_exchange.assert_not_called() def test_unknown_flat_avatar_vision_failure_never_uses_generic_fallback(self): bot = WeChatBot.__new__(WeChatBot) fp = b"flat0002" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": True, "requires_visual_proof": True, } } bot._pending_reply_path = "" bot._pending_exchanges = {} bot.extract_context_for = mock.Mock(return_value="") bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._ensure_session_archive_key = mock.Mock() bot.capture_chat_area = mock.Mock(return_value=b"chat-png") with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=""), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch("ai_chat.safe_media_reply") as safe_reply, mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertIsNone(reply) self.assertIn(fp.hex(), bot._pending_reply_sessions) call_text.assert_not_called() safe_reply.assert_not_called() def test_explicit_customer_block_proves_flat_avatar_is_real_chat(self): bot = WeChatBot.__new__(WeChatBot) fp = b"flat0003" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": True, "requires_visual_proof": True, } } bot._pending_reply_path = "" bot._pending_exchanges = {} bot._flat_visual_proof_fps = {fp.hex()} bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot.extract_context_for = mock.Mock( return_value="客户甲 7/29 10:00:00\n请问今天下午能挂号吗" ) bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._ensure_session_archive_key = mock.Mock() bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=VISION_NO_INCOMING), mock.patch("ai_chat.call_ai_text", return_value="可以，我先帮您登记。"), mock.patch( "registration_store.process_registration_reply", return_value=("可以，我先帮您登记。", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, "可以，我先帮您登记。") self.assertIn(fp.hex(), bot._flat_verified_session_fps) self.assertNotIn(fp.hex(), bot._flat_rejected_session_fps) self.assertFalse( bot._pending_reply_sessions[fp.hex()]["requires_visual_proof"] ) def test_selected_caption_falls_back_to_safe_text_when_vision_fails(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media006" batch = "客户甲 10:00:00\n帮我看看这个" bot.store = mock.Mock() bot.store.has_record.return_value = True bot.extract_context_for = mock.Mock(return_value=batch) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=""), mock.patch("ai_chat.call_ai_text", return_value="您想让我重点看哪一处？") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("您想让我重点看哪一处？", None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply( fp, force_media_check=True, reliable_text_pending=True, ) self.assertEqual(reply, "您想让我重点看哪一处？") self.assertIn("不得推测媒体内容", call_text.call_args.args[0]) def test_screenshot_only_image_type_is_preserved_in_archive(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media005" bot.store = mock.Mock() bot.store.has_record.return_value = False bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value="") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() visual_reply = _finalize_vision_reply( '{"has_new_customer_message":true,"media_type":"image",' '"media_types":["image"],"contains_voice":false,' '"voice_transcribed":false,"reply":"图片我看到了，您想重点确认哪一处？"}', chat_text="", media_types=set(), ) with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value=visual_reply), mock.patch( "registration_store.process_registration_reply", return_value=(str(visual_reply), None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, "图片我看到了，您想重点确认哪一处？") self.assertEqual(bot._stage_exchange.call_args.args[1], "（客户发来图片）") def test_screenshot_only_voice_type_is_preserved_for_safe_archive(self): bot = WeChatBot.__new__(WeChatBot) fp = b"voice003" bot.store = mock.Mock() bot.store.has_record.return_value = False bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value="") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() visual_reply = _finalize_vision_reply( '{"has_new_customer_message":true,"media_type":"voice",' '"media_types":["voice"],"contains_voice":true,' '"voice_transcribed":false,"reply":""}', chat_text="", media_types=set(), ) with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value=visual_reply), mock.patch( "registration_store.process_registration_reply", side_effect=lambda **kwargs: (kwargs["reply_text"], None), ), mock.patch("wechat_bot.time.sleep"), ): reply = bot._generate_ai_reply(fp, confirmed_unread=True) self.assertEqual(reply, safe_media_reply({"voice"})) self.assertEqual( bot._stage_exchange.call_args.args[1], "（客户发来语音，未取得转写）", ) def test_unchanged_clipboard_text_is_not_replied_to_again(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.has_record.return_value = True bot.store.last_lines.return_value = ["客户甲 10:00:00", "上一轮问题"] same = "客户甲 10:00:00\n上一轮问题" self.assertEqual(bot.extract_context_for(b"same0001", pre_text=same), "") bot.store.set_last_lines.assert_called_once() def test_empty_clipboard_surface_change_enters_media_fallback(self): bot = WeChatBot.__new__(WeChatBot) fp = b"media002" bot._capture_full_window = mock.Mock(return_value=np.zeros((20, 20, 4), dtype=np.uint8)) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=-1) bot._chat_identity_signature = mock.Mock(return_value=b"identity") bot._chat_surface_signature = mock.Mock(return_value=b"new-surface") bot._selected_tracking_initialized = True bot._active_session_fp = fp bot._active_identity_signature = b"identity" bot._active_chat_signature = b"old-surface" bot._pending_reply_sessions = {} bot._activate_wx = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock(side_effect=["", ""]) bot._wait_for_message_batch = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="请把重点打字说一下。") bot.send_reply = mock.Mock(return_value=True) bot._run_ai_page_guard = mock.Mock(return_value=False) with mock.patch("wechat_bot.time.sleep"): self.assertTrue(bot._check_selected_session(np.zeros((20, 20, 4), dtype=np.uint8))) bot._run_ai_page_guard.assert_not_called() self.assertTrue(bot._generate_ai_reply.call_args.kwargs["force_media_check"]) def test_visual_failure_does_not_reply_to_stale_clipboard_text(self): bot = WeChatBot.__new__(WeChatBot) fp = b"stale001" bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value="") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value=""), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch("ai_chat.safe_media_reply") as safe_reply, mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply( fp, chat_text="贴心管家 10:00:00\n上一轮已经发出的回复", force_media_check=True, ) self.assertIsNone(result) call_text.assert_not_called() safe_reply.assert_not_called() def test_unconfirmed_empty_clipboard_never_sends_generic_media_reply(self): bot = WeChatBot.__new__(WeChatBot) bot.extract_context_for = mock.Mock(return_value="") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=""), mock.patch("ai_chat.safe_media_reply") as safe_reply, mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply( b"empty001", chat_text="", force_media_check=True, confirmed_unread=False, ) self.assertIsNone(result) safe_reply.assert_not_called() def test_confirmed_unread_empty_clipboard_uses_type_agnostic_safe_reply(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.has_record.return_value = True bot.extract_context_for = mock.Mock(return_value="") bot.capture_chat_area = mock.Mock(return_value=b"chat-png") with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_chat.get_ai_reply", return_value=""), mock.patch( "ai_chat.safe_media_reply", return_value="收到消息，请把重点打字说一下。", ) as safe_reply, mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply( b"empty002", chat_text="", force_media_check=True, confirmed_unread=True, ) self.assertEqual(result, "收到消息，请把重点打字说一下") safe_reply.assert_called_once_with() def test_first_record_visual_failure_never_answers_visible_old_text(self): bot = WeChatBot.__new__(WeChatBot) fp = b"first001" visible_old_text = "贴心管家 09:59:00\n上一轮已经发出的回复" bot.store = mock.Mock() bot.store.has_record.return_value = False bot.get_session_history = mock.Mock(return_value=[]) bot.extract_context_for = mock.Mock(return_value=visible_old_text) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value="") as get_reply, mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "ai_chat.safe_media_reply", return_value="收到消息，请把重点再发一句。", ) as safe_reply, mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply( fp, chat_text=visible_old_text, confirmed_unread=True, ) self.assertEqual(result, "收到消息，请把重点再发一句") get_reply.assert_called_once() call_text.assert_not_called() safe_reply.assert_called_once_with() def test_first_record_explicit_customer_text_is_still_visually_confirmed(self): bot = WeChatBot.__new__(WeChatBot) fp = b"first002" customer_text = "客户甲 7/29 10:00:00\n请问今天下午能挂号吗" bot.store = mock.Mock() bot.store.has_record.return_value = False bot.extract_context_for = mock.Mock(return_value=customer_text) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", False), mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch( "ai_chat.get_ai_reply", return_value="可以的，我先帮您登记需求。", ) as get_reply, mock.patch( "registration_store.process_registration_reply", return_value=("可以的，我先帮您登记需求。", None), ), mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply( fp, confirmed_unread=True, ) self.assertEqual(result, "可以的，我先帮您登记需求。") call_text.assert_not_called() get_reply.assert_called_once() bot.capture_chat_area.assert_called_once() def test_message_arriving_during_model_call_cancels_stale_reply(self): bot = WeChatBot.__new__(WeChatBot) fp = b"race0001" batch = "客户甲 10:00:00\n[图片]，请看一下" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = {fp.hex(): {"batch_ready": True}} bot.extract_context_for = mock.Mock(return_value=batch) bot.get_session_history = mock.Mock(return_value=[]) bot.capture_chat_area = mock.Mock(return_value=b"chat-png") bot._chat_surface_signature = mock.Mock( side_effect=[ b"before-extract", b"before-extract", b"after-new-message", ] ) bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.get_ai_reply", return_value="这是一条已经过时的回复"), mock.patch("wechat_bot.time.sleep"), ): result = bot._generate_ai_reply(fp) self.assertIsNone(result) bot._stage_exchange.assert_not_called() self.assertFalse(bot._pending_reply_state(fp)["batch_ready"]) def test_message_arriving_during_final_extraction_skips_model(self): bot = WeChatBot.__new__(WeChatBot) fp = b"race0002" bot.store = mock.Mock() bot.store.has_record.return_value = True bot._pending_reply_sessions = {fp.hex(): {"batch_ready": True}} bot.extract_context_for = mock.Mock( return_value="客户甲 10:00:00\n尚未包含后到的新消息" ) bot._chat_surface_signature = mock.Mock( side_effect=[b"before-extract", b"after-new-message"] ) with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.call_ai_text") as call_text, mock.patch("ai_chat.get_ai_reply") as vision, mock.patch("wechat_bot.time.sleep"), ): self.assertIsNone(bot._generate_ai_reply(fp)) call_text.assert_not_called() vision.assert_not_called() self.assertFalse(bot._pending_reply_state(fp)["batch_ready"]) def test_pending_text_is_restored_after_model_or_send_failure(self): bot = WeChatBot.__new__(WeChatBot) fp = b"retry001" cached = "客户甲 10:00:00\n上一轮尚未成功发送的问题" bot._pending_reply_sessions = { fp.hex(): {"batch_ready": True, "chat_text": cached} } bot.extract_context_for = mock.Mock(return_value="") bot.get_session_history = mock.Mock(return_value=[]) bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._stage_exchange = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.call_ai_text", return_value="这次继续回复。") as call_text, mock.patch( "registration_store.process_registration_reply", return_value=("这次继续回复。", None), ), mock.patch("wechat_bot.time.sleep"), ): self.assertEqual(bot._generate_ai_reply(fp), "这次继续回复。") call_text.assert_called_once_with(cached, history=[]) def test_snapshot_is_committed_only_after_successful_send(self): bot = WeChatBot.__new__(WeChatBot) fp = b"snap0001" bot._pending_reply_sessions = {} bot._pending_exchanges = {} bot.store = mock.Mock() bot.store.has_record.return_value = True bot.store.last_lines.return_value = ["客户甲 09:59:00", "旧消息"] current = "客户甲 09:59:00\n旧消息\n客户甲 10:00:00\n新消息" delta = bot.extract_context_for( fp, pre_text=current, defer_snapshot=True, ) self.assertIn("新消息", delta) bot.store.set_last_lines.assert_not_called() self.assertEqual( bot._pending_reply_state(fp)["last_lines"][-1], "新消息", ) bot._commit_staged_exchange(fp.hex()) bot.store.set_last_lines.assert_called_once() bot.store.save.assert_called_once() def test_pending_unread_task_survives_process_restart(self): with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") fp = b"p" * 40 bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_path = path bot._pending_reply_sessions = {} bot._active_identity_signature = b"stable-title" bot._mark_reply_pending(fp, batch_ready=True, confirmed_unread=True) state = bot._pending_reply_state(fp) state["chat_text"] = "客户甲 10:00:00\n崩溃前尚未回复" state["last_lines"] = ["客户甲 10:00:00", "崩溃前尚未回复"] state["send_state"] = "sending" state["ctrl_enter_attempted"] = True state["uncertain_since"] = 123.5 state["reply_text"] = "准备发送的回复" state["staged_user_text"] = "客户甲的问题" state["staged_reply_text"] = "准备发送的回复" state["send_surface_signature"] = b"before-enter" state["send_baseline_blocks"] = [ ["客户甲 10:00:00", "崩溃前尚未回复"] ] state["send_reply_was_visible"] = False state["send_known_outgoing_speakers"] = ["高兴亮"] bot._persist_pending_replies() restored_bot = WeChatBot.__new__(WeChatBot) restored_bot._pending_reply_path = path restored = restored_bot._load_pending_replies() self.assertIn(fp.hex(), restored) self.assertTrue(restored[fp.hex()]["confirmed_unread"]) self.assertIn("尚未回复", restored[fp.hex()]["chat_text"]) self.assertEqual(restored[fp.hex()]["send_state"], "sending") self.assertTrue(restored[fp.hex()]["ctrl_enter_attempted"]) self.assertEqual(restored[fp.hex()]["uncertain_since"], 123.5) self.assertEqual(restored[fp.hex()]["reply_text"], "准备发送的回复") self.assertEqual( restored[fp.hex()]["send_surface_signature"], b"before-enter", ) self.assertEqual( restored[fp.hex()]["send_baseline_blocks"], [["客户甲 10:00:00", "崩溃前尚未回复"]], ) self.assertEqual( restored[fp.hex()]["send_known_outgoing_speakers"], ["高兴亮"], ) with open(path, encoding="utf-8") as handle: self.assertIn(fp.hex(), json.load(handle)) def test_unfinished_merge_deadline_survives_process_restart(self): with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") fp = b"d" * 40 bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_path = path bot._pending_reply_sessions = { fp.hex(): { "batch_ready": False, "confirmed_unread": True, "batch_started_at": 100.0, "batch_deadline_at": 120.0, "batch_window_seconds": 20.0, "updated_at": 101.0, }, } self.assertTrue(bot._persist_pending_replies()) restored_bot = WeChatBot.__new__(WeChatBot) restored_bot._pending_reply_path = path restored = restored_bot._load_pending_replies()[fp.hex()] self.assertFalse(restored["batch_ready"]) self.assertEqual(restored["batch_started_at"], 100.0) self.assertEqual(restored["batch_deadline_at"], 120.0) self.assertEqual(restored["batch_window_seconds"], 20.0) def test_legacy_inflight_state_does_not_invent_an_empty_send_anchor(self): with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") fp = b"l" * 40 with open(path, "w", encoding="utf-8") as handle: json.dump( { fp.hex(): { "confirmed_unread": True, "send_state": "sent_uncommitted", "reply_text": "历史回复", "send_reply_match_count": 1, "updated_at": time.time(), } }, handle, ensure_ascii=False, ) bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_path = path restored = bot._load_pending_replies()[fp.hex()] self.assertNotIn("send_baseline_blocks", restored) self.assertNotIn("send_reply_was_visible", restored) def test_previous_16_byte_pending_key_is_loaded_instead_of_dropped(self): with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") old_fp = b"a" * 8 + b"n" * 8 with open(path, "w", encoding="utf-8") as handle: json.dump( { old_fp.hex(): { "batch_ready": True, "confirmed_unread": True, "chat_text": "客户甲 10:00:00\n旧版未回复内容", "identity_signature": b"stable-title".hex(), } }, handle, ) bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_path = path restored = bot._load_pending_replies() self.assertIn(old_fp.hex(), restored) self.assertEqual( restored[old_fp.hex()]["identity_signature"], b"stable-title", ) class SessionViewerSnapshotTest(TestCase): """客户会话记录里那张画面的取路径规则。渲染本身交给 Qt，这里只管定位。""" @classmethod def setUpClass(cls): try: from wechat_gui_qt import SessionDetailDialog except Exception as exc: # PySide6 缺失/无显示环境时跳过，别拖垮整个套件 raise SkipTest(f"PySide6 不可用: {exc}") cls.dialog = SessionDetailDialog def test_a_stored_snapshot_resolves_under_the_media_dir(self): import wechat_gui_qt with tempfile.TemporaryDirectory() as directory: media = os.path.join(directory, "media") os.makedirs(media) with open(os.path.join(media, "shot.png"), "wb") as handle: handle.write(b"PNG") with mock.patch.object(wechat_gui_qt, "SCRIPT_DIR", directory): self.assertEqual( self.dialog._snapshot_path({"image": "shot.png"}), os.path.join(media, "shot.png"), ) def test_a_message_without_a_snapshot_resolves_to_nothing(self): self.assertEqual(self.dialog._snapshot_path({"content": "在不在"}), "") def test_a_missing_file_is_not_offered_to_the_viewer(self): import wechat_gui_qt with tempfile.TemporaryDirectory() as directory: with mock.patch.object(wechat_gui_qt, "SCRIPT_DIR", directory): self.assertEqual( self.dialog._snapshot_path({"image": "没了.png"}), "" ) def test_a_path_in_the_archive_never_escapes_the_media_dir(self): """档案是磁盘上的文件，可能被改。只认纯文件名，不认任何路径。""" for evil in ("../../secret.png", "sub/shot.png", "C:\\Windows\\a.png"): self.assertEqual(self.dialog._snapshot_path({"image": evil}), "") class TransactionStoreTest(TestCase): def test_exchange_id_is_committed_only_once_after_restart(self): with tempfile.TemporaryDirectory() as tmpdir: path = os.path.join(tmpdir, "conversations.json") store = ConversationStore(path) self.assertTrue( store.append_exchange_once("session", "客户消息", "客服回复", "tx-1") ) self.assertFalse( store.append_exchange_once("session", "客户消息", "客服回复", "tx-1") ) restored = ConversationStore(path) self.assertEqual(len(restored.history("session")), 2) def test_visually_proven_outgoing_speaker_survives_restart(self): with tempfile.TemporaryDirectory() as tmpdir: path = os.path.join(tmpdir, "conversations.json") fp = b"k" * 40 store = ConversationStore(path) self.assertTrue(store.add_outgoing_speaker(fp.hex(), "高兴亮")) self.assertFalse(store.add_outgoing_speaker(fp.hex(), "高兴亮")) restored = ConversationStore(path) self.assertEqual(restored.outgoing_speakers(fp.hex()), ["高兴亮"]) bot = WeChatBot.__new__(WeChatBot) bot.store = restored bot._active_session_fp = fp with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertIn("高兴亮", bot._known_outgoing_speakers()) def test_registration_prepare_mode_does_not_write_before_send(self): with tempfile.TemporaryDirectory() as tmpdir: path = os.path.join(tmpdir, "registration.json") store = RegistrationStore(path) reply, lead = process_registration_reply( session_id="customer-a", user_text="我想挂号，最近总是口渴", reply_text="好的，我先帮您预约。", store=store, persist=False, ) self.assertIn("甄养堂互联网医院", reply) self.assertIsNotNone(lead) self.assertEqual(store.list_leads(), []) store.add_or_update(**lead) self.assertEqual(len(store.list_leads()), 1) class SafetyGateTest(TestCase): @staticmethod def _verification_surface(with_nav=False): """登录页样张：正中一个真二维码。 原来这里放的是棋盘格。棋盘格能满足"够黑、够亮、跳变够多"，但它不是 二维码——密集小字同样满足，于是一条长广告消息就能让机器人停机。判据改成 真的去找定位图案后，样张也必须是真码。 """ import cv2 image = np.full((1000, 1600, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 if with_nav: image[80:920, :96, :3] = 45 code = cv2.QRCodeEncoder_create().encode( "https://work.weixin.qq.com/login/verify/abc123" ) code = cv2.resize(code, (240, 240), interpolation=cv2.INTER_NEAREST) image[380:620, 680:920, :3] = code[:, :, None] return image @staticmethod def _modal_surface(with_close=True): image = np.full((800, 1200, 4), 235, dtype=np.uint8) image[:, :, 3] = 255 image[130:700, 280:920, :3] = 250 image[130:700, 919:922, :3] = 190 image[697:701, 280:922, :3] = 190 if with_close: for offset in range(-7, 8): image[175 + offset, 870 + offset, :3] = 70 image[175 + offset, 870 - offset, :3] = 70 return image @staticmethod def _nav_surface(message_selected: bool): image = np.full((320, 500, 4), 242, dtype=np.uint8) image[:, :, 3] = 255 if message_selected: # BGR 蓝色块模拟消息行的选中背景。 image[68:102, 4:58, :3] = (238, 126, 36) else: # 其他入口被选中；消息位置只有灰色图标。 image[68:102, 4:58, :3] = (145, 145, 145) image[210:255, 22:52, :3] = (238, 126, 36) image[240:242, :, :3] = 230 image[242:, :, :3] = 255 return image @staticmethod def _mail_nav_surface(): image = SafetyGateTest._nav_surface(False) # 邮件紧邻消息；旧检测框跨到这一行后会把邮件误判为消息。 image[110:142, 4:58, :3] = (238, 126, 36) return image def test_qr_page_without_main_navigation_is_blocked(self): self.assertTrue( looks_like_security_verification(self._verification_surface()) ) def test_normal_navigation_prevents_false_positive(self): """主界面还在时不停机。这道判断已从像素判据搬到 _security_gate_visible： 浅色主题下左侧导航本来就是浅色，"导航够深"根本挡不住任何东西。""" bot = WeChatBot.__new__(WeChatBot) bot.security_verification_required = False bot._security_log_emitted = False bot.hwnd = 1 bot._message_nav_selected = mock.Mock(return_value=True) surface = self._verification_surface(with_nav=True) with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=(0, 0, 1600, 1000)), mock.patch("wechat_bot.capture_window_region", return_value=surface), ): self.assertFalse(bot._security_gate_visible()) def test_center_modal_close_button_is_detected(self): candidate = find_blocking_modal_close(self._modal_surface()) self.assertIsNotNone(candidate) self.assertLess(abs(candidate[0] - 870), 5) self.assertLess(abs(candidate[1] - 175), 5) def test_plain_surface_is_not_treated_as_modal(self): self.assertIsNone(find_blocking_modal_close(self._modal_surface(False))) @staticmethod def _chat_bubble_surface(): """聊天气泡里出现形似 × 的字形，且下方叠着一列气泡左边缘。 真实故障画面就是这个形状：客户消息「你怎么不回复啊」的“你”被当成 弹窗关闭按钮，而下方连续气泡的左边缘凑出了“竖直面板边缘”。 """ image = np.full((900, 1600, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # 最上面一条客户消息气泡，× 字形落在气泡内部的留白里。 image[96:142, 700:1000, :3] = 255 for offset in range(-7, 8): image[119 + offset, 755 + offset, :3] = 70 image[119 + offset, 755 - offset, :3] = 70 # 下方连续气泡：左边缘固定在 x=780，被气泡间隙反复打断。 for top in range(160, 560, 68): image[top:top + 46, 780:1000, :3] = 255 return image def test_chat_bubble_glyph_is_not_treated_as_modal_close(self): self.assertIsNone(find_blocking_modal_close(self._chat_bubble_surface())) def test_dimmed_background_is_recognised_as_modal_scrim(self): image = np.full((900, 1600, 4), 120, dtype=np.uint8) image[:, :, 3] = 255 image[200:700, 500:1100, :3] = 250 self.assertTrue(looks_like_modal_scrim(image)) def test_normal_bright_page_is_not_a_modal_scrim(self): self.assertFalse(looks_like_modal_scrim(self._chat_bubble_surface())) def test_unchanged_surface_after_escape_is_treated_as_false_positive(self): """Esc 没有改变任何画面时，绝不能把聊天内容当弹窗冻结整轮轮询。""" bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.L = 20 bot.T = 30 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._capture_full_window = mock.Mock(return_value=self._modal_surface()) bot._message_nav_selected = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.safe_set_foreground"), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=bot.hwnd), mock.patch( "wechat_bot.find_blocking_modal_close", side_effect=[(870, 175), None, (870, 175)], ), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertFalse(bot._dismiss_internal_blocker("测试")) # 已被证伪的画面不再重复按 Esc，也不再冻结后续轮询。 self.assertFalse(bot._dismiss_internal_blocker("测试")) press.assert_called_once_with("esc") click.assert_not_called() def test_message_workspace_uses_selected_navigation_state(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 self.assertTrue(bot._message_nav_selected(self._nav_surface(True))) self.assertFalse(bot._message_nav_selected(self._nav_surface(False))) def test_message_workspace_accepts_sparse_200_percent_dpi_highlight(self): """Real 200% DPI rounded highlights expose only about 11% blue pixels.""" image = np.full((360, 600, 4), 242, dtype=np.uint8) image[:, :, 3] = 255 # 1000 / (80 * 116) ~= 10.8%; the old 12% cutoff rejected this. image[140:160, 8:58, :3] = (238, 126, 36) bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 self.assertTrue(bot._message_nav_selected(image)) def test_dynamic_navigation_width_supports_narrow_and_wide_sidebars(self): def surface(nav_width): image = np.full((420, 900, 4), 248, dtype=np.uint8) image[:, :, 3] = 255 # 浅蓝导航背景（BGR），消息行右侧从这里突变为中性列表背景。 image[130:210, :nav_width, :3] = (250, 232, 215) image[130:210, nav_width:, :3] = (245, 245, 245) return image self.assertEqual(infer_navigation_width(surface(136), 2.0)[0], 136) self.assertEqual(infer_navigation_width(surface(320), 2.0)[0], 320) def test_session_list_width_follows_the_persistent_visual_divider(self): image = np.full((1300, 2200, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # 320px 导航后，会话列表宽 508px；右侧聊天区底色不同并带纵向阴影。 image[112:, :320, :3] = 232 image[112:, 320:820, :3] = 248 image[112:, 820:828, :3] = 220 image[112:, 828:, :3] = 238 detected, confidence = infer_session_list_width(image, 320, 2.0) self.assertGreaterEqual(confidence, 0.60) self.assertGreaterEqual(detected, 500) self.assertLessEqual(detected, 512) def test_flat_text_avatar_is_admitted_only_as_visual_proof_candidate(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot.store = mock.Mock() bot.store.has_record.return_value = False bot._flat_visual_proof_fps = set() bot._flat_rejected_session_fps = set() image = np.full((180, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # Rounded blue square with a simple white glyph: representative of a # generated WeCom text avatar and deliberately flat-colour. image[20:108, 22:108, :3] = (220, 120, 30) image[14:25, 16:30, :3] = 245 image[14:25, 100:116, :3] = 245 image[100:114, 16:30, :3] = 245 image[100:114, 100:116, :3] = 245 image[42:82, 56:70, :3] = 250 image[54:68, 42:84, :3] = 250 fp = b"f" * 40 bot.detect_badge_rows = mock.Mock(return_value=[32]) bot._session_fingerprint = mock.Mock(return_value=fp) self.assertFalse(bot._is_real_conversation(image, 32, quiet=True)) found = bot._target_from_session_image(image, set(), set()) self.assertEqual(found, (32, fp)) self.assertIn(fp.hex(), bot._flat_visual_proof_fps) def test_selected_blue_row_uses_background_inside_rounded_highlight(self): """200% DPI selected rows must not compare avatar corners to outer white.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 image = np.full((180, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 selected_blue = np.array((242, 131, 48), dtype=np.uint8) image[0:128, 8:, :3] = selected_blue # Avatar bounds at 200% DPI are x=16..116, y=14..114. Paint a # textured green avatar, then expose selected-blue rounded corners. image[14:114, 16:116, :3] = (80, 190, 70) for offset in range(14, 114): image[offset, 28:104, 1] = 120 + (offset % 100) image[14:24, 16:26, :3] = selected_blue image[14:24, 106:116, :3] = selected_blue image[104:114, 16:26, :3] = selected_blue image[104:114, 106:116, :3] = selected_blue # The old x=6 sample is white while all rounded corners are blue. self.assertGreater( int(np.abs( bot._patch_color(image, 6, 64) - bot._patch_color(image, 16, 14) ).sum()), 45, ) self.assertTrue( bot._is_real_conversation( image, 64, quiet=True, row_center=True, allow_flat=True, ) ) bot._session_fingerprint = mock.Mock(return_value=b"b" * 40) bot._pending_reply_sessions = {} bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot._session_render_ids = {} bot._live_session_fp_aliases = set() self.assertFalse(bot._is_tool_selected(image, 64)) def test_square_unread_avatar_is_kept_for_safe_visual_proof(self): """A verified unread + full composite identity must not be discarded by shape.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot.store = mock.Mock() bot.store.has_record.return_value = False bot._flat_visual_proof_fps = set() bot._flat_rejected_session_fps = set() image = np.full((180, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # Deliberately square/full-bleed so every corner differs from the row. # Extend one pixel beyond the nominal bounds: a 5x5 corner patch then # has an icon-colour majority, while the x=14 background patch still # has a row-background majority. image[13:115, 15:117, :3] = (70, 190, 80) fp = b"s" * 40 bot.detect_badge_rows = mock.Mock(return_value=[32]) bot._session_fingerprint = mock.Mock(return_value=fp) self.assertFalse( bot._is_real_conversation( image, 32, quiet=True, allow_flat=True, ) ) self.assertEqual( bot._target_from_session_image(image, set(), set()), (32, fp), ) self.assertIn(fp.hex(), bot._flat_visual_proof_fps) def test_selected_square_avatar_only_bypasses_tool_filter_for_exact_pending(self): bot = WeChatBot.__new__(WeChatBot) target = b"a" * 8 + b"n" * 32 different_name = b"a" * 8 + b"x" * 32 bot._pending_reply_sessions = { target.hex(): {"requires_visual_proof": True}, } bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot._session_render_ids = {} bot._live_session_fp_aliases = set() bot._is_real_conversation = mock.Mock(return_value=False) bot._session_fingerprint = mock.Mock(return_value=target) page = np.zeros((128, 180, 4), dtype=np.uint8) self.assertFalse(bot._is_tool_selected(page, 64)) bot._session_fingerprint.return_value = different_name self.assertTrue(bot._is_tool_selected(page, 64)) def test_verified_square_avatar_stays_selectable_after_visual_proof_clears(self): bot = WeChatBot.__new__(WeChatBot) target = b"v" * 40 bot._pending_reply_sessions = {} bot._flat_verified_session_fps = {target.hex()} bot._flat_rejected_session_fps = set() bot._session_render_ids = {} bot._live_session_fp_aliases = set() bot._is_real_conversation = mock.Mock(return_value=False) bot._session_fingerprint = mock.Mock(return_value=target) bot.store = mock.Mock() bot.store.has_record.return_value = False self.assertFalse( bot._is_tool_selected(np.zeros((128, 180, 4), dtype=np.uint8), 64) ) def test_200_percent_dpi_input_point_is_inside_editor_body(self): # Regression fixture from the user's original 2726x1756 WeCom image: # the toolbar occupies roughly y=1510..1590. The old 95px offset # landed at y=1566 (toolbar); the new point must be in the editor body. input_y = 1756 - int(INPUT_Y_FROM_BOTTOM * 2.0) self.assertGreaterEqual(input_y, 1600) self.assertLess(input_y, 1756) def test_200_percent_dpi_detects_both_resizable_composer_heights(self): fixtures = ( (1756, 2726, 1510), (1316, 2254, 1008), ) for height, width, divider in fixtures: image = np.full((height, width, 4), 247, dtype=np.uint8) image[:, :, 3] = 255 image[divider:divider + 2, :, :3] = 231 image[divider + 2:, :, :3] = 255 detected = infer_composer_top(image, int(width * 0.30), 2.0) self.assertEqual(detected, divider) self.assertLess(detected - int(2 * 2.0), divider) ambiguous = np.full((1316, 2254, 4), 247, dtype=np.uint8) ambiguous[:, :, 3] = 255 for divider in (820, 1008): ambiguous[divider:divider + 2, :, :3] = 231 ambiguous[divider + 2:, :, :3] = 255 # Repaint the band between the two rules so both remain independent. ambiguous[822:1008, :, :3] = 247 ambiguous[1008:1010, :, :3] = 231 ambiguous[1010:, :, :3] = 255 # 聊天内容里的宽横边（大图/整行气泡边缘）也会形成候选。旧实现遇到 # 多个候选就放弃，小窗口下输入区永远识别不出来、回复功能无法启动。 # 现在选择最靠底部、下方是白色编辑区的那条分隔线。 self.assertEqual( infer_composer_top(ambiguous, int(2254 * 0.30), 2.0), 1008, ) def test_composer_found_despite_wide_content_edge_in_chat(self): """聊天区中部的全宽横边不再让分隔线检测放弃（用户实机截图场景）。""" image = np.full((1196, 2048, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # 聊天中部一条内容横边，下方仍是灰色聊天背景。 image[510:512, :, :3] = 226 # 真正的输入区分隔线，下方是白色编辑区。 image[916:918, :, :3] = 231 image[918:, :, :3] = 255 self.assertEqual( infer_composer_top(image, int(2048 * 0.30), 2.0), 916, ) def test_chat_pane_right_detects_sidebar_divider(self): """右侧工具栏展开时，靠纵贯分隔线找到聊天面板右缘。""" image = np.full((1196, 2048, 4), 246, dtype=np.uint8) image[:, :, 3] = 255 # 聊天面板与工具栏之间的纵贯分隔线（比左右邻列暗）。 image[:, 1550:1552, :3] = 232 chat_left = 580 self.assertEqual(infer_chat_pane_right(image, chat_left, 2.0), 1550) # 没有分隔线 → 聊天区延伸到窗口右缘。 plain = np.full((1196, 2048, 4), 246, dtype=np.uint8) plain[:, :, 3] = 255 self.assertIsNone(infer_chat_pane_right(plain, chat_left, 2.0)) # 断续的短竖线（气泡边缘/滚动条）不能被当成面板分界。 broken = plain.copy() broken[300:700, 1550:1552, :3] = 232 self.assertIsNone(infer_chat_pane_right(broken, chat_left, 2.0)) def test_composer_scan_is_bounded_inside_chat_pane(self): """右侧工具栏内容不再干扰输入区分隔线检测。""" image = np.full((1196, 2048, 4), 246, dtype=np.uint8) image[:, :, 3] = 255 chat_left = 400 # 工具栏（x>=1550）填充杂乱内容，破坏全宽 80% 变化率要求。 image[:, 1550:1552, :3] = 232 rng = np.random.default_rng(7) image[:, 1560:, :3] = rng.integers(120, 250, (1196, 488, 3), dtype=np.uint8) # 分隔线只存在于聊天面板内部。 image[916:918, chat_left:1550, :3] = 231 image[918:, chat_left:1550, :3] = 255 # 不限定右缘时扫描带跨进工具栏，检测失败（旧 bug）。 self.assertIsNone(infer_composer_top(image, chat_left, 2.0)) # 限定聊天面板右缘后成功。 self.assertEqual( infer_composer_top(image, chat_left, 2.0, chat_right=1550), 916, ) def test_post_paste_divider_check_ignores_sidebar_and_editor_text(self): """The final Enter gate must use the chat pane, not the whole window.""" image = np.full((1196, 2048, 4), 246, dtype=np.uint8) image[:, :, 3] = 255 chat_left = 400 image[:, 1550:1552, :3] = 232 rng = np.random.default_rng(17) image[:, 1560:, :3] = rng.integers( 120, 250, (1196, 488, 3), dtype=np.uint8 ) image[916:918, chat_left:1550, :3] = 231 image[918:, chat_left:1550, :3] = 255 # The reply has already been pasted into the upper editor body. image[958:982, 460:920, :3] = 70 matched, detected = composer_divider_matches( image, chat_left, 916, 2.0, chat_right=1550, ) self.assertTrue(matched) self.assertLessEqual(abs(int(detected) - 916), 8) def test_refresh_geometry_shrinks_chat_region_when_sidebar_opens(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 0, 0, 2048, 1196 bot._list_x = 320 bot._selected_tracking_initialized = True bot._active_session_fp = b"old" bot._active_chat_signature = b"old" bot._active_identity_signature = b"old" bot._composer_geometry_valid = True bot._composer_rel_top = 916 full = np.zeros((1196, 2048, 4), dtype=np.uint8) with ( mock.patch("wechat_bot.infer_navigation_width", return_value=(320, 0.9)), mock.patch("wechat_bot.infer_chat_pane_right", return_value=1550), mock.patch("wechat_bot.infer_composer_top", return_value=916), ): # 工具栏从无到有属于几何变化，必须触发重算。 self.assertTrue(bot._refresh_message_geometry(full)) self.assertEqual(bot._chat_pane_right_rel, 1550) region = bot._chat_region self.assertLessEqual(region["left"] + region["width"], 1550) # 输入点击必须落在聊天面板内，而不是工具栏里。 self.assertLess(bot.input_x, 1550) # 视觉截图区域同样止步于面板右缘。 self.assertLessEqual(bot._chat_rel_x + bot._chat_rel_w, 1550) def test_refresh_geometry_pane_unchanged_is_not_a_layout_change(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 0, 0, 2048, 1196 bot._list_x = 320 bot._composer_geometry_valid = True bot._composer_rel_top = 916 bot._chat_pane_right_rel = None full = np.zeros((1196, 2048, 4), dtype=np.uint8) with ( mock.patch("wechat_bot.infer_navigation_width", return_value=(320, 0.9)), mock.patch("wechat_bot.infer_chat_pane_right", return_value=None), mock.patch("wechat_bot.infer_composer_top", return_value=916), ): self.assertFalse(bot._refresh_message_geometry(full)) def test_pending_square_avatar_can_be_found_after_unread_badge_disappears(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.session_item_h = 32 target = b"p" * 40 bot._pending_reply_sessions = { target.hex(): {"requires_visual_proof": True}, } bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot._session_render_ids = {} bot._live_session_fp_aliases = set() page = np.zeros((64, 180, 4), dtype=np.uint8) bot.detect_selected_row = mock.Mock(return_value=-1) bot.detect_badge_rows = mock.Mock(return_value=[]) bot._session_fingerprint = mock.Mock( side_effect=lambda _img, y, row_center=True: ( target if y == 16 else b"z" * 40 ) ) bot._is_real_conversation = mock.Mock(return_value=False) self.assertEqual(bot._pending_rows_on_page(page, target), [16]) def test_rejected_flat_row_render_drift_does_not_starve_next_unread(self): """A proven tool row stays excluded after font/selection render drift.""" bot = WeChatBot.__new__(WeChatBot) rejected = b"a" * 8 + bytes(32) drifted_name = bytearray(32) drifted_name[2] = 0b00000001 # allowed middle-render drift drifted_name[8] = 0b00000001 # allowed absolute-grid drift drifted = b"a" * 8 + bytes(drifted_name) customer_name = bytearray(32) customer_name[0] = 0b00000001 # distinct first-glyph identity customer = b"b" * 8 + bytes(customer_name) bot._flat_rejected_session_fps = {rejected.hex()} # Persisted 40-byte archive keys stay byte-for-byte unchanged. Only a # process-local render ID proves that the unread-bold and restored-row # variants are the same system entry. bot._session_render_ids = { rejected.hex(): {"same-live-render"}, drifted.hex(): {"same-live-render"}, } bot.detect_badge_rows = mock.Mock(return_value=[16, 80]) bot._session_fingerprint = mock.Mock( side_effect=lambda _img, y: drifted if y == 16 else customer ) bot._is_real_conversation = mock.Mock(return_value=True) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) page = np.zeros((128, 180, 4), dtype=np.uint8) non_conversations = set() self.assertEqual( bot._target_from_session_image(page, set(), non_conversations), (80, customer), ) self.assertIn(drifted, non_conversations) def test_badge_and_selected_row_use_the_same_avatar_center(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() image = np.full((180, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # badge y=32 映射到头像中心 y=64；构造一块不对称纹理头像。 for y in range(40, 88): for x in range(20, 84): image[y, x, :3] = ((x * 3) % 255, (y * 5) % 255, (x + y) % 255) image[28:54, 170:220, :3] = 20 from_badge = bot._session_fingerprint(image, 32) from_selected_center = bot._session_fingerprint( image, 64, row_center=True, ) self.assertEqual(from_badge, from_selected_center) @staticmethod def _session_list_surface(rows=6, pitch=128, first_center=64): """构造多行会话列表：规整行距、各行纹理不同的头像方块与名称字形。""" height = first_center + pitch * (rows - 1) + pitch // 2 image = np.full((height, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 for index in range(rows): center = first_center + index * pitch for y in range(center - 40, center + 40): for x in range(20, 88): image[y, x, :3] = ( (x * 3 + index * 29) % 255, (y * 5) % 255, (x + y + index * 11) % 255, ) image[center - 38:center - 8, 122:158, :3] = 25 image[center + 4:center + 26, 122:200, :3] = 90 return image def _fingerprint_bot(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() return bot def test_row_estimate_error_no_longer_forks_the_archive_key(self): """行锚点估算偏差绝不能让同一个联系人算出第二个档案键。 档案查找是精确匹配，而头像感知哈希对锚点极敏感；锚点一偏，会话就被当成 “首次遇到”，复制到的聊天文字会被丢弃、只靠截图回复，历史也注入不了。 """ bot = self._fingerprint_bot() image = self._session_list_surface() truth = bot._session_fingerprint(image, 192, row_center=True) self.assertTrue(truth) for offset in (-48, -32, -18, -6, -1, 1, 6, 18, 32, 48): self.assertEqual( bot._session_fingerprint(image, 192 + offset, row_center=True), truth, msg=f"行锚点偏 {offset}px 就换了档案键", ) def test_badge_offset_error_keeps_the_unread_and_opened_keys_identical(self): """未读徽章按固定偏移推算行中心，偏差不能改写会话键。""" bot = self._fingerprint_bot() image = self._session_list_surface() # 徽章画得比假定位置高 18px，推算出的行中心随之偏离真实头像中心。 badge_y = 192 - int(16 * bot.scale) - 18 self.assertNotEqual(bot._row_center_from_badge(image, badge_y), 192) self.assertEqual( bot._session_fingerprint(image, badge_y), bot._session_fingerprint(image, 192, row_center=True), ) def test_avatar_anchor_never_snaps_onto_a_neighbouring_row(self): """吸附只能收敛同一行的估算误差，绝不能跨行认错联系人。""" bot = self._fingerprint_bot() image = self._session_list_surface() self.assertEqual(bot._avatar_anchor(image, 192), 192) self.assertEqual(bot._avatar_anchor(image, 320), 320) self.assertNotEqual( bot._session_fingerprint(image, 192, row_center=True), bot._session_fingerprint(image, 320, row_center=True), ) def test_unconfirmed_navigation_width_mints_no_session_identity(self): """导航宽度未识别确认时绝不铸造会话键。 宽/窄侧栏的列表裁剪起点实测相差 184px，此时采到的“头像”其实是别处的 像素，算出的键与真实键相差 25 位（容差 6 位）。这种键一旦落盘就永久 多出一个认不回来的会话：档案查不到 → 每轮都算“首次遇到” → 复制到的 聊天文字被丢弃、只靠截图回复。 """ bot = self._fingerprint_bot() image = self._session_list_surface() bot._nav_width_confirmed = False bot._nav_width_gate_logged = False self.assertEqual(bot._session_fingerprint(image, 192, row_center=True), b"") bot._nav_width_confirmed = True self.assertTrue(bot._session_fingerprint(image, 192, row_center=True)) # ── 头像 pHash 漂移不能把同一个联系人否掉 ──────────────────────────────── # 现场日志（2026-07-31 09:40:18→09:40:19）：点击会话后 1 秒复核，名称字形 # 哈希逐位相同，头像 pHash 却漂了 15 位，于是被判成“打开的不是目标会话”。 # 每个会话回两次之后指纹一漂，档案和待回复任务就都认不回来了。 _DRIFT_NAME = bytes.fromhex("07fd03fb") + b"\x5a" * 28 _DRIFT_AVATAR_BEFORE = bytes.fromhex("05050d1d1f0f0700") _DRIFT_AVATAR_AFTER = bytes.fromhex("000818181f1f0f0e") def _fp_bot(self): bot = WeChatBot.__new__(WeChatBot) bot._live_session_fp_aliases = set() return bot def test_same_contact_survives_the_measured_avatar_hash_drift(self): bot = self._fp_bot() before = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME after = self._DRIFT_AVATAR_AFTER + self._DRIFT_NAME distance = ( int.from_bytes(self._DRIFT_AVATAR_BEFORE, "big") ^ int.from_bytes(self._DRIFT_AVATAR_AFTER, "big") ).bit_count() # 守住前提：这确实超出原来的 6 位容差，否则本测试就失去意义。 self.assertGreater(distance, bot._FP_HAMMING_TOL) self.assertTrue(bot._session_fp_matches(before, after)) def test_the_drifted_avatar_canonicalizes_onto_the_existing_key(self): """归一化也必须认下这次漂移，否则同一个人当场被铸成第二把档案键。 `_session_fp_matches` 放行、`_canonical_session_fp` 却按 6 位头像容差把 已有键筛掉的话，落盘的仍是一把新键：档案查不到、待回复任务对不上， 这个联系人一样从此收不到回复。 """ bot = self._fp_bot() before = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME after = self._DRIFT_AVATAR_AFTER + self._DRIFT_NAME bot._known_session_fps = {before} self.assertEqual(bot._canonical_session_fp(after), before) # ── 一次只服务一个会话：当前会话先收尾，其余按到达先后排队 ────────────── def test_the_open_session_is_served_before_anyone_else(self): """正在回复的会话不能被别的会话抢走，否则这条回复要等下一轮重来。""" pending = { "aa" * 40: {"created_at": 100.0}, "bb" * 40: {"created_at": 200.0}, "cc" * 40: {"created_at": 300.0}, } active = bytes.fromhex("cc" * 40) order = [key for key, _ in WeChatBot._pending_queue_order(pending, active)] self.assertEqual(order[0], "cc" * 40) def test_the_rest_of_the_queue_is_first_come_first_served(self): """多个会话同时来消息就排队，按到达先后一条条处理。""" pending = { "cc" * 40: {"created_at": 300.0}, "aa" * 40: {"created_at": 100.0}, "bb" * 40: {"created_at": 200.0}, } order = [key for key, _ in WeChatBot._pending_queue_order(pending, None)] self.assertEqual(order, ["aa" * 40, "bb" * 40, "cc" * 40]) def test_a_missing_arrival_time_never_breaks_the_queue(self): """旧任务缺少 created_at 时排队不能崩，只能排在最前面等着被收掉。""" pending = { "aa" * 40: {}, "bb" * 40: {"created_at": "坏值"}, "cc" * 40: {"created_at": 200.0}, } order = [key for key, _ in WeChatBot._pending_queue_order(pending, None)] self.assertEqual(order[-1], "cc" * 40) # ── 新会话只有一条消息，复制不出表头，仍要能证明回复发出去了 ──────────── # 现场（2026-07-31 12:11）：新客户只发了“你好”，框选只能选中气泡内文字， # 企微不给“发言人+时间”表头，消息块锚点建不起来，发送被永久拦下。 def _receipt_bot(self, visible_after, outgoing=True, surface_changed=True): bot = WeChatBot.__new__(WeChatBot) bot.extract_chat_text = lambda screens=1, wait_for_idle=False: visible_after bot._last_visible_bubble_is_outgoing = lambda: outgoing bot._chat_surface_signature = lambda: b"after" if surface_changed else b"before" return bot def test_a_headerless_chat_can_still_prove_the_reply_landed(self): reply = "你好呀，我是贴心管家，有什么想问的您慢慢说" bot = self._receipt_bot(f"你好\n{reply}") self.assertIs( bot._raw_text_receipt_matches(reply, "你好", b"before"), True, ) def test_a_reply_that_never_appeared_is_not_accepted(self): reply = "你好呀，我是贴心管家" bot = self._receipt_bot("你好") self.assertIs(bot._raw_text_receipt_matches(reply, "你好", b"before"), False) def test_a_customer_followup_does_not_cancel_our_receipt(self): """客户在我们发完后马上又说一句，末条气泡就在左边。 现场（2026-07-31 12:38）：回复实际已经发出去了，客户紧接着补了句 “你在哪呢”，末条落到左侧，回执被判定为失败，任务卡在待核对里既不重发 也不放行。这句回复是模型现生成的，发送前整屏文字里没有、现在有了，就 只能是我们发的；末条在左边只说明客户有新话要接。 """ reply = "你好呀，我是贴心管家" bot = self._receipt_bot(f"你好\n{reply}\n你在哪呢", outgoing=False) self.assertIs(bot._raw_text_receipt_matches(reply, "你好", b"before"), True) self.assertIs(bot._last_send_receipt_followup, True) def test_a_quiet_chat_reports_no_followup_to_chase(self): reply = "你好呀，我是贴心管家" bot = self._receipt_bot(f"你好\n{reply}", outgoing=True) self.assertIs(bot._raw_text_receipt_matches(reply, "你好", b"before"), True) self.assertIsNone(bot._last_send_receipt_followup) def test_a_reply_missing_from_the_screen_is_still_refused(self): """末条气泡不再有否决权，但"屏幕上根本没有这句话"仍然必须判失败。""" reply = "你好呀，我是贴心管家" bot = self._receipt_bot("你好\n你在哪呢", outgoing=False) self.assertIs(bot._raw_text_receipt_matches(reply, "你好", b"before"), False) @staticmethod def _login_page(qr_side=420, center=(0.5, 0.45), width=2258, height=1320): """一张真的登录页：白底、正中一个真二维码、没有任何主界面结构。""" import cv2 page = np.full((height, width, 4), 245, dtype=np.uint8) code = cv2.QRCodeEncoder_create().encode( "https://work.weixin.qq.com/login/verify/abc123" ) code = cv2.resize( code, (qr_side, qr_side), interpolation=cv2.INTER_NEAREST ) cx = int(width * center[0]) cy = int(height * center[1]) x0, y0 = cx - qr_side // 2, cy - qr_side // 2 page[y0:y0 + qr_side, x0:x0 + qr_side, :3] = code[:, :, None] return page def test_a_customer_image_is_kept_with_the_archived_message(self): """企微图片没有可复制文本，档案里只剩「（客户发来图片）」这行占位。 事后翻记录完全不知道客户发了什么。视觉模式本来就截了这一屏发给模型， 顺手落一份盘，会话记录才有东西可显示。 """ from conversation_store import ConversationStore with tempfile.TemporaryDirectory() as directory: store = ConversationStore(os.path.join(directory, "conversations.json")) store.append_exchange_once( "abc", "（客户发来图片）", "收到啦", "tx1", user_image="shot.png" ) history = store.history("abc") self.assertEqual(history[0]["image"], "shot.png") # 我方回复没有画面，不该凭空多出这个键 self.assertNotIn("image", history[1]) def test_a_text_only_exchange_stays_free_of_image_keys(self): from conversation_store import ConversationStore with tempfile.TemporaryDirectory() as directory: store = ConversationStore(os.path.join(directory, "conversations.json")) store.append_exchange_once("abc", "在不在", "在呢", "tx1") self.assertNotIn("image", store.history("abc")[0]) def test_a_saved_snapshot_lands_on_disk_and_old_ones_are_pruned(self): with tempfile.TemporaryDirectory() as directory: with ( mock.patch.object(WeChatBot, "_MEDIA_DIR", directory), mock.patch.object(WeChatBot, "_MEDIA_KEEP_FILES", 3), ): bot = WeChatBot.__new__(WeChatBot) names = [ bot._save_media_snapshot(b"f" * 40, b"PNG-%d" % index) for index in range(6) ] self.assertTrue(all(names)) left = [n for n in os.listdir(directory) if n.endswith(".png")] self.assertLessEqual(len(left), 3) # 留下的必须是最近几张，最早那几张才是该淘汰的 self.assertIn(names[-1], left) self.assertNotIn(names[0], left) def test_an_unwritable_media_dir_never_blocks_the_reply(self): """留存失败是小事，绝不能因此不回客户。""" bot = WeChatBot.__new__(WeChatBot) with mock.patch("wechat_bot.os.makedirs", side_effect=OSError("满了")): self.assertEqual(bot._save_media_snapshot(b"f" * 40, b"PNG"), "") self.assertEqual(bot._save_media_snapshot(b"f" * 40, b""), "") def test_the_staged_snapshot_reaches_the_archive(self): bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 bot._pending_exchanges = {} bot._pending_reply_sessions = { fp.hex(): { "staged_user_text": "（客户发来图片）", "staged_reply_text": "收到啦", "staged_user_image": "shot.png", "exchange_id": "tx1", "archive_enabled": True, } } bot.store = mock.Mock() bot.store.append_exchange_once = mock.Mock(return_value=True) bot._forget_uncertain_tracking = mock.Mock() bot._persist_pending_replies = mock.Mock() bot._commit_staged_exchange(fp.hex()) bot.store.append_exchange_once.assert_called_once_with( fp.hex(), "（客户发来图片）", "收到啦", "tx1", user_image="shot.png", ) def test_the_staged_snapshot_survives_a_restart(self): """发送和入档之间进程挂掉，重启后这张画面不能丢。""" with tempfile.TemporaryDirectory() as directory: bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 bot._pending_reply_path = os.path.join(directory, "pending.json") bot._pending_reply_sessions = { fp.hex(): { "confirmed_unread": True, "staged_user_image": "shot.png", "created_at": time.time(), "updated_at": time.time(), } } self.assertTrue(bot._persist_pending_replies()) restored = bot._load_pending_replies() self.assertEqual(restored[fp.hex()]["staged_user_image"], "shot.png") def _extract_with_screens(self, screen_lines): """跑一遍逐屏采集，screen_lines 依次是每屏框选到的内容。""" bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 1 bot._activate_wx = mock.Mock(return_value=True) bot._select_visible_chat = mock.Mock(side_effect=list(screen_lines)) scrolls = [] with ( mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.moveTo"), mock.patch( "wechat_bot.pyautogui.scroll", side_effect=lambda amount, *a, **k: scrolls.append(amount), ), mock.patch("wechat_bot.time.sleep"), ): text = bot._extract_chat_text_locked( 1, 100, 100, 800, 600, 10, 500, 400, 130 ) return text, bot._select_visible_chat.call_count, scrolls @staticmethod def _screen_of_body(count, prefix="这是很长的一段留言"): """一屏纯正文，没有任何「发言人+时间」表头。""" return [f"{prefix}{index}" for index in range(count)] def test_a_message_taller_than_one_screen_is_scrolled_up_for(self): """满屏正文却没有表头，说明这条消息的开头还在上面，必须往上翻。 现场（2026-07-31 14:16）：客户发来的长留言超过一屏，增量模式只取一屏 读到的是尾巴，档案里只剩「（首次会话的新消息已由聊天截图确认）」， 模型回了句"这句话没显示完整，您再发一遍吧"。 """ first = self._screen_of_body(wechat_bot.CHAT_FULL_SCREEN_LINES + 4) second = ["高瑞 14:16"] + self._screen_of_body(6, "开头那几句") text, calls, scrolls = self._extract_with_screens([first, second]) self.assertEqual(calls, 2) self.assertIn("高瑞 14:16", text) self.assertIn("开头那几句0", text) # 翻上去之后必须原路滚回底部，否则下一轮停在半空 self.assertTrue(any(amount > 0 for amount in scrolls)) self.assertTrue(any(amount < 0 for amount in scrolls)) def test_a_normal_screen_with_headers_never_scrolls(self): """能看到表头就说明这条消息是完整的，多翻一屏是白白浪费两秒。""" screen = ["高瑞 14:16"] + self._screen_of_body( wechat_bot.CHAT_FULL_SCREEN_LINES + 4 ) _text, calls, scrolls = self._extract_with_screens([screen]) self.assertEqual(calls, 1) self.assertFalse(scrolls) def test_a_sparse_headerless_chat_does_not_trigger_the_search(self): """新会话同样复制不出表头，但它行数很少，不该被当成被截断的长消息。""" _text, calls, scrolls = self._extract_with_screens([["在不在"]]) self.assertEqual(calls, 1) self.assertFalse(scrolls) def test_the_upward_search_gives_up_instead_of_scrolling_forever(self): """对方粘了一整份文档时不能一直翻下去，把这个会话拖死。""" full = self._screen_of_body(wechat_bot.CHAT_FULL_SCREEN_LINES + 4) screens = [ self._screen_of_body( wechat_bot.CHAT_FULL_SCREEN_LINES + 4, f"第{index}屏" ) for index in range(20) ] _text, calls, _scrolls = self._extract_with_screens(screens) self.assertEqual(calls, 1 + WeChatBot._CLIPPED_MESSAGE_EXTRA_SCREENS) self.assertTrue(WeChatBot._newest_message_is_clipped([full])) def test_a_reordered_row_does_not_cost_everyone_else_the_round(self): """刷屏消息把列表搅乱时，打不开的那个会话不能拖着所有人一起等下一轮。 现场（2026-07-31 14:04）：测试消息一密集，红点识别和点击之间列表就重排， 点开的不是目标，于是整轮 break——其他客户全部顺延。 """ bot = WeChatBot.__new__(WeChatBot) stuck = b"x" * 40 served = b"y" * 40 page = self._nav_surface(True) bot.session_item_h = 32 bot.list_region = {"top": 0} bot.list_click_x = 200 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = set() bot._pending_reply_sessions = {} bot._persist_pending_replies = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=page) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=page) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._hold_for_unfinished_active_session = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) bot._row_center_from_badge = mock.Mock(return_value=16) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._last_click_failure_reason = "selected_fingerprint_mismatch" def next_unread(processed_fp, non_conv_fp, full=None): for fp in (stuck, served): if fp not in processed_fp and fp not in non_conv_fp: return page, 16, fp return None bot._find_next_unread_session = mock.Mock(side_effect=next_unread) bot.click_session = mock.Mock(return_value=False) handled = [] bot.handle_session_reply = mock.Mock( side_effect=lambda *a, **k: handled.append(a) ) with mock.patch("wechat_bot.time.sleep"): bot._poll_once() # 打不开的那个被记进本轮跳过集合，扫描才会换人；否则一整轮的名额全耗在它身上 clicked = [call.args[1] if len(call.args) > 1 else call.kwargs["expected_fp"] for call in bot.click_session.call_args_list] self.assertIn(served, clicked) def test_a_real_login_qr_still_stops_everything(self): self.assertTrue( wechat_bot.looks_like_security_verification(self._login_page()) ) def test_dense_chat_text_is_not_a_login_qr(self): """现场（2026-07-31 14:04）：一条带表情的长广告消息让机器人整个停机。 旧判据靠"中央够黑 + 够亮 + 明暗跳变够多"猜二维码，实测这三个数是 0.0254 / 0.9203 / 0.0367，全部刚刚压线过关。密集小字就是长这样。 """ rng = np.random.default_rng(20260731) page = np.full((1320, 2258, 4), 250, dtype=np.uint8) for row in range(120, 1100, 26): for col in range(700, 1900, 11): if rng.random() < 0.55: page[row:row + 13, col:col + 7, :3] = 40 self.assertFalse(wechat_bot.looks_like_security_verification(page)) def test_a_payment_qr_sent_into_a_chat_is_not_a_login_page(self): """客户发一张收款码进来，机器人不能就此罢工等人扫码。""" page = self._login_page(qr_side=220, center=(0.78, 0.5)) self.assertFalse(wechat_bot.looks_like_security_verification(page)) def test_the_message_workspace_overrides_any_qr_on_screen(self): """消息工作区还在，就绝不可能是登录页。""" bot = WeChatBot.__new__(WeChatBot) bot.security_verification_required = False bot._security_log_emitted = False bot.hwnd = 1 bot._message_nav_selected = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=(0, 0, 2258, 1320)), mock.patch( "wechat_bot.capture_window_region", return_value=self._login_page(), ), ): self.assertFalse(bot._security_gate_visible()) self.assertFalse(bot.security_verification_required) def test_a_login_page_without_a_workspace_locks_the_bot(self): bot = WeChatBot.__new__(WeChatBot) bot.security_verification_required = False bot._security_log_emitted = False bot._window_ready = True bot.hwnd = 1 bot._message_nav_selected = mock.Mock(return_value=False) with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=(0, 0, 2258, 1320)), mock.patch( "wechat_bot.capture_window_region", return_value=self._login_page(), ), ): self.assertTrue(bot._security_gate_visible()) self.assertTrue(bot.security_verification_required) def test_a_subscription_row_is_evicted_from_the_queue(self): """指纹分毫不差、但这一行根本不是聊天：再等下去也不会变。 现场探针（2026-07-31 12:47）：打卡和行业资讯两个任务，头像与名称哈希 距离都是 0，被 _is_real_conversation 否掉，于是队列每一轮都为它们做一次 全列表分页扫描（6 个任务 21 秒），真正的客户全排在后面。 """ bot = WeChatBot.__new__(WeChatBot) fp = b"s" * 40 bot._composerless_strikes = {} bot._unrepliable_sessions = {} bot._persist_unrepliable_sessions = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._note_unclickable_pending(fp) self.assertFalse(bot._unrepliable_sessions) bot._clear_reply_pending.assert_not_called() bot._note_unclickable_pending(fp) self.assertIn(fp.hex(), bot._unrepliable_sessions) bot._clear_reply_pending.assert_called_once_with(fp) bot._persist_unrepliable_sessions.assert_called_once() def test_a_reopened_row_clears_its_own_strikes(self): """真会话偶尔判错一次，不能因此被误判成订阅号。""" bot = WeChatBot.__new__(WeChatBot) fp = b"t" * 40 bot._composerless_strikes = {} bot._unrepliable_sessions = {} bot._persist_unrepliable_sessions = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._composer_geometry_valid = True bot._note_unclickable_pending(fp) self.assertTrue(bot._session_accepts_replies(fp)) self.assertNotIn(fp.hex(), bot._composerless_strikes) bot._note_unclickable_pending(fp) self.assertFalse(bot._unrepliable_sessions) def test_a_task_with_no_matching_row_anywhere_expires(self): """列表里找不到对应会话的空壳任务不能永远占着队列。""" bot = WeChatBot.__new__(WeChatBot) fp = b"g" * 40 bot._clear_reply_pending = mock.Mock() state = {"resume_failures": bot._UNREACHABLE_RESUME_FAILURES - 1} self.assertFalse(bot._expire_unreachable_pending(fp, state)) bot._clear_reply_pending.assert_not_called() state["resume_failures"] = bot._UNREACHABLE_RESUME_FAILURES self.assertTrue(bot._expire_unreachable_pending(fp, state)) bot._clear_reply_pending.assert_called_once_with(fp) def test_a_findable_task_never_expires_on_a_bad_count(self): bot = WeChatBot.__new__(WeChatBot) bot._clear_reply_pending = mock.Mock() self.assertFalse( bot._expire_unreachable_pending(b"h" * 40, {"resume_failures": "坏值"}) ) bot._clear_reply_pending.assert_not_called() def test_an_unchanged_screen_is_never_taken_as_a_send(self): reply = "你好呀，我是贴心管家" bot = self._receipt_bot(f"你好\n{reply}", surface_changed=False) self.assertIs(bot._raw_text_receipt_matches(reply, "你好", b"before"), False) def test_a_baseline_already_holding_the_reply_proves_nothing(self): """基线里已经有这句话，发送前后长得一样，证明不了任何事。""" reply = "你好呀，我是贴心管家" bot = self._receipt_bot(f"你好\n{reply}") self.assertIsNone( bot._raw_text_receipt_matches(reply, f"你好 {reply}", b"before") ) self.assertFalse(bot._raw_text_anchor_usable(f"你好 {reply}", reply)) def test_an_empty_baseline_never_unlocks_the_raw_anchor(self): """完全读不到聊天内容时不能放行，否则等于取消了重复发送保护。""" bot = WeChatBot.__new__(WeChatBot) self.assertFalse(bot._raw_text_anchor_usable("", "你好呀")) self.assertFalse(bot._raw_text_anchor_usable("你好", "")) def test_the_raw_anchor_survives_a_restart(self): """重启后还要能核对回执，否则任务只能挂成待核对、客户白等。""" bot = WeChatBot.__new__(WeChatBot) handle, path = tempfile.mkstemp(suffix=".json") os.close(handle) self.addCleanup(lambda: os.path.exists(path) and os.unlink(path)) fp = bytes.fromhex("aa" * 40) bot._pending_reply_path = path bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "send_state": "sent_uncommitted", "send_baseline_text": "你好", "created_at": time.time(), "updated_at": time.time(), } } self.assertTrue(bot._persist_pending_replies()) restored = WeChatBot._load_pending_replies(bot) self.assertEqual(restored[fp.hex()]["send_baseline_text"], "你好") def test_block_anchors_keep_their_own_proven_path(self): """有消息块时必须走原来的路径，裸文本只在没有块时兜底。""" bot = WeChatBot.__new__(WeChatBot) called = [] bot._raw_text_receipt_matches = lambda *a, **k: called.append(a) or True bot._visible_last_message_matches = lambda *a, **k: None result = bot._send_receipt_matches( reply_text="你好呀", customer_speaker="", before_surface=b"before", before_blocks=[["高瑞 7/31 12:00:00", "你好"]], before_text="你好", ) self.assertEqual(called, []) self.assertIsNone(result) # ── 机器人自己遗留的草稿，不能当成人工草稿一路让路 ────────────────────── # 现场（2026-07-31 12:11）：上一轮贴好草稿后被中途打断，草稿留在输入框里。 # 下一轮机器人认不出这是自己写的，判成人工草稿取消发送，这个会话从此 # 每轮都调一次模型、又每轮都让路，客户永远等不到回复。 def test_our_own_abandoned_draft_is_cleared_and_resent(self): bot = WeChatBot.__new__(WeChatBot) reply = "在呢，您有什么事就直接说，我这边看着呢" # 调用方传进来的永远是归一化后的草稿（全角标点已折半），这里照做 draft = bot._normalized_message_text(reply) state = {"staged_reply_text": reply, "send_state": ""} self.assertTrue(bot._draft_is_our_own(draft, state, reply)) def test_last_round_wording_is_still_recognised_as_ours(self): """模型每轮换一种说法，只比对新回复就永远认不出框里那句是自己写的。""" bot = WeChatBot.__new__(WeChatBot) stale = "在呢，您有什么事慢慢说，我这边听着呢" fresh = "在呢，您说，我这边听着" state = { "staged_reply_text": fresh, "last_pasted_draft": bot._normalized_message_text(stale), "send_state": "", } draft = bot._normalized_message_text(stale) self.assertTrue(bot._draft_is_our_own(draft, state, fresh)) def test_a_human_sentence_still_stops_the_bot_cold(self): bot = WeChatBot.__new__(WeChatBot) reply = "在呢，您有什么事就直接说" state = {"staged_reply_text": reply, "send_state": ""} draft = bot._normalized_message_text("我自己来回这条") self.assertFalse(bot._draft_is_our_own(draft, state, reply)) def test_a_dispatched_transaction_keeps_its_draft_untouched(self): """已经按过回车的事务归回执核对管，这里清掉再发就是重复发送。""" bot = WeChatBot.__new__(WeChatBot) reply = "在呢，您有什么事就直接说" draft = bot._normalized_message_text(reply) state = {"staged_reply_text": reply, "send_state": "sent_uncommitted"} self.assertFalse(bot._draft_is_our_own(draft, state, reply)) def test_a_session_without_a_task_never_gets_its_draft_wiped(self): bot = WeChatBot.__new__(WeChatBot) self.assertFalse(bot._draft_is_our_own("随便什么字", {}, "机器人的回复")) self.assertFalse(bot._draft_is_our_own("随便什么字", None, "机器人的回复")) # ── 只有一两条消息的新会话，框选起点必须落在真正有字的地方 ────────────── # 现场（2026-07-31 11:51）：新客户只发了一句“在不在”，气泡贴在聊天区最顶 # 上，其余全是空白。两条固定边距的拖拽路径都按在空白上，锚不到文字， # “两次框选均为空”。复制不到就只能走视觉，视觉文本没有“发言人+时间”表头， # 发送前锚点建不起来，于是不停调模型又不停取消，客户永远等不到回复。 def _ink_bot(self, chat_image): bot = WeChatBot.__new__(WeChatBot) bot.L, bot.T = 100, 200 bot.hwnd = 1 bot.scale = 1.0 return bot, mock.patch.object( wechat_bot, "capture_window_region", return_value=chat_image, ) @staticmethod def _sparse_chat_image(height=800, width=600, bubble_bottom=60): """顶部一条气泡，其余全是背景色——新会话的真实样子。""" img = np.full((height, width, 4), 246, dtype=np.uint8) img[10:bubble_bottom, 40:160, :3] = 40 return img def test_the_lone_bubble_at_the_top_is_found(self): image = self._sparse_chat_image() bot, patcher = self._ink_bot(image) with patcher: bounds = bot._chat_ink_bounds(100, 200, 600, 800) self.assertIsNotNone(bounds) ink_top, ink_bottom = bounds # 屏幕坐标 = 区域左上角 + 墨迹行号 self.assertEqual(ink_top, 200 + 10) self.assertEqual(ink_bottom, 200 + 59) def test_an_empty_chat_reports_no_ink_instead_of_guessing(self): image = np.full((800, 600, 4), 246, dtype=np.uint8) bot, patcher = self._ink_bot(image) with patcher: self.assertIsNone(bot._chat_ink_bounds(100, 200, 600, 800)) def test_the_scrollbar_gutter_never_counts_as_a_message(self): """右缘滚动条会随鼠标淡入淡出，算进墨迹就会把范围撑满整个面板。""" image = np.full((800, 600, 4), 246, dtype=np.uint8) image[:, -6:, :3] = 120 bot, patcher = self._ink_bot(image) with patcher: self.assertIsNone(bot._chat_ink_bounds(100, 200, 600, 800)) def test_a_sparse_chat_tries_the_ink_anchored_drag_first(self): """消息稀疏时先走墨迹路径，省下两次注定选空的拖拽。""" bot, patcher = self._ink_bot(self._sparse_chat_image()) attempts = [] bot._drag_select = lambda x1, y1, x2, y2, steps=12: attempts.append((y1, y2)) bot._copy_selection = lambda: "" with patcher: bot._select_visible_chat(100, 200, 600, 800, 20, 230) # 起点仍被钳在 top+margin：那道边距是防止拖到聊天区外触发历史翻页。 # 气泡跨 210~259，钳到 220 依然落在字上，锚得住 self.assertEqual(attempts[0], (200 + 20, 200 + 57)) def test_a_full_chat_keeps_the_proven_path_first(self): """消息占满面板时不改动既有顺序，墨迹路径只当兜底。""" image = np.full((800, 600, 4), 246, dtype=np.uint8) image[10:790, 40:560, :3] = 40 bot, patcher = self._ink_bot(image) attempts = [] bot._drag_select = lambda x1, y1, x2, y2, steps=12: attempts.append((y1, y2)) bot._copy_selection = lambda: "" with patcher: bot._select_visible_chat(100, 200, 600, 800, 20, 230) self.assertEqual(attempts[0], (200 + 800 - 20, 230)) self.assertEqual(len(attempts), 3) def test_a_working_first_drag_never_costs_a_second_one(self): bot, patcher = self._ink_bot(self._sparse_chat_image()) attempts = [] bot._drag_select = lambda x1, y1, x2, y2, steps=12: attempts.append((y1, y2)) bot._copy_selection = lambda: "高瑞@微信 7/31 11:51:00\n在不在" with patcher: lines = bot._select_visible_chat(100, 200, 600, 800, 20, 230) self.assertEqual(len(attempts), 1) self.assertEqual(lines, ["高瑞@微信 7/31 11:51:00", "在不在"]) def test_a_recovered_copy_rebuilds_the_missing_send_anchor(self): """带表头的复制文本必须能解析出锚点——这正是发送被卡住的那一步。""" bot = WeChatBot.__new__(WeChatBot) self.assertEqual(bot._normalized_copied_blocks("在不在"), []) blocks = bot._normalized_copied_blocks( "高瑞@微信@微信联系人 7/31 11:51:00\n在不在" ) self.assertEqual(len(blocks), 1) self.assertEqual(blocks[0][1], "在不在") def test_a_composed_reply_waits_out_the_last_seconds_of_spacing(self): """回复已经生成就不能因为还差几秒发送间隔被丢掉，下一轮要从头再调模型。""" bot = WeChatBot.__new__(WeChatBot) remaining = [1.0, 1.0, 0.0] bot._send_gate_open = lambda: False bot._send_gate_remaining = lambda: remaining.pop(0) if remaining else 0.0 self.assertTrue(bot._await_send_gate()) def test_a_long_rate_limit_still_leaves_the_task_for_later(self): """分钟/小时配额用尽时不能原地干等，必须放行让轮询继续跑。""" bot = WeChatBot.__new__(WeChatBot) bot._send_gate_open = lambda: False bot._send_gate_remaining = lambda: bot._SEND_GATE_WAIT_BUDGET_SECONDS + 30.0 self.assertFalse(bot._await_send_gate()) def _hold_bot(self, active_fp: bytes, pending: dict): bot = WeChatBot.__new__(WeChatBot) bot._active_session_fp = active_fp bot._pending_reply_sessions = pending bot._active_hold_key = "" bot._active_hold_since = 0.0 bot._active_hold_expired = False return bot def test_an_unfinished_session_keeps_the_round_to_itself(self): """当前会话没回完，本轮不能掉进未读扫描去点开别人。""" fp = bytes.fromhex("aa" * 40) bot = self._hold_bot(fp, {fp.hex(): {"confirmed_unread": True}}) self.assertTrue(bot._hold_for_unfinished_active_session()) self.assertTrue(bot._hold_for_unfinished_active_session()) def test_a_finished_session_releases_the_round_at_once(self): """回完就立刻放行，排队的会话不该多等一轮。""" fp = bytes.fromhex("aa" * 40) pending = {fp.hex(): {"confirmed_unread": True}} bot = self._hold_bot(fp, pending) self.assertTrue(bot._hold_for_unfinished_active_session()) pending.clear() self.assertFalse(bot._hold_for_unfinished_active_session()) def test_a_stuck_session_stops_blocking_everyone_else(self): """真卡住的会话必须到点放行，否则后面排队的客户一起陪葬。""" fp = bytes.fromhex("aa" * 40) bot = self._hold_bot(fp, {fp.hex(): {"confirmed_unread": True}}) self.assertTrue(bot._hold_for_unfinished_active_session()) bot._active_hold_since -= bot._ACTIVE_SESSION_HOLD_SECONDS + 1.0 self.assertFalse(bot._hold_for_unfinished_active_session()) # 放行之后不能再反复压住：同一个会话不该每 60 秒又独占一次 self.assertFalse(bot._hold_for_unfinished_active_session()) def test_switching_sessions_starts_a_fresh_hold(self): """换到下一个会话时重新计时，不继承上一个会话烧掉的额度。""" first = bytes.fromhex("aa" * 40) second = bytes.fromhex("bb" * 40) pending = {first.hex(): {}, second.hex(): {}} bot = self._hold_bot(first, pending) self.assertTrue(bot._hold_for_unfinished_active_session()) bot._active_hold_since -= bot._ACTIVE_SESSION_HOLD_SECONDS + 1.0 self.assertFalse(bot._hold_for_unfinished_active_session()) bot._active_session_fp = second self.assertTrue(bot._hold_for_unfinished_active_session()) # ── 订阅号/系统号没有输入框，不能一直占着回复队列 ────────────────────── # 现场（2026-07-31 11:04）：“行业资讯”订阅号的聊天页没有输入框，机器人每轮 # 都把它重新打开、调一次视觉模型，再卡在“无法确认消息区与输入区分隔线”上。 # 队列里 7 条待回复有 3 条是这种永远完不成的任务，真客户被挤到后面。 def _composer_bot(self): bot = WeChatBot.__new__(WeChatBot) handle, path = tempfile.mkstemp(suffix=".json") os.close(handle) os.unlink(path) self.addCleanup( lambda: os.path.exists(path) and os.unlink(path) ) bot._unrepliable_path = path bot._unrepliable_sessions = {} bot._composerless_strikes = {} bot._pending_reply_path = "" bot._pending_reply_sessions = {} bot._pending_scan_progress = {} bot._pending_exchanges = {} return bot def test_a_page_without_a_composer_leaves_the_reply_queue(self): bot = self._composer_bot() fp = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME bot._pending_reply_sessions[fp.hex()] = {"confirmed_unread": True} bot._composer_geometry_valid = False for _ in range(bot._COMPOSERLESS_STRIKES): self.assertFalse(bot._session_accepts_replies(fp)) # 判定之后：任务出队、后续轮次直接跳过，不再重复调用模型 self.assertNotIn(fp.hex(), bot._pending_reply_sessions) self.assertTrue(bot._session_is_unrepliable(fp)) self.assertFalse(bot._session_accepts_replies(fp)) def test_one_bad_frame_never_silences_a_real_contact(self): """单帧没渲染完不能把真客户静默移出队列。""" bot = self._composer_bot() fp = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME bot._composer_geometry_valid = False self.assertFalse(bot._session_accepts_replies(fp)) bot._composer_geometry_valid = True self.assertTrue(bot._session_accepts_replies(fp)) # 计数已清零：再连续失败仍需攒满整轮才判定 bot._composer_geometry_valid = False for _ in range(bot._COMPOSERLESS_STRIKES - 1): self.assertFalse(bot._session_accepts_replies(fp)) self.assertFalse(bot._session_is_unrepliable(fp)) def test_the_filter_rechecks_itself_after_the_cooldown(self): """企微改版或误判时必须能自己走回来。""" bot = self._composer_bot() fp = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME bot._unrepliable_sessions[fp.hex()] = ( time.time() - bot._UNREPLIABLE_RECHECK_SECONDS - 1.0 ) self.assertFalse(bot._session_is_unrepliable(fp)) bot._composer_geometry_valid = True self.assertTrue(bot._session_accepts_replies(fp)) def test_cross_monitor_window_is_detected_even_when_its_center_monitor_is_valid(self): """The field failure spans a 200% laptop and a 100% external panel.""" monitors = [ (0, 0, 1536, 960), (3072, 0, 4992, 1080), ] # Exact geometry from the 2026-08-18 field log. Looking only at the # centre/nearest monitor missed this split and left the composer offset. self.assertTrue( window_spans_multiple_displays( (1387, 474, 4359, 1774), monitors, ) ) # In a per-monitor-aware Python process the same physical arrangement # exposes doubled monitor coordinates, while virtualized WeCom keeps # reporting the rectangle above. Its external-screen half therefore # lands in a numeric gap and must still be treated as unsafe. self.assertTrue( window_spans_multiple_displays( (1387, 474, 4359, 1774), [(0, 0, 3072, 1920), (6144, 0, 9984, 2160)], ) ) self.assertFalse( window_spans_multiple_displays( (40, 20, 1496, 912), monitors, ) ) def test_cross_monitor_window_is_resized_entirely_inside_primary_work_area(self): x, y, width, height = fit_window_inside_work_area( (1387, 474, 4359, 1774), (0, 0, 1536, 912), ) self.assertGreaterEqual(x, 0) self.assertGreaterEqual(y, 0) self.assertLessEqual(x + width, 1536) self.assertLessEqual(y + height, 912) self.assertGreaterEqual(width, 640) self.assertGreaterEqual(height, 480) def test_open_customer_recaptures_geometry_before_composer_filter(self): bot = self._composer_bot() bot.hwnd = 1 fp = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME bot._composer_geometry_valid = False bot._input_geometry_valid = False bot.report_operation = mock.Mock() bot._capture_full_window = mock.Mock( return_value=np.zeros((720, 1280, 4), dtype=np.uint8) ) def recover(_full): bot._composer_geometry_valid = True bot._input_geometry_valid = True return True bot._refresh_message_geometry = mock.Mock(side_effect=recover) bot._maximize_window_for_composer = mock.Mock(return_value=False) bot._run_ai_layout_guard = mock.Mock(return_value=False) self.assertTrue(bot._session_accepts_replies(fp)) bot._capture_full_window.assert_called_once() bot._refresh_message_geometry.assert_called_once() bot._run_ai_layout_guard.assert_not_called() self.assertNotIn(fp.hex(), bot._composerless_strikes) def test_visual_model_link_error_preserves_real_customer_task(self): bot = self._composer_bot() bot.hwnd = 1 fp = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME bot._pending_reply_sessions[fp.hex()] = {"confirmed_unread": True} bot._composer_geometry_valid = False bot._input_geometry_valid = False bot.report_operation = mock.Mock() bot._capture_full_window = mock.Mock( return_value=np.zeros((720, 1280, 4), dtype=np.uint8) ) bot._refresh_message_geometry = mock.Mock(return_value=False) bot._maximize_window_for_composer = mock.Mock(return_value=False) def link_error(*_args, **_kwargs): bot._last_layout_guard_outcome = "link_error" return False bot._run_ai_layout_guard = mock.Mock(side_effect=link_error) for _ in range(bot._COMPOSERLESS_STRIKES + 2): self.assertFalse(bot._session_accepts_replies(fp)) self.assertIn(fp.hex(), bot._pending_reply_sessions) self.assertNotIn(fp.hex(), bot._composerless_strikes) self.assertFalse(bot._session_is_unrepliable(fp)) def test_a_far_avatar_under_the_same_name_is_still_a_different_row(self): """名称相同也不能无条件放行；头像彻底不同仍必须拒绝。""" bot = self._fp_bot() near = self._DRIFT_AVATAR_BEFORE + self._DRIFT_NAME far = bytes.fromhex("ffffffffffffffff") + self._DRIFT_NAME self.assertFalse(bot._session_fp_matches(near, far)) def test_close_avatars_with_different_names_never_match(self): """现场最接近的一对不同联系人（头像仅差 10 位）必须继续被分开。""" bot = self._fp_bot() left = bytes.fromhex("18181810151d1f1f") + bytes.fromhex("017b0163") + b"\x5a" * 28 right = self._DRIFT_AVATAR_AFTER + self._DRIFT_NAME avatar_distance = ( int.from_bytes(left[:8], "big") ^ int.from_bytes(right[:8], "big") ).bit_count() self.assertLessEqual(avatar_distance, bot._FP_HAMMING_TOL_NAMED) self.assertFalse(bot._session_fp_matches(left, right)) def test_a_blank_name_hash_falls_back_to_the_strict_avatar_tolerance(self): """名称采不到字时它什么都证明不了，头像必须回到严格容差。""" bot = self._fp_bot() blank = b"\x00" * 32 left = self._DRIFT_AVATAR_BEFORE + blank right = self._DRIFT_AVATAR_AFTER + blank self.assertFalse(bot._name_fp_is_substantive(blank)) self.assertFalse(bot._session_fp_matches(left, right)) # 同样一片空白的名称下，头像足够接近时仍然照旧放行。 near = bytes( self._DRIFT_AVATAR_BEFORE[:7] + bytes([self._DRIFT_AVATAR_BEFORE[7] ^ 0b11]) ) + blank self.assertTrue(bot._session_fp_matches(left, near)) def test_calibration_gate_keeps_warning_instead_of_going_silent(self): """闸门关闭 = 自动回复完全停摆，绝不能只吭一声就静默。""" bot = WeChatBot.__new__(WeChatBot) bot._nav_width_confirmed = False bot._nav_width_gate_logged = 0.0 bot._nav_width_gate_since = 0.0 def gate_output(now): buffer = io.StringIO() with mock.patch("wechat_bot.time.monotonic", return_value=now): with redirect_stdout(buffer): self.assertFalse(bot._session_identity_trustworthy()) return buffer.getvalue() self.assertIn("自动回复已暂停", gate_output(1000.0)) # 紧接着的轮次不刷屏。 self.assertEqual(gate_output(1005.0), "") # 但停摆持续下去必须继续告警，并报出已经停了多久。 later = gate_output(1040.0) self.assertIn("自动回复已暂停 40 秒", later) bot._nav_width_confirmed = True self.assertTrue(bot._session_identity_trustworthy()) # 恢复后重新计时，下次停摆立刻重新告警。 bot._nav_width_confirmed = False self.assertIn("自动回复已暂停 0 秒", gate_output(2000.0)) def test_low_confidence_frame_never_revokes_a_confirmed_navigation_width(self): """置信度不足时沿用已生效宽度，因此不能撤销既有的确认结论。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.L = bot.T = 0 bot.R, bot.B = 1200, 800 bot._list_x = 320 bot._composer_rel_top = 600 bot._composer_geometry_valid = True bot._nav_width_confirmed = True full = np.zeros((800, 1200, 4), dtype=np.uint8) with mock.patch( "wechat_bot.infer_navigation_width", return_value=(68, 0.0), ), mock.patch( "wechat_bot.infer_composer_top", return_value=600, ): bot._refresh_message_geometry(full) self.assertEqual(bot._list_x, 320) self.assertTrue(bot._nav_width_confirmed) def test_navigation_geometry_is_committed_before_a_chat_composer_exists(self): """消息首页没有选中会话时也必须先校准列表，才能找到并打开未读客户。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L = bot.T = 0 bot.R, bot.B = 2200, 1300 bot._list_x = 136 bot._nav_width_confirmed = False bot._selected_tracking_initialized = True bot._active_session_fp = b"old" bot._active_chat_signature = b"old" bot._active_identity_signature = b"old" full = np.zeros((1300, 2200, 4), dtype=np.uint8) with mock.patch( "wechat_bot.infer_navigation_width", return_value=(320, 0.9), ), mock.patch( "wechat_bot.infer_composer_top", return_value=None, ): self.assertTrue(bot._refresh_message_geometry(full)) self.assertEqual(bot._list_x, 320) self.assertEqual(bot.list_region["left"], 320) self.assertTrue(bot._nav_width_confirmed) self.assertTrue(bot._session_geometry_valid) self.assertFalse(bot._composer_geometry_valid) self.assertFalse(bot._selected_tracking_initialized) def test_semantic_layout_hint_still_requires_local_pixel_boundaries(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L = bot.T = 0 bot.R, bot.B = 2200, 1300 bot._list_x = 136 bot._list_w = 460 bot._nav_width_confirmed = False bot._selected_tracking_initialized = False bot._active_session_fp = None bot._active_chat_signature = None bot._active_identity_signature = None full = np.full((1300, 2200, 4), 245, dtype=np.uint8) full[:, :, 3] = 255 full[:, :320, :3] = 225 full[:, 320:820, :3] = 248 full[:, 820:, :3] = 238 hint = { "navigation_right_ratio": 320 / 2200, "session_list_right_ratio": 820 / 2200, "composer_top_ratio": 1000 / 1300, } with ( mock.patch("wechat_bot.infer_navigation_width", return_value=(136, 0.0)), mock.patch("wechat_bot.infer_session_list_width", return_value=(460, 0.0)), mock.patch("wechat_bot.infer_composer_top", return_value=None), mock.patch("wechat_bot.composer_divider_matches", return_value=(True, 1000)), ): self.assertTrue(bot._refresh_message_geometry(full, semantic_hint=hint)) self.assertEqual(bot._list_x, 320) self.assertEqual(bot._list_w, 500) self.assertEqual(bot._composer_rel_top, 1000) self.assertTrue(bot._nav_width_confirmed) self.assertTrue(bot._composer_geometry_valid) def test_avatar_anchor_keeps_the_caller_estimate_without_a_lattice(self): """看不出行距时宁可沿用调用方的估算，不能凭单个色块乱吸附。""" bot = self._fingerprint_bot() blank = np.full((320, 460, 4), 245, dtype=np.uint8) blank[:, :, 3] = 255 self.assertEqual(bot._avatar_anchor(blank, 137), 137) single = blank.copy() for y in range(24, 104): for x in range(20, 88): single[y, x, :3] = ((x * 3) % 255, (y * 5) % 255, (x + y) % 255) self.assertEqual(bot._avatar_anchor(single, 137), 137) def test_unread_badge_disappearing_does_not_change_flat_contact_key(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() base = np.full((160, 460, 4), 245, dtype=np.uint8) base[:, :, 3] = 255 # 纯色文字头像 + 两个深色名称字形块。 base[20:108, 22:108, :3] = (220, 120, 30) base[42:82, 56:70, :3] = 250 base[26:56, 122:150, :3] = 25 base[30:52, 164:194, :3] = 25 unread = base.copy() yy, xx = np.ogrid[:unread.shape[0], :unread.shape[1]] # 多位数未读徽章会越过头像右边缘，覆盖名称第一字左上/下缘。 badge = (xx - 116) ** 2 + (yy - 32) ** 2 <= 20 ** 2 unread[badge, :3] = (55, 55, 245) unread[26:39, 107:125, :3] = 250 selected = base.copy() selected[:, -24:, :3] = (238, 126, 36) before = bot._session_fingerprint(unread, 32) after = bot._session_fingerprint(selected, 64, row_center=True) self.assertEqual(before, after) def test_same_avatar_with_different_row_names_gets_distinct_session_keys(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() first = np.full((160, 460, 4), 245, dtype=np.uint8) second = first.copy() first[:, :, 3] = 255 second[:, :, 3] = 255 # 完全相同的头像。 for image in (first, second): for y in range(40, 88): for x in range(20, 84): image[y, x, :3] = ((x * 3) % 255, (y * 5) % 255, (x + y) % 255) # 名称首行字形位置不同，模拟两个使用相同头像的联系人。 first[26:56, 122:158, :3] = 25 first[32:50, 174:210, :3] = 25 second[26:56, 226:262, :3] = 25 second[32:50, 278:314, :3] = 25 first_fp = bot._session_fingerprint(first, 64, row_center=True) second_fp = bot._session_fingerprint(second, 64, row_center=True) self.assertEqual(len(first_fp), 40) self.assertEqual(first_fp[:8], second_fp[:8]) self.assertNotEqual(first_fp, second_fp) def test_same_avatar_short_names_with_different_first_character_stay_distinct(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() first = np.full((160, 460, 4), 245, dtype=np.uint8) second = first.copy() first[:, :, 3] = 255 second[:, :, 3] = 255 for image in (first, second): image[40:88, 20:84, :3] = 90 # 相同的第二个字。 image[28:55, 174:210, :3] = 20 # 仅首字底部字形不同，覆盖名称前缀安全采样条。 first[48:55, 126:142, :3] = 20 first[51:58, 146:158, :3] = 20 second[51:58, 126:142, :3] = 20 second[48:55, 146:158, :3] = 20 first_fp = bot._session_fingerprint(first, 64, row_center=True) second_fp = bot._session_fingerprint(second, 64, row_center=True) self.assertNotEqual(first_fp, second_fp) self.assertFalse(bot._remember_live_render_alias(first_fp, second_fp)) def test_same_name_is_stable_between_normal_and_selected_row_colors(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() normal = np.full((160, 460, 4), 245, dtype=np.uint8) selected = np.full((160, 460, 4), (210, 130, 45, 255), dtype=np.uint8) normal[:, :, 3] = 255 for image in (normal, selected): for y in range(40, 88): for x in range(20, 84): image[y, x, :3] = ((x * 3) % 255, (y * 5) % 255, (x + y) % 255) normal[28:54, 124:154, :3] = 20 normal[30:56, 170:204, :3] = 20 selected[28:54, 124:154, :3] = 250 selected[30:56, 170:204, :3] = 250 normal_fp = bot._session_fingerprint(normal, 64, row_center=True) selected_fp = bot._session_fingerprint(selected, 64, row_center=True) self.assertEqual(normal_fp, selected_fp) def test_persisted_name_hash_keeps_established_40_byte_key_layout(self): """Do not silently reinterpret existing conversations.json keys.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 image = np.full((160, 460, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 image[28:54, 124:154, :3] = 20 image[30:56, 170:204, :3] = 20 self.assertEqual( bot._session_name_fingerprint(image, 64, row_center=True).hex(), "7ff07ff0000000000000007c00007c00007c00007c00007c00007c00007c0000", ) def test_unread_bold_name_and_selected_regular_name_keep_same_identity(self): """WeCom removes unread bold weight when the row becomes selected.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() unread = np.full((160, 460, 4), 245, dtype=np.uint8) selected = np.full((160, 460, 4), (210, 130, 45, 255), dtype=np.uint8) unread[:, :, 3] = 255 for image in (unread, selected): for y in range(40, 88): for x in range(20, 84): image[y, x, :3] = ( (x * 3) % 255, (y * 5) % 255, (x + y) % 255, ) # Same glyph centre-lines. The unread rendering is five pixels wider; # the selected rendering uses the normal three-pixel font weight. unread[27:56, 178:187, :3] = 20 unread[34:44, 168:204, :3] = 20 unread[28:56, 224:233, :3] = 20 unread[45:55, 216:246, :3] = 20 selected[29:54, 181:184, :3] = 250 selected[37:40, 171:201, :3] = 250 selected[30:54, 227:230, :3] = 250 selected[48:51, 219:243, :3] = 250 unread_fp = bot._session_fingerprint(unread, 64, row_center=True) selected_fp = bot._session_fingerprint(selected, 64, row_center=True) distance = ( int.from_bytes(unread_fp[8:], "big") ^ int.from_bytes(selected_fp[8:], "big") ).bit_count() # The established 40-byte archive key must not be redefined merely to # absorb a font-weight change. The immediately observed unread and # selected rows are linked by a process-local render proof instead. self.assertTrue( bot._remember_live_render_alias(unread_fp, selected_fp), ( f"name distance={distance}, " f"unread_render={bot._live_render_ids_for(unread_fp)}, " f"selected_render={bot._live_render_ids_for(selected_fp)}" ), ) self.assertTrue(bot._session_fp_matches(unread_fp, selected_fp)) def test_unread_badge_and_dynamic_time_do_not_change_session_identity(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() unread = np.full((160, 460, 4), 245, dtype=np.uint8) selected = np.full((160, 460, 4), (210, 130, 45, 255), dtype=np.uint8) unread[:, :, 3] = 255 for image in (unread, selected): image[40:88, 20:84, :3] = 90 # 名称位于固定名称带；未读红点在头像右上，右侧时间每天都会变化。 unread[28:55, 170:220, :3] = 20 selected[28:55, 170:220, :3] = 250 unread[18:48, 70:146, :3] = (35, 45, 235) unread[30:50, 350:420, :3] = 80 selected[30:50, 340:430, :3] = 250 self.assertEqual( bot._session_fingerprint(unread, 64, row_center=True), bot._session_fingerprint(selected, 64, row_center=True), ) def test_typing_status_below_title_does_not_change_chat_identity(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.scale = 2.0 bot.L, bot.R = 0, 1800 bot._list_x = 136 bot._list_w = 460 idle = np.full((112, 1000, 4), 245, dtype=np.uint8) typing = idle.copy() idle[:, :, 3] = 255 typing[:, :, 3] = 255 idle[22:54, 50:210, :3] = 30 typing[22:54, 50:210, :3] = 30 typing[76:100, 50:190, :3] = 80 with mock.patch( "wechat_bot.capture_window_region", side_effect=[idle, typing], ): self.assertEqual( bot._chat_identity_signature(), bot._chat_identity_signature(), ) def test_same_avatar_long_common_name_prefix_keeps_distinct_suffixes(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() first = np.full((160, 460, 4), 245, dtype=np.uint8) second = first.copy() first[:, :, 3] = 255 second[:, :, 3] = 255 for image in (first, second): image[40:88, 20:84, :3] = 90 # 相同的长公共前缀。 image[28:54, 122:282, :3] = 25 # 名称末尾不同，且都位于动态时间左侧。 first[26:38, 296:326, :3] = 25 first[44:56, 330:360, :3] = 25 second[44:56, 296:326, :3] = 25 second[26:38, 330:360, :3] = 25 first_fp = bot._session_fingerprint(first, 64, row_center=True) second_fp = bot._session_fingerprint(second, 64, row_center=True) self.assertNotEqual(first_fp, second_fp) def test_same_avatar_names_differing_at_last_visible_character_stay_distinct(self): """The final name glyph before the time column is part of session identity.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._known_fps = set() bot._known_session_fps = set() first = np.full((160, 460, 4), 245, dtype=np.uint8) second = first.copy() first[:, :, 3] = 255 second[:, :, 3] = 255 for image in (first, second): image[40:88, 20:84, :3] = 90 # Identical long visible prefix through logical x=160. image[28:54, 122:320, :3] = 25 # The last visible glyph lives before the x=170 time-column boundary. first[28:38, 322:338, :3] = 25 second[44:54, 322:338, :3] = 25 first_fp = bot._session_fingerprint(first, 64, row_center=True) second_fp = bot._session_fingerprint(second, 64, row_center=True) self.assertNotEqual(first_fp, second_fp) self.assertFalse(bot._remember_live_render_alias(first_fp, second_fp)) def test_mixed_legacy_and_composite_keys_never_match_by_avatar_only(self): bot = WeChatBot.__new__(WeChatBot) self.assertFalse( bot._session_fp_matches(b"a" * 8, b"a" * 8 + b"b" * 32) ) def test_legacy_archive_is_moved_once_after_composite_identity_is_known(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.entry_snapshot.side_effect = [ None, { "last_lines": [ "高兴亮 7/28 08:59:00", "已回复", "客户甲 7/28 09:00:00", "旧问题", ], "history": [ {"role": "assistant", "content": "已回复"}, { "role": "user", "content": ( "高兴亮 7/28 08:59:00\n已回复\n" "客户甲 7/28 09:00:00\n旧问题" ), }, ], }, ] bot.store.migrate_key.return_value = True bot._legacy_migration_checked = set() fp = b"avatar01" + b"n" * 32 chat_text = ( "高兴亮 7/29 09:59:00\n已回复\n" "客户甲 7/29 10:00:00\n新问题" ) with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): bot._ensure_session_archive_key(fp, chat_text) bot._ensure_session_archive_key(fp, chat_text) bot.store.migrate_key.assert_called_once_with( b"avatar01".hex(), fp.hex(), ) def test_previous_16_byte_archive_is_preferred_over_avatar_only_archive(self): bot = WeChatBot.__new__(WeChatBot) avatar = b"avatar01" old16 = avatar + b"oldname1" current = avatar + b"N" * 32 legacy_entry = { "last_lines": [ "客户甲 7/28 09:00:00", "旧问题", "高兴亮 7/28 09:01:00", "已回复", ], "history": [ {"role": "user", "content": "旧问题"}, {"role": "assistant", "content": "已回复"}, ], } bot.store = mock.Mock() bot.store.keys.return_value = [avatar.hex(), old16.hex()] bot.store.entry_snapshot.side_effect = [ None, legacy_entry, legacy_entry, ] bot.store.migrate_key.return_value = True bot._legacy_fp_for_current = {current.hex(): old16} bot._legacy_migration_checked = set() bot._known_session_fps = set() bot._pending_reply_sessions = {} bot._chat_identity_signature = mock.Mock(return_value=b"") chat_text = ( "高兴亮 7/29 09:59:00\n已回复\n" "客户甲 7/29 10:00:00\n新问题" ) with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): bot._ensure_session_archive_key(current, chat_text) bot.store.migrate_key.assert_called_once_with(old16.hex(), current.hex()) def test_previous_16_byte_pending_is_atomically_rekeyed_after_title_proof(self): bot = WeChatBot.__new__(WeChatBot) avatar = b"avatar01" old16 = avatar + b"oldname1" current = avatar + b"C" * 32 state = { "batch_ready": True, "confirmed_unread": True, "chat_text": "客户甲 10:00:00\n待回复内容", "identity_signature": b"stable-title", } bot.store = mock.Mock() bot.store.keys.return_value = [] bot.store.entry_snapshot.return_value = None bot._legacy_fp_for_current = {current.hex(): old16} bot._legacy_migration_checked = set() bot._known_session_fps = set() bot._pending_reply_sessions = {old16.hex(): state} bot._pending_reply_path = "" bot._chat_identity_signature = mock.Mock(return_value=b"stable-title") bot._ensure_session_archive_key( current, "客户甲 10:00:00\n待回复内容", ) self.assertNotIn(old16.hex(), bot._pending_reply_sessions) self.assertIs(bot._pending_reply_sessions[current.hex()], state) self.assertTrue(state["confirmed_unread"]) def test_legacy_archive_is_not_migrated_when_customer_name_does_not_match(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.entry_snapshot.side_effect = [ None, {"last_lines": ["客户甲 7/28 09:00:00", "旧问题"]}, ] bot._legacy_migration_checked = set() fp = b"avatar01" + b"m" * 32 bot._ensure_session_archive_key( fp, "客户乙 7/29 10:00:00\n新问题", ) bot.store.migrate_key.assert_not_called() def test_legacy_archive_with_another_customer_in_history_is_never_migrated(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.entry_snapshot.side_effect = [ None, { "last_lines": ["客户乙 7/28 09:00:00", "乙的问题"], "history": [ { "role": "user", "content": "客户甲 7/27 09:00:00\n甲的问题", } ], }, ] bot._legacy_migration_checked = set() fp = b"avatar01" + b"q" * 32 bot._ensure_session_archive_key(fp, "客户乙 7/29 10:00:00\n新问题") bot.store.migrate_key.assert_not_called() def test_date_bearing_agent_header_is_not_treated_as_customer_message(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.history.return_value = [ {"role": "assistant", "content": "更早的一条回复"} ] text = ( "客户甲 7/29 10:52:00\n上一条问题\n" "高兴亮 7/29 10:53:23\n这是我方刚发出的回复" ) with mock.patch("ai_config.AI_AGENT_NAME", "高兴亮"): self.assertFalse(bot._has_pending_customer_message(text, b"session")) def test_actual_staff_name_is_learned_when_configured_nickname_differs(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.history.return_value = [ {"role": "assistant", "content": "历史我方回复"} ] bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=True) text = ( "高兴亮 7/29 10:50:00\n历史我方回复\n" "高兴亮 7/29 10:53:23\n这是人工刚发出的新回复" ) with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertFalse(bot._has_pending_customer_message(text, b"session")) def test_customer_echoing_an_old_assistant_phrase_is_still_pending(self): bot = WeChatBot.__new__(WeChatBot) bot.store = mock.Mock() bot.store.history.return_value = [ {"role": "assistant", "content": "好的"} ] bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) text = "客户甲 10:00:00\n好的" with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertTrue(bot._has_pending_customer_message(text, b"session")) self.assertNotIn( "客户甲", getattr(bot, "_known_agent_speakers", set()), ) def test_right_side_unselectable_media_does_not_relabel_last_copied_customer(self): bot = WeChatBot.__new__(WeChatBot) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=True) text = "客户甲 10:00:00\n请看上一条，后面还有一张图片" with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertFalse(bot._has_pending_customer_message(text, b"session")) self.assertNotIn( "客户甲", getattr(bot, "_known_agent_speakers", set()), ) def test_message_page_refreshes_geometry_after_wide_sidebar_opens(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 100, 50, 2300, 1350 bot._list_x = 136 bot._selected_tracking_initialized = True bot._active_session_fp = b"old" bot._active_chat_signature = b"old" bot._active_identity_signature = b"old" image = np.full((1300, 2200, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 image[130:210, :320, :3] = (250, 232, 215) image[1000:1002, :, :3] = 230 image[1002:, :, :3] = 255 self.assertTrue(bot._refresh_message_geometry(image)) self.assertEqual(bot._list_x, 320) self.assertEqual(bot.list_region["left"], 420) self.assertEqual(bot.list_click_x, 650) # 视觉/指纹裁剪从会话列表右边缘附近开始，必须覆盖客户左侧气泡； # 不能再额外右移 300×DPI。 self.assertLessEqual(bot._chat_rel_x, bot._list_x + bot._list_w + 20 * bot.scale) self.assertGreater(bot._chat_rel_w, 1000) self.assertTrue(bot._composer_geometry_valid) self.assertLessEqual( bot._chat_region["top"] + bot._chat_region["height"], bot.T + 1000 - int(2 * bot.scale), ) self.assertGreater(bot.input_y, bot.T + 1000) self.assertFalse(bot._selected_tracking_initialized) @staticmethod def _geometry_surface(): image = np.full((1300, 2200, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 image[130:210, :320, :3] = (250, 232, 215) image[1000:1002, :, :3] = 230 image[1002:, :, :3] = 255 return image def test_auto_hiding_chat_scrollbar_never_counts_as_a_new_message(self): """消息区右缘的滚动条随鼠标进出淡入淡出，绝不能改写聊天画面指纹。 机器人自己把鼠标从消息区移到输入框就会让这条滚动条消失。若它落在指纹 裁剪区内，按 Enter 前的校验会把这次重绘当成“又收到新消息”，清掉刚写好 的草稿，自动回复永远发不出去。 """ bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 100, 50, 2300, 1350 bot._list_x = 136 bot.detect_selected_row = mock.Mock(return_value=-1) bot._active_session_fp = None base = self._geometry_surface() self.assertTrue(bot._refresh_message_geometry(base)) chat_x1 = bot._chat_rel_x chat_x2 = chat_x1 + bot._chat_rel_w with_bubble = base.copy() with_bubble[400:460, chat_x1 + 40:chat_x1 + 300, :3] = 90 bot._capture_full_window = mock.Mock(return_value=with_bubble) baseline = bot._chat_surface_signature() self.assertTrue(baseline) # 滚动条紧贴消息区右缘，出现或淡出都不得改变指纹。 with_scrollbar = with_bubble.copy() with_scrollbar[500:900, chat_x2 - 6:chat_x2, :3] = 150 bot._capture_full_window.return_value = with_scrollbar self.assertEqual(bot._chat_surface_signature(), baseline) # 同样的判据仍须能发现消息区内部真正的新增内容。 with_new_message = with_bubble.copy() with_new_message[700:760, chat_x1 + 40:chat_x1 + 300, :3] = 90 bot._capture_full_window.return_value = with_new_message self.assertNotEqual(bot._chat_surface_signature(), baseline) def test_chat_capture_still_covers_the_full_outgoing_bubble(self): """自己的气泡右缘紧贴滚动条，截图裁剪区不能为了避开滚动条把它切掉。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 100, 50, 2300, 1350 bot._list_x = 136 self.assertTrue(bot._refresh_message_geometry(self._geometry_surface())) window_width = bot.R - bot.L # 只允许留出视觉边距本身，不得额外内缩。 self.assertGreaterEqual( bot._chat_rel_x + bot._chat_rel_w, window_width - max(4, int(8 * bot.scale)), ) def test_text_selection_region_is_clamped_inside_narrow_window(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 100, 50, 800, 500 bot._list_x = 136 bot._selected_tracking_initialized = True bot._active_session_fp = b"old" bot._active_chat_signature = b"old" bot._active_identity_signature = b"old" full = np.zeros((450, 700, 4), dtype=np.uint8) with ( mock.patch("wechat_bot.infer_navigation_width", return_value=(320, 0.9)), mock.patch("wechat_bot.infer_composer_top", return_value=280), ): self.assertTrue(bot._refresh_message_geometry(full)) region = bot._chat_region self.assertGreaterEqual(region["left"], bot.L) self.assertGreaterEqual(region["top"], bot.T) self.assertLessEqual(region["left"] + region["width"], bot.R) self.assertLessEqual(region["top"] + region["height"], bot.B) self.assertGreaterEqual(bot.input_x, bot.L) self.assertLess(bot.input_x, bot.R) self.assertGreaterEqual(bot.input_y, bot.T) self.assertLess(bot.input_y, bot.B) self.assertFalse(bot._session_geometry_valid) self.assertFalse(bot._input_geometry_valid) def test_tiny_chat_region_never_starts_mouse_drag(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot._chat_region = {"left": 799, "top": 200, "width": 1, "height": 120} bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._drag_select = mock.Mock() self.assertEqual(bot.extract_chat_text(screens=1), "") bot.wait_for_mouse_idle.assert_not_called() bot._drag_select.assert_not_called() def test_failed_composer_redetection_invalidates_every_chat_reader(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.L, bot.T, bot.R, bot.B = 0, 0, 1200, 800 bot._list_x = 68 bot._list_w = 230 bot._composer_rel_top = 620 bot._composer_geometry_valid = True bot._chat_geometry_valid = True bot._input_geometry_valid = True bot._chat_region = {"left": 310, "top": 100, "width": 850, "height": 500} bot._drag_select = mock.Mock() frame = np.full((800, 1200, 4), 245, dtype=np.uint8) with ( mock.patch("wechat_bot.infer_navigation_width", return_value=(68, 0.9)), mock.patch("wechat_bot.infer_composer_top", return_value=None), mock.patch("wechat_bot.pyautogui.click") as click, ): self.assertFalse(bot._refresh_message_geometry(frame)) self.assertFalse(bot._composer_geometry_valid) self.assertFalse(bot._chat_geometry_valid) self.assertFalse(bot._input_geometry_valid) self.assertEqual(bot.extract_chat_text(screens=1), "") self.assertIsNone(bot._last_visible_bubble_is_outgoing()) self.assertEqual(bot._chat_surface_signature(), b"") with self.assertRaises(RuntimeError): bot.capture_chat_area() click.assert_not_called() bot._drag_select.assert_not_called() def test_invalid_session_geometry_never_scrolls_mouse(self): bot = WeChatBot.__new__(WeChatBot) bot._session_geometry_valid = False bot.wait_for_mouse_idle = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.pyautogui.moveTo") as move, mock.patch("wechat_bot.pyautogui.scroll") as scroll, ): bot._scroll_session_list_top() self.assertIsNone( bot._scroll_session_list_page(np.zeros((20, 20, 4), dtype=np.uint8)) ) bot.wait_for_mouse_idle.assert_not_called() move.assert_not_called() scroll.assert_not_called() def test_selected_mail_is_not_mistaken_for_messages(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 self.assertFalse(bot._message_nav_selected(self._mail_nav_surface())) def test_ui_guard_rejects_model_action_that_does_not_match_state(self): decision = _parse_ui_guard_decision( '说明文字 {"state":"chat_ready","action":"open_messages",' '"confidence":0.99,"reason":"误判动作"}' ) self.assertEqual(decision["state"], "chat_ready") self.assertEqual(decision["action"], "none") def test_ui_guard_skips_unrelated_json_before_protocol_object(self): decision = _parse_ui_guard_decision( '{"trace_id":"abc","tokens":42}\n' '{"state":"non_message_page","action":"open_messages",' '"confidence":0.96,"reason":"当前是邮件页"}' ) self.assertEqual(decision["state"], "non_message_page") self.assertEqual(decision["action"], "open_messages") self.assertEqual(decision["confidence"], 0.96) def test_ui_guard_conflicting_protocol_objects_fail_closed(self): decision = _parse_ui_guard_decision( '{"state":"blocking_modal","action":"escape","confidence":0.95}\n' '{"state":"non_message_page","action":"open_messages","confidence":0.99}' ) self.assertEqual(decision["state"], "unknown") self.assertEqual(decision["action"], "none") self.assertEqual(decision["confidence"], 0.0) def test_ui_guard_missing_protocol_field_fails_closed(self): decision = _parse_ui_guard_decision( '{"state":"non_message_page","confidence":0.99}\n' '{"action":"open_messages","confidence":0.99}' ) self.assertEqual(decision["state"], "unknown") self.assertEqual(decision["action"], "none") def test_layout_guard_accepts_one_normalized_semantic_layout(self): decision = _parse_wecom_layout_decision( '{"state":"chat_ready","navigation_right_ratio":0.10,' '"session_list_right_ratio":0.30,"composer_top_ratio":0.78,' '"chat_right_ratio":1.0,"confidence":0.93,"reason":"消息页"}' ) self.assertEqual(decision["state"], "chat_ready") self.assertEqual(decision["confidence"], 0.93) def test_layout_guard_rejects_impossible_or_ambiguous_geometry(self): impossible = _parse_wecom_layout_decision( '{"state":"chat_ready","navigation_right_ratio":0.40,' '"session_list_right_ratio":0.20,"composer_top_ratio":0.10,' '"chat_right_ratio":1.0,"confidence":0.99}' ) self.assertEqual(impossible["confidence"], 0.0) ambiguous = _parse_wecom_layout_decision( '{"state":"chat_ready","navigation_right_ratio":0.10,' '"session_list_right_ratio":0.30,"confidence":0.9}\n' '{"state":"chat_ready","navigation_right_ratio":0.12,' '"session_list_right_ratio":0.32,"confidence":0.9}' ) self.assertEqual(ambiguous["confidence"], 0.0) def test_dify_ui_guard_uploads_image_before_chat_message(self): upload = mock.Mock(ok=True, status_code=201, text="") upload.json.return_value = {"id": "file-123"} chat = mock.Mock(ok=True, status_code=200, text="") chat.json.return_value = { "answer": ( '{"state":"blocking_modal","action":"close_modal",' '"confidence":0.96,"reason":"文档弹窗遮挡"}' ) } with ( mock.patch("ai_chat.ai_config.AI_PROVIDER_TYPE", "dify"), mock.patch("ai_chat.ai_config.AI_API_BASE", "https://dify.example/v1"), mock.patch("ai_chat.ai_config.AI_API_KEY", "app-secret"), mock.patch("ai_chat.requests.post", side_effect=[upload, chat]) as post, ): decision = classify_wecom_ui(b"png-data", trigger="测试") self.assertEqual(decision["action"], "close_modal") self.assertEqual(post.call_args_list[0].args[0], "https://dify.example/v1/files/upload") self.assertIn("file", post.call_args_list[0].kwargs["files"]) second_payload = post.call_args_list[1].kwargs["json"] self.assertEqual(second_payload["files"][0]["upload_file_id"], "file-123") self.assertEqual(second_payload["files"][0]["transfer_method"], "local_file") def test_ai_page_guard_can_only_open_fixed_message_entry(self): bot = WeChatBot.__new__(WeChatBot) bot._last_ui_guard_ts = 0.0 bot._last_ui_guard_signature = "" bot._open_messages_page = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._escape_proven_blocker = mock.Mock(return_value=False) surface = np.full((300, 500, 4), 220, dtype=np.uint8) surface[:, :, 3] = 255 with ( mock.patch("wechat_bot.time.monotonic", return_value=100.0), mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_UI_GUARD_ENABLED", True), mock.patch( "ai_chat.classify_wecom_ui", return_value={ "state": "non_message_page", "action": "open_messages", "confidence": 0.95, "reason": "当前是微盘", }, ), ): self.assertTrue(bot._run_ai_page_guard("测试", full=surface)) bot._open_messages_page.assert_called_once() bot._dismiss_internal_blocker.assert_not_called() bot._escape_proven_blocker.assert_not_called() def test_ai_page_guard_never_closes_security_verification(self): bot = WeChatBot.__new__(WeChatBot) bot._last_ui_guard_ts = 0.0 bot._last_ui_guard_signature = "" bot.security_verification_required = False bot._window_ready = True bot._open_messages_page = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=True) bot._escape_proven_blocker = mock.Mock(return_value=True) surface = np.full((300, 500, 4), 220, dtype=np.uint8) surface[:, :, 3] = 255 with ( mock.patch("wechat_bot.time.monotonic", return_value=100.0), mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_UI_GUARD_ENABLED", True), mock.patch( "ai_chat.classify_wecom_ui", return_value={ "state": "security_verification", "action": "none", "confidence": 0.93, "reason": "需要扫码", }, ), ): self.assertFalse(bot._run_ai_page_guard("测试", full=surface)) self.assertTrue(bot.security_verification_required) self.assertFalse(bot._window_ready) bot._open_messages_page.assert_not_called() bot._dismiss_internal_blocker.assert_not_called() bot._escape_proven_blocker.assert_not_called() def test_minimum_send_interval_is_enforced(self): bot = WeChatBot.__new__(WeChatBot) bot._send_timestamps = deque([95.0]) bot._last_send_ts = 95.0 with mock.patch("wechat_bot.time.monotonic", return_value=100.0): self.assertAlmostEqual(bot._send_gate_remaining(), 3.0) def test_send_stops_immediately_after_owned_blocker_handling(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=True) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse(bot.send_reply("这次不能发送")) bot._ensure_visible.assert_not_called() bot._dismiss_internal_blocker.assert_not_called() click.assert_not_called() def test_send_stops_immediately_after_internal_modal_handling(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock() with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse(bot.send_reply("这次不能发送")) bot._capture_full_window.assert_not_called() click.assert_not_called() def test_send_is_cancelled_before_click_when_chat_identity_changed(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=b"target") bot._chat_identity_signature = mock.Mock(return_value=b"changed") bot._active_identity_signature = b"original" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse( bot.send_reply( "不会发送", session_id=b"target".hex(), expected_fp=b"target", ) ) click.assert_not_called() def test_send_is_cancelled_when_pending_title_does_not_match(self): bot = WeChatBot.__new__(WeChatBot) fp = b"target02" bot._pending_reply_sessions = { fp.hex(): {"identity_signature": b"original-title"} } bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"other-title") bot._active_identity_signature = b"other-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse( bot.send_reply( "不会串发", session_id=fp.hex(), expected_fp=fp, ) ) click.assert_not_called() def test_send_is_cancelled_when_new_message_arrives_after_generation(self): bot = WeChatBot.__new__(WeChatBot) fp = b"target04" bot._pending_reply_sessions = { fp.hex(): { "identity_signature": b"same-title", "generation_surface_signature": b"before-model", } } bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"new-message") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse( bot.send_reply( "已经过时的回复", session_id=fp.hex(), expected_fp=fp, ) ) click.assert_not_called() bot._run_ai_page_guard.assert_not_called() def test_send_is_cancelled_when_message_arrives_after_paste_before_enter(self): bot = WeChatBot.__new__(WeChatBot) fp = b"z" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", } } bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock( side_effect=[b"stable-chat", b"new-message"] ) bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock( side_effect=["", "已经过时的草稿"] ) with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertFalse( bot.send_reply( "已经过时的草稿", session_id=fp.hex(), expected_fp=fp, ) ) self.assertIn(mock.call("ctrl", "v"), hotkey.call_args_list) self.assertIn(mock.call("ctrl", "a"), hotkey.call_args_list) self.assertIn(mock.call("backspace"), press.call_args_list) self.assertFalse(bot._pending_reply_state(fp)["batch_ready"]) def test_send_is_cancelled_when_input_geometry_is_invalid(self): bot = WeChatBot.__new__(WeChatBot) bot._input_geometry_valid = False bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse(bot.send_reply("不会发送")) click.assert_not_called() def test_send_is_cancelled_when_selected_session_fingerprint_is_missing(self): bot = WeChatBot.__new__(WeChatBot) fp = b"target03" bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse( bot.send_reply( "不会发送", session_id=fp.hex(), expected_fp=fp, ) ) click.assert_not_called() def test_successful_send_keeps_current_chat_open(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=b"target") bot._chat_identity_signature = mock.Mock(return_value=b"identity") bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._active_identity_signature = b"identity" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "正常发送"]) bot._record_send = mock.Mock() bot._commit_staged_exchange = mock.Mock() bot._remember_active_surface = mock.Mock() bot._deselect_session = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.send_reply( "正常发送", session_id=b"target".hex(), expected_fp=b"target", ) ) bot._deselect_session.assert_not_called() def test_final_enter_gate_uses_detected_chat_pane_right(self): """Regression: an expanded customer panel used to fake a resize forever.""" bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", "last_lines": ["客户甲 10:00:00", "在不在"], } } bot._pending_reply_path = "" bot._set_task_stage = mock.Mock() bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot._composer_geometry_valid = True bot.scale = 2.0 bot._list_x = 320 bot._list_w = 460 bot._chat_pane_right_rel = 1550 bot._composer_rel_top = 916 bot._refresh_message_geometry = mock.Mock(return_value=False) bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "会回复的"]) bot._persist_pending_replies = mock.Mock(return_value=True) bot._record_send = mock.Mock() bot._same_chat_is_open = mock.Mock(return_value=True) bot._send_receipt_matches = mock.Mock(return_value=True) bot._last_send_receipt_followup = False bot._visible_reply_has_customer_followup = mock.Mock(return_value=False) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() with ( mock.patch( "wechat_bot.composer_divider_matches", return_value=(True, 916), ) as divider, mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.send_reply("会回复的", session_id=fp.hex(), expected_fp=fp) ) self.assertEqual(divider.call_args.kwargs["chat_right"], 1550) def test_layout_change_after_paste_keeps_draft_and_staged_reply(self): bot = WeChatBot.__new__(WeChatBot) fp = b"l" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", "staged_reply_text": "保留这条回复", "last_lines": ["客户甲 10:00:00", "在不在"], } } bot._pending_reply_path = "" bot._set_task_stage = mock.Mock() bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot._composer_geometry_valid = True bot.scale = 2.0 bot._list_x = 320 bot._list_w = 460 bot._chat_pane_right_rel = 1550 bot._composer_rel_top = 916 bot._refresh_message_geometry = mock.Mock(return_value=False) bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "保留这条回复"]) bot._persist_pending_replies = mock.Mock(return_value=True) with ( mock.patch( "wechat_bot.composer_divider_matches", return_value=(False, 1008), ), mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertFalse( bot.send_reply( "保留这条回复", session_id=fp.hex(), expected_fp=fp ) ) state = bot._pending_reply_state(fp) self.assertTrue(state["layout_retry_pending"]) self.assertTrue(state["batch_ready"]) self.assertEqual(state["staged_reply_text"], "保留这条回复") self.assertEqual(state["last_pasted_draft"], "保留这条回复") self.assertNotIn(mock.call("ctrl", "a"), hotkey.call_args_list) self.assertNotIn(mock.call("backspace"), press.call_args_list) def test_layout_rebase_distinguishes_resize_from_appended_message(self): bot = WeChatBot.__new__(WeChatBot) fp = b"b" * 40 baseline = ["客户甲 10:00:00", "在不在"] state = { "identity_signature": b"same-title", "generation_surface_signature": b"old-size", "last_lines": list(baseline), "staged_reply_text": "我在呢", "layout_retry_pending": True, } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_target_matches = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock( return_value="客户甲 10:00:00\n在不在" ) bot._chat_surface_signature = mock.Mock(return_value=b"new-size") bot._persist_pending_replies = mock.Mock(return_value=True) self.assertEqual( bot._rebase_pending_after_layout_change(fp, state), "unchanged", ) self.assertEqual(state["generation_surface_signature"], b"new-size") self.assertEqual(state["staged_reply_text"], "我在呢") self.assertNotIn("layout_retry_pending", state) changed_state = { "identity_signature": b"same-title", "last_lines": list(baseline), } bot.extract_chat_text.return_value = ( "客户甲 10:00:00\n在不在\n客户甲 10:01:00\n还有一件事" ) self.assertEqual( bot._rebase_pending_after_layout_change(fp, changed_state), "changed", ) def test_unchanged_surface_reuses_staged_reply_without_model_call(self): bot = WeChatBot.__new__(WeChatBot) fp = b"u" * 40 state = { "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", "staged_reply_text": "已经生成过的回复", "layout_retry_pending": True, } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_target_matches = mock.Mock(return_value=True) bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._persist_pending_replies = mock.Mock(return_value=True) bot._set_task_stage = mock.Mock() with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch( "ai_chat.get_ai_reply", side_effect=AssertionError("unchanged retry must not call the model"), ), ): self.assertEqual( bot._generate_ai_reply(fp), "已经生成过的回复", ) self.assertNotIn("layout_retry_pending", state) bot._set_task_stage.assert_called_with( fp, "ready_to_send", detail="聊天内容未变化，复用已生成回复", ) def test_repeated_unknown_layout_escalates_to_maximize_then_multimodal_guard(self): bot = WeChatBot.__new__(WeChatBot) fp = b"e" * 40 state = { "identity_signature": b"same-title", "generation_surface_signature": b"old-layout", "staged_reply_text": "保留回复", "layout_retry_pending": True, "layout_retry_count": 2, } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_target_matches = mock.Mock(return_value=True) bot._chat_surface_signature = mock.Mock(return_value=b"new-layout") bot._rebase_pending_after_layout_change = mock.Mock(return_value="unknown") bot._persist_pending_replies = mock.Mock(return_value=True) bot._set_task_stage = mock.Mock() bot._maximize_window_for_composer = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock( return_value=np.zeros((300, 500, 4), dtype=np.uint8) ) bot._run_ai_page_guard = mock.Mock(return_value=False) with mock.patch("ai_config.AI_ENABLED", True): self.assertIsNone(bot._generate_ai_reply(fp)) bot._maximize_window_for_composer.assert_called_once_with(force=True) bot._run_ai_page_guard.assert_called_once_with( "连续布局重定位失败", full=bot._capture_full_window.return_value, ) def test_tiny_window_is_maximized_before_any_input_click(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 0, 0, 1200, 800 bot.hwnd = 123 bot.auto_activate_window = True bot._window_ready = True bot.connect = mock.Mock(return_value=True) with ( mock.patch( "wechat_bot.win32gui.GetWindowPlacement", return_value=(0, wechat_bot.win32con.SW_SHOWNORMAL, (0, 0), (0, 0), (0, 0, 1200, 800)), ), mock.patch("wechat_bot.win32gui.ShowWindow") as show, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._maximize_window_for_composer()) show.assert_called_once_with(123, wechat_bot.win32con.SW_MAXIMIZE) bot.connect.assert_called_once_with(activate=False) def test_reply_without_generation_surface_still_records_pre_enter_baseline(self): """AI-disabled/fixed-reply mode must not become permanently uncertain.""" bot = WeChatBot.__new__(WeChatBot) fp = b"f" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "last_lines": ["客户甲 10:00:00", "固定回复前的问题"], } } bot._pending_reply_path = "" bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"pre-enter") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "固定回复"]) bot._persist_pending_replies = mock.Mock(return_value=True) bot._record_send = mock.Mock() bot._same_chat_is_open = mock.Mock(return_value=True) bot._send_receipt_matches = mock.Mock(return_value=True) bot._last_send_receipt_followup = False bot._visible_reply_has_customer_followup = mock.Mock(return_value=False) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.send_reply("固定回复", session_id=fp.hex(), expected_fp=fp) ) state = bot._pending_reply_state(fp) self.assertEqual(state["send_surface_signature"], b"pre-enter") bot._send_receipt_matches.assert_called_once() def test_human_draft_is_preserved_and_enter_is_never_pressed(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(return_value="人工正在编辑的内容") with ( mock.patch("wechat_bot.pyperclip.paste", return_value="原剪贴板"), mock.patch("wechat_bot.pyperclip.copy") as copy, mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.pyautogui.press") as press, ): self.assertFalse(bot.send_reply("自动回复")) self.assertNotIn(mock.call("ctrl", "v"), hotkey.call_args_list) self.assertNotIn(mock.call("enter"), press.call_args_list) copy.assert_called_once_with("原剪贴板") def test_incomplete_paste_is_never_sent(self): bot = WeChatBot.__new__(WeChatBot) bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "应该完整写入"]) with ( mock.patch("wechat_bot.pyperclip.paste", return_value="原剪贴板"), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.time.sleep"), ): self.assertFalse(bot.send_reply("应该完整写入的自动回复")) self.assertIn(mock.call("ctrl", "v"), hotkey.call_args_list) self.assertNotIn(mock.call("enter"), press.call_args_list) self.assertIn(mock.call("backspace"), press.call_args_list) def test_delayed_copy_marker_never_claims_human_draft_is_empty(self): bot = WeChatBot.__new__(WeChatBot) bot.input_x = 800 bot.input_y = 700 bot._input_editor_looks_blank = mock.Mock(return_value=False) marker = "__wecom_empty_123__" with ( mock.patch("wechat_bot.time.time_ns", return_value=123), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyperclip.paste", return_value=marker), mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.time.sleep"), ): self.assertIsNone(bot._read_input_draft()) press.assert_called_with("end") def _draft_read(self, clipboard, blank): """跑一次 _read_input_draft，剪贴板与输入框像素判定都由调用方给定。""" bot = WeChatBot.__new__(WeChatBot) bot.input_x = 800 bot.input_y = 700 bot._input_editor_looks_blank = mock.Mock(return_value=blank) with ( mock.patch("wechat_bot.time.time_ns", return_value=123), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyperclip.paste", return_value=clipboard), mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.time.sleep"), ): return bot._read_input_draft() def test_a_lingering_chat_selection_is_not_a_human_draft(self): """机器人刚框选复制过聊天记录，那块高亮不会因为点一下空白就消失。 现场（2026-07-31 12:26~12:30）：Ctrl+C 拿回来的是聊天区里还亮着的 “在不在”，被当成人工草稿，于是每轮调一次模型、又每轮让路，连着十几轮 一条都没发出去。输入框像素上是空的，就不能算草稿。 """ self.assertEqual(self._draft_read("在不在", blank=True), "") def test_a_real_draft_in_a_non_blank_editor_still_wins(self): self.assertEqual( self._draft_read("我自己在打字", blank=False), "我自己在打字", ) def test_an_uncertain_editor_never_gets_overwritten(self): """像素判定拿不准时保持原样保守：宁可不发，也不能覆盖人工输入。""" self.assertEqual( self._draft_read("说不清是什么", blank=None), "说不清是什么", ) def test_empty_editor_requires_visual_blank_evidence(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot._list_x = 0 bot._list_w = 100 bot._composer_geometry_valid = True bot._composer_rel_top = 180 blank = np.full((300, 500, 4), 255, dtype=np.uint8) bot._capture_full_window = mock.Mock(return_value=blank) self.assertTrue(bot._input_editor_looks_blank()) with_text = blank.copy() with_text[240:260, 130:200, :3] = (100, 130, 240) bot._capture_full_window.return_value = with_text self.assertFalse(bot._input_editor_looks_blank()) def test_expanded_right_toolbar_is_excluded_from_empty_editor_vision(self): """200% DPI field evidence must stop at the detected chat divider.""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot._list_x = 0 bot._list_w = 100 bot._composer_geometry_valid = True bot._composer_rel_top = 180 bot._chat_pane_right_rel = 700 frame = np.full((400, 1100, 4), 255, dtype=np.uint8) frame[:, :, 3] = 255 # Simulate a dense customer-info toolbar to the right of x=700. frame[180:390, 720:1080, :3] = 40 bot._capture_full_window = mock.Mock(return_value=frame) self.assertTrue(bot._input_editor_looks_blank()) with_draft = frame.copy() with_draft[290:320, 150:250, :3] = (70, 100, 220) bot._capture_full_window.return_value = with_draft self.assertFalse(bot._input_editor_looks_blank()) def test_input_focus_retries_a_second_visual_editor_point(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 0 bot.scale = 2.0 bot.L, bot.T, bot.R, bot.B = 60, 70, 2324, 1774 bot._list_x = 320 bot._list_w = 460 bot._chat_pane_right_rel = 2200 bot._composer_rel_top = 1270 bot._editor_rel_top = 1350 bot.input_x = 1760 bot.input_y = 1654 bot._input_editor_looks_blank = mock.Mock(side_effect=[None, True]) marker = "__wecom_empty_123__" with ( mock.patch("wechat_bot.time.time_ns", return_value=123), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyperclip.paste", return_value=marker), mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.time.sleep"), ): self.assertEqual(bot._read_input_draft(), "") self.assertEqual(click.call_count, 2) self.assertNotEqual(click.call_args_list[0], click.call_args_list[1]) @staticmethod def _composer_panel_surface(with_draft=False): """带圆角边框的输入面板，面板下方还有窗口底色。 采样框必然盖到面板边框和面板外底色；若不先收缩到编辑区内部，空输入 框的几乎每一列都会被算成“有内容”。 """ image = np.full((300, 500, 4), 235, dtype=np.uint8) image[:, :, 3] = 255 image[200:273, 118:339, :3] = 255 image[269:273, 118:339, :3] = 215 image[200:273, 118:122, :3] = 215 image[200:273, 334:339, :3] = 215 # 空输入框里只有一条细光标。 image[226:244, 126, :3] = 60 if with_draft: image[230:250, 150:260, :3] = (90, 120, 235) return image def test_composer_border_and_window_backdrop_never_fake_a_draft(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot._list_x = 0 bot._list_w = 100 bot._composer_geometry_valid = True bot._composer_rel_top = 180 bot._capture_full_window = mock.Mock( return_value=self._composer_panel_surface() ) self.assertTrue(bot._input_editor_looks_blank()) bot._capture_full_window.return_value = self._composer_panel_surface(True) self.assertFalse(bot._input_editor_looks_blank()) def test_ctrl_enter_accepts_verified_square_avatar_raw_fingerprint_once(self): bot = WeChatBot.__new__(WeChatBot) fp = b"q" * 40 state = {} bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._active_identity_signature = b"same-title" bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock( side_effect=["兼容发送", "兼容发送"] ) bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_timestamps = deque([1.0]) with ( mock.patch("wechat_bot.pyperclip.paste", return_value="原剪贴板"), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot._try_ctrl_enter_for_retained_draft( "兼容发送", state, fp, b"same-title", ) ) self.assertFalse( bot._try_ctrl_enter_for_retained_draft( "兼容发送", state, fp, b"same-title", ) ) self.assertTrue(state["ctrl_enter_attempted"]) self.assertGreater(bot._send_timestamps[-1], 1.0) self.assertGreater(state["send_dispatched_at"], 0.0) self.assertEqual( hotkey.call_args_list.count(mock.call("ctrl", "enter")), 1, ) bot._selected_session_fingerprint.assert_not_called() def test_ctrl_enter_persist_failure_does_not_lock_future_recovery(self): bot = WeChatBot.__new__(WeChatBot) fp = b"p" * 40 state = {"send_state": "sent_uncommitted"} bot._same_chat_is_open = mock.Mock(return_value=True) bot._read_input_draft = mock.Mock( side_effect=["兼容发送", "兼容发送"] ) bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._persist_pending_replies = mock.Mock(return_value=False) with ( mock.patch("wechat_bot.pyperclip.paste", return_value="原剪贴板"), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.pyautogui.hotkey") as hotkey, mock.patch("wechat_bot.time.sleep"), ): self.assertFalse( bot._try_ctrl_enter_for_retained_draft( "兼容发送", state, fp, ) ) self.assertEqual(state["send_state"], "sent_uncommitted") self.assertNotIn("ctrl_enter_attempted", state) self.assertNotIn(mock.call("ctrl", "enter"), hotkey.call_args_list) def test_ctrl_enter_stops_immediately_when_human_has_taken_over(self): bot = WeChatBot.__new__(WeChatBot) state = {"send_state": "sent_uncommitted"} bot._mouse_is_idle_now = mock.Mock(return_value=False) bot._same_chat_is_open = mock.Mock(return_value=True) bot._begin_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock() bot._persist_pending_replies = mock.Mock() bot._refresh_send_reservation = mock.Mock() with mock.patch("wechat_bot.pyautogui.hotkey") as hotkey: self.assertFalse( bot._try_ctrl_enter_for_retained_draft( "兼容发送", state, b"target", ) ) bot._same_chat_is_open.assert_not_called() bot._begin_bot_mouse.assert_not_called() bot._read_input_draft.assert_not_called() bot._persist_pending_replies.assert_not_called() bot._refresh_send_reservation.assert_not_called() hotkey.assert_not_called() self.assertNotIn("ctrl_enter_attempted", state) self.assertNotIn("send_dispatched_at", state) def test_send_receipt_allows_bounded_delayed_render(self): bot = WeChatBot.__new__(WeChatBot) bot._send_receipt_matches = mock.Mock(side_effect=[False, True]) with mock.patch("wechat_bot.time.sleep") as sleep: self.assertTrue( bot._wait_for_visible_reply( "已发送", "客户甲", b"before", ) ) self.assertEqual(bot._send_receipt_matches.call_count, 2) self.assertEqual(sleep.call_count, 1) def test_old_same_text_bubble_cannot_confirm_unchanged_transaction(self): bot = WeChatBot.__new__(WeChatBot) bot._visible_last_message_matches = mock.Mock(return_value=True) bot._chat_surface_signature = mock.Mock(return_value=b"before-send") self.assertFalse( bot._send_receipt_matches( "好的", "客户甲", b"before-send", ) ) def test_old_same_text_plus_new_customer_message_cannot_confirm_send(self): bot = WeChatBot.__new__(WeChatBot) visible = ( "贴心管家 10:00:00\n好的\n" "客户甲 10:00:05\n我再问一句" ) bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"customer-followup") with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertFalse( bot._send_receipt_matches( reply_text="好的", customer_speaker="客户甲", before_surface=b"before-send", before_blocks=[["贴心管家 10:00:00", "好的"]], reply_was_visible=True, ) ) def test_new_same_text_outgoing_block_confirms_send(self): bot = WeChatBot.__new__(WeChatBot) visible = ( "贴心管家 10:00:00\n好的\n" "客户甲 10:00:05\n我再问一句\n" "贴心管家 10:00:10\n好的" ) bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=True) bot._chat_surface_signature = mock.Mock(return_value=b"after-send") with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertTrue( bot._send_receipt_matches( reply_text="好的", customer_speaker="客户甲", before_surface=b"before-send", before_blocks=[ ["贴心管家 10:00:00", "好的"], ["客户甲 10:00:05", "我再问一句"], ], reply_was_visible=True, ) ) def test_actual_staff_name_can_be_proved_by_outgoing_bubble_side(self): bot = WeChatBot.__new__(WeChatBot) visible = ( "客户甲 10:00:05\n我再问一句\n" "高兴亮 10:00:10\n好的" ) bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=True) bot._chat_surface_signature = mock.Mock(return_value=b"after-send") with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertTrue( bot._send_receipt_matches( reply_text="好的", customer_speaker="客户甲", before_surface=b"before-send", before_blocks=[["客户甲 10:00:05", "我再问一句"]], ) ) self.assertIn("高兴亮", bot._known_agent_speakers) def test_group_member_echo_cannot_be_mistaken_for_our_reply(self): bot = WeChatBot.__new__(WeChatBot) visible = ( "客户甲 10:00:00\n有人在吗\n" "客户乙 10:00:03\n我在呢" ) bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"changed") with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertFalse( bot._send_receipt_matches( reply_text="我在呢", customer_speaker="客户甲", before_surface=b"before", before_blocks=[["客户甲 10:00:00", "有人在吗"]], ) ) def test_proven_real_staff_name_confirms_reply_before_fast_followup(self): bot = WeChatBot.__new__(WeChatBot) bot._known_agent_speakers = {"高兴亮"} visible = ( "客户甲 10:00:00\n原问题\n" "高兴亮 10:00:05\n我在呢\n" "客户甲 10:00:06\n还有一个问题" ) bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"after") with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertTrue( bot._send_receipt_matches( reply_text="我在呢", customer_speaker="客户甲", before_surface=b"before", before_blocks=[["客户甲 10:00:00", "原问题"]], ) ) self.assertTrue(bot._last_send_receipt_followup) self.assertTrue( bot._visible_reply_has_customer_followup("我在呢", "客户甲") ) def test_receipt_and_fast_followup_are_committed_from_one_snapshot(self): bot = WeChatBot.__new__(WeChatBot) fp = b"j" * 40 state = { "send_state": "sent_uncommitted", "reply_text": "我在呢", "customer_speaker": "客户甲", "send_surface_signature": b"before", "send_baseline_blocks": [["客户甲 10:00:00", "原问题"]], "send_known_outgoing_speakers": ["高兴亮"], } visible = ( "客户甲 10:00:00\n原问题\n" "高兴亮 10:00:05\n我在呢\n" "客户甲 10:00:06\n还有一个问题" ) bot._known_agent_speakers = set() bot.extract_chat_text = mock.Mock(return_value=visible) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"after") bot._visible_reply_has_customer_followup = mock.Mock(return_value=False) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._queue_followup_after_confirmed_send = mock.Mock() bot._remember_active_surface = mock.Mock() with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertEqual(bot._reconcile_uncertain_send(fp, state), "sent") bot.extract_chat_text.assert_called_once() bot._visible_reply_has_customer_followup.assert_not_called() bot._queue_followup_after_confirmed_send.assert_called_once_with(fp) bot._remember_active_surface.assert_not_called() def test_unknown_followup_direction_keeps_a_pending_probe(self): bot = WeChatBot.__new__(WeChatBot) fp = b"v" * 40 state = { "send_state": "sent_uncommitted", "reply_text": "已发送", "send_surface_signature": b"before", "send_baseline_blocks": [["客户甲 10:00:00", "原问题"]], } bot._chat_surface_signature = mock.Mock(return_value=b"after") bot._send_receipt_matches = mock.Mock(return_value=True) bot._last_send_receipt_followup = None bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._queue_followup_after_confirmed_send = mock.Mock() bot._remember_active_surface = mock.Mock() self.assertEqual(bot._reconcile_uncertain_send(fp, state), "sent") bot._queue_followup_after_confirmed_send.assert_called_once_with(fp) bot._remember_active_surface.assert_not_called() def test_block_anchor_tolerates_old_blocks_scrolling_off_screen(self): bot = WeChatBot.__new__(WeChatBot) baseline = [ ["客户甲 09:59:00", "更早的问题"], ["贴心管家 09:59:10", "更早的回复"], ["客户甲 10:00:00", "新的问题"], ] current = baseline[1:] + [["贴心管家 10:00:10", "新的回答"]] self.assertEqual( bot._blocks_after_baseline(baseline, current), [["贴心管家 10:00:10", "新的回答"]], ) def test_missing_or_malformed_legacy_anchor_never_confirms_old_reply(self): bot = WeChatBot.__new__(WeChatBot) fp = b"g" * 40 state = { "send_state": "sent_uncommitted", "reply_text": "好的", "send_surface_signature": b"before", "send_reply_match_count": 0, } bot._chat_surface_signature = mock.Mock(return_value=b"after") bot._send_receipt_matches = mock.Mock(return_value=True) bot._persist_pending_replies = mock.Mock(return_value=True) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") bot._send_receipt_matches.assert_not_called() bot._commit_staged_exchange.assert_not_called() bot._clear_reply_pending.assert_not_called() state["send_state"] = "sent_uncommitted" state["send_baseline_blocks"] = [] self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") bot._send_receipt_matches.assert_not_called() def test_legacy_uncertain_task_yields_to_a_proven_new_customer_turn(self): bot = WeChatBot.__new__(WeChatBot) fp = b"y" * 40 state = { "send_state": "uncertain", "reply_text": "旧草稿绝不能重发", "send_surface_signature": b"before", "uncertain_since": 1.0, "customer_speaker": "客户甲", "last_lines": ["客户甲 10:00:00", "原问题"], "confirmed_unread": True, } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {fp.hex(): b"before"} bot._chat_surface_signature = mock.Mock(return_value=b"after") bot.extract_chat_text = mock.Mock( return_value=( "客户甲 10:00:00\n原问题\n" "客户甲 10:00:30\n这是后续新消息" ) ) bot._persist_pending_replies = mock.Mock(return_value=True) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() with mock.patch("wechat_bot.pyautogui.hotkey") as hotkey: self.assertEqual(bot._reconcile_uncertain_send(fp, state), "unsent") refreshed = bot._pending_reply_state(fp) self.assertNotIn("send_state", refreshed) self.assertNotIn("reply_text", refreshed) self.assertTrue(refreshed["confirmed_unread"]) self.assertEqual(refreshed["last_lines"], ["客户甲 10:00:00", "原问题"]) bot._commit_staged_exchange.assert_not_called() bot._clear_reply_pending.assert_not_called() hotkey.assert_not_called() def test_same_chat_receipt_uses_strong_chat_fallback_when_nav_colour_misses(self): bot = WeChatBot.__new__(WeChatBot) fp = b"h" * 40 bot._capture_full_window = mock.Mock(return_value=self._nav_surface(False)) bot._message_nav_selected = mock.Mock(return_value=False) bot._target_chat_ready = mock.Mock(return_value=fp) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._active_identity_signature = b"same-title" self.assertTrue(bot._same_chat_is_open(fp, b"same-title")) def test_same_chat_receipt_accepts_title_render_drift_with_full_selected_fp(self): bot = WeChatBot.__new__(WeChatBot) fp = b"i" * 40 bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"new-render") bot._active_identity_signature = b"old-render" self.assertTrue(bot._same_chat_is_open(fp, b"old-render")) def test_send_receipt_deadline_stops_more_expensive_checks(self): bot = WeChatBot.__new__(WeChatBot) bot._send_receipt_matches = mock.Mock(return_value=False) with ( mock.patch("wechat_bot.time.monotonic", side_effect=[0.0, 9.0]), mock.patch("wechat_bot.time.sleep") as sleep, ): self.assertFalse( bot._wait_for_visible_reply( "已发送", "客户甲", b"before", ) ) bot._send_receipt_matches.assert_called_once() sleep.assert_not_called() def test_restart_reconciles_visible_sent_reply_without_resending(self): bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 state = { "send_state": "sent_uncommitted", "reply_text": "已经发送的回复", "send_surface_signature": b"before-send", "send_baseline_blocks": [["客户甲 10:00:00", "原问题"]], } def visible_sent(*_args, **_kwargs): bot._last_send_receipt_followup = False return True bot._visible_last_message_matches = mock.Mock(side_effect=visible_sent) bot._chat_surface_signature = mock.Mock(return_value=b"after-send") bot._visible_reply_has_customer_followup = mock.Mock(return_value=False) bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() self.assertEqual(bot._reconcile_uncertain_send(fp, state), "sent") bot._commit_staged_exchange.assert_called_once_with(fp.hex()) bot._clear_reply_pending.assert_called_once_with(fp) def test_followup_detection_anchors_latest_same_text_reply(self): bot = WeChatBot.__new__(WeChatBot) no_followup = ( "贴心管家 10:00:00\n好的\n" "客户甲 10:00:01\n谢谢\n" "贴心管家 10:00:02\n好的" ) bot.extract_chat_text = mock.Mock(return_value=no_followup) with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertFalse( bot._visible_reply_has_customer_followup("好的", "客户甲") ) with_followup = no_followup + "\n客户甲 10:00:03\n还有一个问题" bot.extract_chat_text.return_value = with_followup with mock.patch("ai_config.AI_AGENT_NAME", "贴心管家"): self.assertTrue( bot._visible_reply_has_customer_followup("好的", "客户甲") ) def test_restart_only_retries_when_pre_send_surface_proves_enter_did_not_happen(self): bot = WeChatBot.__new__(WeChatBot) fp = b"u" * 40 state = { "send_state": "sending", "reply_text": "尚未发送的回复", "send_surface_signature": b"same-before-enter", } bot._visible_last_message_matches = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"same-before-enter") bot._persist_pending_replies = mock.Mock(return_value=True) self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") self.assertEqual(state["send_state"], "uncertain") self.assertEqual(state["reply_text"], "尚未发送的回复") def test_uncertain_receipt_is_rechecked_at_low_frequency(self): bot = WeChatBot.__new__(WeChatBot) fp = b"l" * 40 state = { "send_state": "sent_uncommitted", "reply_text": "等待回执", "send_baseline_blocks": [["客户甲 10:00:00", "原问题"]], } bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {} bot._visible_last_message_matches = mock.Mock(return_value=False) bot._try_ctrl_enter_for_retained_draft = mock.Mock(return_value=False) bot._chat_surface_signature = mock.Mock(return_value=b"stable") bot._persist_pending_replies = mock.Mock(return_value=True) with mock.patch("wechat_bot.time.monotonic", side_effect=[100.0, 101.0]): self.assertEqual( bot._reconcile_uncertain_send(fp, state), "uncertain", ) self.assertEqual( bot._reconcile_uncertain_send(fp, state), "uncertain", ) bot._visible_last_message_matches.assert_called_once() bot._try_ctrl_enter_for_retained_draft.assert_not_called() def test_uncertain_state_is_strictly_read_only_even_after_surface_change(self): bot = WeChatBot.__new__(WeChatBot) fp = b"x" * 40 state = { "send_state": "uncertain", "reply_text": "不允许再发", "send_surface_signature": b"before", "send_baseline_blocks": [["客户甲 10:00:00", "原问题"]], "uncertain_since": 1.0, } bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {fp.hex(): b"before"} bot._chat_surface_signature = mock.Mock(return_value=b"changed") bot._send_receipt_matches = mock.Mock(return_value=False) bot._try_ctrl_enter_for_retained_draft = mock.Mock(return_value=True) bot._persist_pending_replies = mock.Mock(return_value=True) self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") bot._send_receipt_matches.assert_called_once() bot._try_ctrl_enter_for_retained_draft.assert_not_called() def test_unknown_send_state_fails_closed_with_real_uncertain_timestamp(self): bot = WeChatBot.__new__(WeChatBot) fp = b"w" * 40 state = { "send_state": "future-v99", "reply_text": "未知事务", "uncertain_since": 0.0, } bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._send_receipt_matches = mock.Mock(return_value=False) bot._persist_pending_replies = mock.Mock(return_value=True) self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") self.assertEqual(state["send_state"], "uncertain") self.assertGreater(state["uncertain_since"], 0.0) bot._persist_pending_replies.assert_called_once() def test_an_untouched_chat_proves_the_send_never_landed(self): """按回车前后整片聊天区一模一样 → 那一下什么都没发生，可以安全重来。 这条路以前不存在：没有表头就没有回执比对，任务永远停在"发送待核对"， 而 `_check_selected_session` 每轮都在这个状态上 return False，那位客户 之后再发多少条都不会有人理。这里也不许重按回车，只是把任务放回队列。 """ bot = WeChatBot.__new__(WeChatBot) fp = b"d" * 40 state = { "send_state": "uncertain", "reply_text": "等待确认", "send_surface_signature": b"same", "uncertain_since": 123.0, } bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {} bot._chat_surface_signature = mock.Mock(return_value=b"same") bot._send_receipt_matches = mock.Mock(return_value=False) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=None) bot._reset_pending_batch = mock.Mock() bot._pending_reply_sessions = {} bot._persist_pending_replies = mock.Mock(return_value=True) bot._log_queue_event = mock.Mock() with mock.patch("wechat_bot.time.monotonic", side_effect=[100.0, 106.0]): self.assertEqual(bot._reconcile_uncertain_send(fp, state), "unsent") # 回执比对要表头，这条路正是为"没有表头"准备的，不该被调用 bot._send_receipt_matches.assert_not_called() bot._reset_pending_batch.assert_called_once_with(fp) def test_an_undecidable_screen_is_rechecked_instead_of_rewritten(self): """判不出结果时不反复写盘，也不反复框选，就是安静地等下一轮。""" bot = WeChatBot.__new__(WeChatBot) fp = b"d" * 40 state = { "send_state": "uncertain", "reply_text": "等待确认", "send_surface_signature": b"before", "uncertain_since": time.time() - 1.0, } bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {} bot._chat_surface_signature = mock.Mock(return_value=b"after") bot._send_receipt_matches = mock.Mock(return_value=False) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=None) bot._persist_pending_replies = mock.Mock(return_value=True) bot._log_queue_event = mock.Mock() with mock.patch("wechat_bot.time.monotonic", side_effect=[100.0, 106.0]): self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") self.assertEqual(bot._reconcile_uncertain_send(fp, state), "uncertain") bot._persist_pending_replies.assert_not_called() @staticmethod def _stalled_bot(fp: bytes, state: dict, bubble=None, visible: str = ""): """一个卡在「发送待核对」上的机器人，屏幕由参数决定。""" bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_sessions = {fp.hex(): state} bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {} bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=bubble) bot._persist_pending_replies = mock.Mock(return_value=True) bot._log_queue_event = mock.Mock() bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() bot._reset_pending_batch = mock.Mock() bot.extract_chat_text = mock.Mock(return_value=visible) return bot def test_a_waiting_customer_breaks_the_reconciliation_deadlock(self): """待核对期间客户还在等 → 放弃旧草稿去回答他，而不是把他晾在那儿。 这正是"当前这个会话来了新消息却不回复"的根子：任务卡在待核对上， `_check_selected_session` 每轮都在这个状态上 return False，新消息 连读都不会被读到。 """ fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "旧草稿", "send_surface_signature": b"before", "uncertain_since": time.time() - 10.0, } bot = self._stalled_bot(fp, state, bubble=False) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"before", current_surface=b"after", reply_text="旧草稿", ), "unsent", ) bot._reset_pending_batch.assert_called_once_with(fp) # 绝不重发那条旧草稿，只是让正常流程重新读一遍最新的话 bot._commit_staged_exchange.assert_not_called() def test_our_own_last_bubble_settles_the_task_as_sent(self): fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "在的", "send_surface_signature": b"before", "uncertain_since": time.time() - 10.0, } bot = self._stalled_bot(fp, state, bubble=True) bot._nothing_left_to_answer = mock.Mock(return_value=True) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"before", current_surface=b"after", reply_text="在的", ), "sent", ) def test_a_task_is_never_judged_before_the_screen_can_catch_up(self): """刚按下回车就断言"屏幕没变=没发出去"，会冤枉刚刚发成功的那一条。""" fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "在的", "send_surface_signature": b"same", "send_dispatched_at": time.time(), } bot = self._stalled_bot(fp, state, bubble=None) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"same", current_surface=b"same", reply_text="在的", ), "", ) bot._reset_pending_batch.assert_not_called() def test_a_task_with_no_dispatch_time_is_left_alone(self): fp = b"q" * 40 state = {"send_state": "uncertain", "reply_text": "在的"} bot = self._stalled_bot(fp, state, bubble=None) self.assertEqual( bot._resolve_stalled_send(fp, state, reply_text="在的"), "" ) def test_an_unreadable_screen_never_becomes_a_second_reply(self): """一个字都读不到时不许推出"没发出去"——那正是连回三条的老路。""" fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "在的", "send_surface_signature": b"before", "uncertain_since": time.time() - 600.0, } bot = self._stalled_bot(fp, state, bubble=None, visible="") self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"before", current_surface=b"after", reply_text="在的", ), "", ) bot._reset_pending_batch.assert_not_called() def test_a_reply_found_on_screen_after_the_deadline_counts_as_sent(self): fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "您好，这边帮您看", "send_surface_signature": b"before", "uncertain_since": time.time() - 600.0, } bot = self._stalled_bot( fp, state, bubble=None, visible="客户甲 10:00\n在不在\n我 10:01\n您好，这边帮您看", ) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"before", current_surface=b"after", reply_text="您好，这边帮您看", ), "sent", ) bot._commit_staged_exchange.assert_called_once() def test_a_readable_screen_without_our_reply_frees_the_customer(self): fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "您好，这边帮您看", "send_surface_signature": b"before", "uncertain_since": time.time() - 600.0, } bot = self._stalled_bot( fp, state, bubble=None, visible="客户甲 10:00\n在不在", ) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"before", current_surface=b"after", reply_text="您好，这边帮您看", ), "unsent", ) def test_an_unchanged_screen_with_our_bubble_last_is_not_called_unsent(self): """画面没变却说最后一条是我方发的，两件事对不上，宁可不下"没发出去"。""" fp = b"q" * 40 state = { "send_state": "uncertain", "reply_text": "在的", "send_surface_signature": b"same", "uncertain_since": time.time() - 10.0, } bot = self._stalled_bot(fp, state, bubble=True) bot._nothing_left_to_answer = mock.Mock(return_value=True) self.assertEqual( bot._resolve_stalled_send( fp, state, before_surface=b"same", current_surface=b"same", reply_text="在的", ), "sent", ) bot._reset_pending_batch.assert_not_called() def test_reset_pending_clears_uncertain_tracking_maps(self): bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 key = fp.hex() bot._pending_reply_sessions = {key: {"send_state": "uncertain"}} bot._uncertain_send_last_check = {key: 1.0} bot._uncertain_send_last_log = {key: 1.0} bot._uncertain_send_last_surface = {key: b"surface"} bot._persist_pending_replies = mock.Mock(return_value=True) bot._reset_pending_batch(fp) self.assertNotIn(key, bot._uncertain_send_last_check) self.assertNotIn(key, bot._uncertain_send_last_log) self.assertNotIn(key, bot._uncertain_send_last_surface) def test_reset_pending_batch_drops_the_cached_question_text(self): """放弃旧草稿必须连缓存的旧问题一起丢，下一轮才不会拿它再答一遍。 2026-07-31 现场：回执没确认 → 对账「放弃旧草稿改答最新消息」→ 重新 生成时提取恰好失败（人在动鼠标）→ 生成流程复用了缓存里上一轮的 「你多大了」，同一句回复被原样再发一遍，客户刚问的新问题没进模型。 """ bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 key = fp.hex() bot._pending_reply_sessions = {key: { "send_state": "uncertain", "chat_text": "高瑞@微信@微信联系人 7/31 18:13\n你多大了", "reply_text": "四十来岁啦，怎么突然问这个？", }} bot._persist_pending_replies = mock.Mock(return_value=True) bot._reset_pending_batch(fp) self.assertNotIn("chat_text", bot._pending_reply_sessions[key]) def test_uncertain_active_task_does_not_block_next_pending_session(self): bot = WeChatBot.__new__(WeChatBot) uncertain_fp = b"a" * 40 next_fp = b"b" * 40 bot._pending_reply_sessions = { uncertain_fp.hex(): { "send_state": "uncertain", "identity_signature": b"active-title", }, next_fp.hex(): { "confirmed_unread": True, "identity_signature": b"other-title", }, } bot._active_session_fp = uncertain_fp bot._active_identity_signature = b"active-title" bot._chat_identity_signature = mock.Mock(return_value=b"active-title") bot._reconcile_uncertain_send = mock.Mock(return_value="uncertain") bot._pending_scan_progress = {} bot._pending_scan_incomplete = False bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._find_pending_session = mock.Mock(return_value=None) self.assertFalse(bot._resume_orphaned_pending_reply()) bot._find_pending_session.assert_called_once_with(next_fp) def test_offscreen_uncertain_head_never_starts_deep_scan(self): bot = WeChatBot.__new__(WeChatBot) uncertain_fp = b"o" * 40 next_fp = b"n" * 40 bot._pending_reply_sessions = { uncertain_fp.hex(): { "send_state": "uncertain", "identity_signature": b"old-title", }, next_fp.hex(): { "confirmed_unread": True, "identity_signature": b"next-title", }, } bot._active_session_fp = None bot._active_identity_signature = None bot._chat_identity_signature = mock.Mock(return_value=b"") bot._pending_scan_progress = {} bot._pending_scan_incomplete = False bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._find_pending_session = mock.Mock(return_value=None) self.assertFalse(bot._resume_orphaned_pending_reply()) bot._find_pending_session.assert_called_once_with(next_fp) def test_offscreen_dispatched_head_never_blocks_normal_pending(self): bot = WeChatBot.__new__(WeChatBot) dispatched_fp = b"s" * 40 next_fp = b"p" * 40 bot._pending_reply_sessions = { dispatched_fp.hex(): { "send_state": "sent_uncommitted", "identity_signature": b"old-title", }, next_fp.hex(): { "confirmed_unread": True, "identity_signature": b"next-title", }, } bot._active_session_fp = None bot._active_identity_signature = None bot._chat_identity_signature = mock.Mock(return_value=b"") bot._pending_scan_progress = {} bot._pending_scan_incomplete = False bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._find_pending_session = mock.Mock(return_value=None) self.assertFalse(bot._resume_orphaned_pending_reply()) bot._find_pending_session.assert_called_once_with(next_fp) def test_active_sent_uncommitted_is_reconciled_before_model_call(self): bot = WeChatBot.__new__(WeChatBot) fp = b"a" * 40 bot._pending_reply_sessions = { fp.hex(): { "send_state": "sent_uncommitted", "reply_text": "已发出的回复", "identity_signature": b"same-title", } } bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=-1) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._ensure_session_archive_key = mock.Mock() bot._selected_tracking_initialized = True bot._active_session_fp = fp bot._active_identity_signature = b"same-title" bot._active_chat_signature = b"surface" bot._reconcile_uncertain_send = mock.Mock(return_value="sent") bot._generate_ai_reply = mock.Mock() bot.send_reply = mock.Mock() self.assertTrue(bot._check_selected_session(np.zeros((40, 40, 4), dtype=np.uint8))) bot._reconcile_uncertain_send.assert_called_once() bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() def test_selected_pending_title_render_drift_still_reaches_reply_flow(self): bot = WeChatBot.__new__(WeChatBot) fp = b"d" * 40 state = { "batch_ready": True, "confirmed_unread": True, "identity_signature": b"old-title-render", } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=24) bot._session_fingerprint = mock.Mock(return_value=fp) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) bot._is_tool_selected = mock.Mock(return_value=False) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"new-title-render") bot._chat_surface_signature = mock.Mock(return_value=b"new-chat-surface") bot._selected_tracking_initialized = True bot._active_session_fp = fp bot._active_identity_signature = b"old-title-render" bot._active_chat_signature = b"old-chat-surface" bot._ensure_session_archive_key = mock.Mock() bot._persist_pending_replies = mock.Mock(return_value=True) bot._reconcile_uncertain_send = mock.Mock(return_value="unsent") bot._activate_wx = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock( return_value="客户甲 10:00:00\n请回复这条新消息" ) bot._has_pending_customer_message = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="已经正常回复") bot.send_reply = mock.Mock(return_value=True) with mock.patch("wechat_bot.time.sleep"): self.assertTrue( bot._check_selected_session( np.zeros((80, 80, 4), dtype=np.uint8) ) ) self.assertEqual(state["identity_signature"], b"new-title-render") bot._generate_ai_reply.assert_called_once() bot.send_reply.assert_called_once_with( "已经正常回复", session_id=fp.hex(), expected_fp=fp, ) def test_enter_without_visible_receipt_never_commits_or_clears(self): bot = WeChatBot.__new__(WeChatBot) fp = b"n" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", "last_lines": ["客户甲 10:00:00", "没有真正发出前的问题"], } } bot._pending_reply_path = "" bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "没有真正发出"]) bot._persist_pending_replies = mock.Mock(return_value=True) bot._visible_last_message_matches = mock.Mock(return_value=False) bot._try_ctrl_enter_for_retained_draft = mock.Mock(return_value=False) bot._record_send = mock.Mock() bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertFalse( bot.send_reply("没有真正发出", session_id=fp.hex(), expected_fp=fp) ) self.assertEqual(bot._pending_reply_state(fp)["send_state"], "uncertain") bot._record_send.assert_called_once_with(fp.hex()) bot._commit_staged_exchange.assert_not_called() bot._clear_reply_pending.assert_not_called() def test_ctrl_enter_is_used_only_after_retained_draft_is_proven(self): bot = WeChatBot.__new__(WeChatBot) fp = b"c" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "identity_signature": b"same-title", "generation_surface_signature": b"stable-chat", "last_lines": ["客户甲 10:00:00", "兼容发送前的问题"], } } bot._pending_reply_path = "" bot._security_gate_visible = mock.Mock(return_value=False) bot._send_gate_open = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._chat_surface_signature = mock.Mock(return_value=b"stable-chat") bot._active_identity_signature = b"same-title" bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._input_geometry_valid = True bot.input_x = 800 bot.input_y = 700 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._read_input_draft = mock.Mock(side_effect=["", "兼容发送"]) bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_receipt_matches = mock.Mock(side_effect=[False, True]) bot._last_send_receipt_followup = False bot._try_ctrl_enter_for_retained_draft = mock.Mock(return_value=True) bot._visible_reply_has_customer_followup = mock.Mock(return_value=False) bot._record_send = mock.Mock() bot._commit_staged_exchange = mock.Mock() bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.pyautogui.hotkey"), mock.patch("wechat_bot.pyautogui.press"), mock.patch("wechat_bot.pyperclip.paste", return_value=""), mock.patch("wechat_bot.pyperclip.copy"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.send_reply("兼容发送", session_id=fp.hex(), expected_fp=fp) ) bot._try_ctrl_enter_for_retained_draft.assert_called_once() bot._commit_staged_exchange.assert_called_once_with(fp.hex()) def test_internal_modal_is_closed_with_escape_before_clicking_x(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.L = 20 bot.T = 30 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._capture_full_window = mock.Mock( side_effect=[self._modal_surface(), self._modal_surface(False)] ) bot._message_nav_selected = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.safe_set_foreground"), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=bot.hwnd), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._dismiss_internal_blocker("测试")) press.assert_called_once_with("esc") click.assert_not_called() def test_non_message_page_is_never_treated_as_internal_modal(self): bot = WeChatBot.__new__(WeChatBot) bot._capture_full_window = mock.Mock(return_value=self._modal_surface()) bot._message_nav_selected = mock.Mock(return_value=False) with mock.patch("wechat_bot.find_blocking_modal_close") as detector: self.assertFalse(bot._dismiss_internal_blocker("测试")) detector.assert_not_called() def test_independent_wecom_document_window_is_not_force_closed(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=200), mock.patch( "wechat_bot.win32process.GetWindowThreadProcessId", return_value=(0, 77), ), mock.patch("wechat_bot.win32gui.IsWindowVisible", return_value=True), mock.patch("wechat_bot.win32gui.GetWindow", return_value=0), mock.patch("wechat_bot.win32gui.GetClassName", return_value="WeWorkWindow"), mock.patch("wechat_bot.win32gui.GetWindowText", return_value="智能文档"), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.win32gui.PostMessage") as close, ): self.assertFalse(bot._dismiss_owned_blocking_window()) press.assert_not_called() close.assert_not_called() def test_login_verification_child_window_is_never_closed(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=200), mock.patch( "wechat_bot.win32process.GetWindowThreadProcessId", return_value=(0, 77), ), mock.patch("wechat_bot.win32gui.IsWindowVisible", return_value=True), mock.patch("wechat_bot.win32gui.GetWindow", return_value=100), mock.patch("wechat_bot.win32gui.GetClassName", return_value="#32770"), mock.patch("wechat_bot.win32gui.GetWindowText", return_value="企业微信登录验证"), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.win32gui.PostMessage") as close, ): self.assertFalse(bot._dismiss_owned_blocking_window()) press.assert_not_called() close.assert_not_called() def test_stubborn_owned_dialog_is_blocked_but_not_reclosed_every_poll(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.time.monotonic", side_effect=[100.0, 105.0]), mock.patch("wechat_bot.time.sleep"), mock.patch("wechat_bot.safe_set_foreground", return_value=True), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=200), mock.patch( "wechat_bot.win32process.GetWindowThreadProcessId", return_value=(0, 77), ), mock.patch("wechat_bot.win32gui.IsWindowVisible", return_value=True), mock.patch("wechat_bot.win32gui.IsWindow", return_value=True), mock.patch("wechat_bot.win32gui.GetWindow", return_value=100), mock.patch("wechat_bot.win32gui.GetClassName", return_value="#32770"), mock.patch("wechat_bot.win32gui.GetWindowText", return_value="发送文档"), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.win32gui.PostMessage") as close, ): self.assertTrue(bot._dismiss_owned_blocking_window()) self.assertTrue(bot._dismiss_owned_blocking_window()) press.assert_called_once_with("esc") close.assert_called_once_with(200, mock.ANY, 0, 0) def test_stubborn_internal_modal_freezes_poll_without_repeated_escape(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.L = 10 bot.T = 20 bot._capture_full_window = mock.Mock(return_value=self._modal_surface()) bot._message_nav_selected = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.time.monotonic", side_effect=[100.0, 105.0]), mock.patch("wechat_bot.time.sleep"), mock.patch("wechat_bot.safe_set_foreground", return_value=True), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=100), mock.patch( "wechat_bot.find_blocking_modal_close", return_value=(870, 175), ), mock.patch("wechat_bot.pyautogui.press") as press, mock.patch("wechat_bot.pyautogui.click") as click, ): self.assertTrue(bot._dismiss_internal_blocker("测试")) self.assertTrue(bot._dismiss_internal_blocker("测试")) press.assert_called_once_with("esc") click.assert_called_once_with(880, 195) def test_page_restore_keeps_pending_and_next_poll_reopens_it(self): bot = WeChatBot.__new__(WeChatBot) fp = b"p" * 40 state = { "batch_ready": True, "confirmed_unread": True, "chat_text": "客户甲 10:00:00\n还没有回复的问题", } bot.scale = 1.0 bot._pending_reply_sessions = {fp.hex(): state} bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock( side_effect=[self._nav_surface(False), self._nav_surface(True)] ) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=np.zeros((64, 80, 4), dtype=np.uint8)) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=True) bot.send_reply = mock.Mock() bot._poll_once() # 邮件/文档/加载页：只恢复消息入口。 self.assertIs(bot._pending_reply_sessions[fp.hex()], state) bot._resume_orphaned_pending_reply.assert_not_called() bot._poll_once() # 下一轮已回消息页：恢复原已读未回复任务。 bot._resume_orphaned_pending_reply.assert_called_once() self.assertIs(bot._pending_reply_sessions[fp.hex()], state) bot.send_reply.assert_not_called() def test_pending_persist_failure_prevents_unread_click(self): """Never consume the unread badge when its recovery task is not durable.""" bot = WeChatBot.__new__(WeChatBot) fp = b"d" * 40 message_page = self._nav_surface(True) session_page = np.zeros((180, 460, 4), dtype=np.uint8) bot.scale = 1.0 bot.session_item_h = 64 bot.list_region = {"top": 100} bot.list_click_x = 200 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = set() bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=session_page) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( return_value=(session_page, 16, fp) ) bot._send_gate_open = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock(return_value=False) bot._activate_wx = mock.Mock(return_value=True) bot.click_session = mock.Mock(return_value=True) bot._poll_once() bot._mark_reply_pending.assert_called_once_with( fp, confirmed_unread=True, requires_visual_proof=False, bind_identity=False, ) bot._activate_wx.assert_not_called() bot.click_session.assert_not_called() def test_selected_mismatch_keeps_preclick_pending_on_disk(self): """A post-click render mismatch must not lose the now-read message.""" with tempfile.TemporaryDirectory() as directory: bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 message_page = self._nav_surface(True) session_page = np.zeros((180, 460, 4), dtype=np.uint8) bot.scale = 1.0 bot.session_item_h = 64 bot.list_region = {"top": 100} bot.list_click_x = 200 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = set() bot._pending_reply_path = os.path.join( directory, "pending_replies.json", ) bot._pending_reply_sessions = {} bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=session_page) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( return_value=(session_page, 16, fp) ) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) bot._last_click_failure_reason = "selected_fingerprint_mismatch" bot.click_session = mock.Mock(return_value=False) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._poll_once() state = bot._pending_reply_state(fp) self.assertIsNotNone(state) self.assertTrue(state["confirmed_unread"]) self.assertNotIn("identity_signature", state) # 指纹对不上多半是列表在识别和点击之间重排了，等一下重定位再点一次； # 两次都不行才跳过它去服务其他未读会话（这里的桩固定返回同一个目标， # 真实扫描会因为 processed_fp 而换人） self.assertEqual( bot.click_session.call_args_list[:2], [mock.call(16, expected_fp=fp)] * 2, ) with open(bot._pending_reply_path, encoding="utf-8") as handle: persisted = json.load(handle) self.assertTrue(persisted[fp.hex()]["confirmed_unread"]) def test_confirmed_unread_pending_older_than_24_hours_is_restored(self): with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") fp = b"o" * 40 with open(path, "w", encoding="utf-8") as handle: json.dump( { fp.hex(): { "confirmed_unread": True, "batch_ready": False, "updated_at": 1.0, } }, handle, ) bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_path = path with mock.patch("wechat_bot.time.time", return_value=200000.0): restored = bot._load_pending_replies() self.assertIn(fp.hex(), restored) self.assertTrue(restored[fp.hex()]["confirmed_unread"]) def test_startup_archive_delta_creates_pending_and_enters_retry(self): """A selected read message newer than its archive snapshot is recoverable.""" bot = WeChatBot.__new__(WeChatBot) fp = b"a" * 40 title = b"customer-title" session_page = np.zeros((180, 460, 4), dtype=np.uint8) visible_text = ( "Agent 09:00:00\nold reply\n" "Customer 09:01:00\nnew question" ) bot.scale = 1.0 bot.session_item_h = 64 bot._selected_tracking_initialized = False bot._active_session_fp = None bot._active_identity_signature = None bot._active_chat_signature = None bot._pending_reply_path = "" bot._pending_reply_sessions = {} bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=32) bot._chat_identity_signature = mock.Mock(return_value=title) bot._session_fingerprint = mock.Mock(return_value=fp) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) bot._is_tool_selected = mock.Mock(return_value=False) bot._ensure_session_archive_key = mock.Mock() bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._activate_wx = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock(return_value=visible_text) bot.store = mock.Mock() bot.store.has_record.return_value = True bot.store.last_lines.return_value = [ "Agent 09:00:00", "old reply", ] bot.store.history.return_value = [] bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=False) bot._wait_for_message_batch = mock.Mock(return_value=False) bot._generate_ai_reply = mock.Mock(return_value="must not run") bot.send_reply = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse(bot._check_selected_session(session_page)) state = bot._pending_reply_state(fp) self.assertIsNotNone(state) self.assertEqual(state["identity_signature"], title) bot._wait_for_message_batch.assert_called_once_with(fp) bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() click.assert_not_called() def test_restart_binds_bold_unread_pending_to_selected_regular_render(self): """Persisted render metadata recovers one task without changing its key.""" with tempfile.TemporaryDirectory() as directory: path = os.path.join(directory, "pending_replies.json") unread = np.full((160, 460, 4), 245, dtype=np.uint8) selected = np.full( (160, 460, 4), (210, 130, 45, 255), dtype=np.uint8, ) unread[:, :, 3] = 255 for image in (unread, selected): for y in range(40, 88): for x in range(20, 84): image[y, x, :3] = ( (x * 3) % 255, (y * 5) % 255, (x + y) % 255, ) # The same two glyph centre-lines use WeCom's unread-bold and # selected-regular weights respectively. unread[27:56, 178:187, :3] = 20 unread[34:44, 168:204, :3] = 20 unread[28:56, 224:233, :3] = 20 unread[45:55, 216:246, :3] = 20 selected[29:54, 181:184, :3] = 250 selected[37:40, 171:201, :3] = 250 selected[30:54, 227:230, :3] = 250 selected[48:51, 219:243, :3] = 250 # Same avatar, different first name glyph. It must never inherit # the original task even though its avatar hash is identical. distractor = selected.copy() distractor[48:55, 126:142, :3] = 250 distractor[51:58, 146:158, :3] = 250 producer = WeChatBot.__new__(WeChatBot) producer.scale = 2.0 producer.session_item_h = 128 producer._known_fps = set() producer._known_session_fps = set() producer._pending_reply_path = path producer._pending_reply_sessions = {} unread_fp = producer._session_fingerprint( unread, 64, row_center=True, ) distractor_fp = producer._session_fingerprint( distractor, 64, row_center=True, ) self.assertEqual(unread_fp[:8], distractor_fp[:8]) self.assertNotEqual(unread_fp, distractor_fp) self.assertFalse( producer._live_render_transition_match( unread_fp, distractor_fp, ) ) self.assertTrue( producer._mark_reply_pending( unread_fp, confirmed_unread=True, bind_identity=False, ) ) with open(path, encoding="utf-8") as handle: persisted = json.load(handle) self.assertTrue( persisted[unread_fp.hex()]["render_identities"] ) # Simulate a fresh process: only the pending task and its render # metadata survive; live alias pairs deliberately do not. bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 bot._pending_reply_path = path bot._pending_reply_sessions = bot._load_pending_replies() bot._session_render_ids = { key: set(state.get("render_identities") or []) for key, state in bot._pending_reply_sessions.items() } bot._known_fps = {unread_fp[:8]} bot._known_session_fps = {unread_fp} bot._live_session_fp_aliases = set() bot._selected_tracking_initialized = False bot._active_session_fp = None bot._active_identity_signature = None bot._active_chat_signature = None bot._capture_full_window = mock.Mock( return_value=self._nav_surface(True) ) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=64) bot._chat_identity_signature = mock.Mock( return_value=b"original-customer-title" ) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) bot._is_tool_selected = mock.Mock(return_value=False) bot._ensure_session_archive_key = mock.Mock() bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._activate_wx = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock( return_value="Customer 09:01:00\nnew question" ) bot._has_pending_customer_message = mock.Mock(return_value=True) bot.store = mock.Mock() bot._wait_for_message_batch = mock.Mock(return_value=False) bot._generate_ai_reply = mock.Mock(return_value="must not run") bot.send_reply = mock.Mock(return_value=True) with mock.patch("wechat_bot.pyautogui.click") as click: self.assertFalse(bot._check_selected_session(selected)) selected_fp = bot._session_fingerprint( selected, 64, row_center=True, ) restarted_distractor_fp = bot._session_fingerprint( distractor, 64, row_center=True, ) self.assertNotEqual(selected_fp, unread_fp) self.assertTrue(bot._session_fp_matches(selected_fp, unread_fp)) self.assertFalse( bot._session_fp_matches(restarted_distractor_fp, unread_fp) ) self.assertEqual( set(bot._pending_reply_sessions), {unread_fp.hex()}, ) state = bot._pending_reply_sessions[unread_fp.hex()] self.assertEqual( state["identity_signature"], b"original-customer-title", ) bot._wait_for_message_batch.assert_called_once_with(unread_fp) bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() click.assert_not_called() def test_flat_system_entry_clears_the_preclick_pending_reservation(self): bot = WeChatBot.__new__(WeChatBot) fp = b"f" * 40 message_page = self._nav_surface(True) non_message_page = self._nav_surface(False) session_page = np.zeros((180, 460, 4), dtype=np.uint8) bot.scale = 1.0 bot.session_item_h = 64 bot.list_region = {"top": 100} bot.list_click_x = 200 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = {fp.hex()} bot._flat_rejected_session_fps = set() bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock( side_effect=[message_page, message_page, non_message_page, message_page] ) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=session_page) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( side_effect=[(session_page, 32, fp), None] ) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) # click_session now proves a navigation exit with two post-click frames # and reports the reason to the poller. This mock bypasses that method, # so provide the proved outcome explicitly. bot._last_click_failure_reason = "left_message_workspace" bot.click_session = mock.Mock(return_value=False) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock() bot.send_reply = mock.Mock() bot._poll_once() self.assertIn(fp.hex(), bot._flat_rejected_session_fps) self.assertNotIn(fp.hex(), bot._flat_visual_proof_fps) bot._ensure_message_workspace.assert_called_once_with("系统入口识别") bot._mark_reply_pending.assert_called_once_with( fp, confirmed_unread=True, requires_visual_proof=True, bind_identity=False, ) bot.send_reply.assert_not_called() def test_real_wechat_external_avatar_survives_transient_nav_false(self): """The green @微信 default avatar is a contact, not a system entry.""" # Programmatic copy of the 200% DPI field geometry. Never use # debug_skipped_row0.png as a fixture: production deliberately # overwrites that diagnostic file whenever another row is skipped. sample = np.full((100, 116, 4), 245, dtype=np.uint8) sample[:, :, 3] = 255 selected_blue = np.array((242, 131, 48), dtype=np.uint8) sample[:, 8:, :3] = selected_blue for y in range(4, 96): for x in range(20, 112): sample[y, x, :3] = ( 35 + ((x + y) % 55), 125 + ((2 * x + y) % 105), 25 + ((x + 3 * y) % 65), ) sample[0:10, 16:28, :3] = selected_blue sample[0:10, 104:116, :3] = selected_blue sample[90:100, 16:28, :3] = selected_blue sample[90:100, 104:116, :3] = selected_blue probe = WeChatBot.__new__(WeChatBot) probe.scale = 2.0 probe.session_item_h = 128 # This field sample is WeCom's green default avatar for an external # ``@微信`` contact. It is gradient-rich and is accepted as a real row # even though it resembles some built-in application icons. self.assertFalse(probe._is_flat_icon(sample, sample.shape[0] // 2)) self.assertTrue( probe._is_real_conversation( sample, sample.shape[0] // 2, quiet=True, row_center=True, ) ) bot = WeChatBot.__new__(WeChatBot) customer_fp = b"w" * 40 message_page = self._nav_surface(True) unread_page = np.full((180, 460, 4), 245, dtype=np.uint8) unread_page[:, :, 3] = 255 unread_page[: sample.shape[0], : sample.shape[1]] = sample selected_page = unread_page.copy() # After clicking, the badge disappears and the row/preview becomes # selected. These changes are independent of the navigation highlight. selected_page[8:30, 94:122, :3] = 245 selected_page[0:128, 130:350, :3] = (238, 224, 210) bot.scale = 2.0 bot.session_item_h = 128 bot.list_region = {"top": 100} bot.list_click_x = 200 bot._session_geometry_valid = True bot.L, bot.T, bot.R, bot.B = 0, 0, 1000, 800 bot.input_x, bot.input_y = 760, 700 bot._input_geometry_valid = True bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = set() bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot._active_session_fp = None title_signature = "一个小迷糊@微信".encode("utf-8") bot._active_identity_signature = title_signature bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) # Poll precheck and click precheck are correct. The first post-click # navigation read is a false negative during repaint; the confirming # read succeeds while the selected conversation and input remain valid. bot._message_nav_selected = mock.Mock( side_effect=[True, True, False, True] ) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock( side_effect=[unread_page, unread_page, selected_page] ) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( side_effect=[(unread_page, 16, customer_fp), None] ) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) bot.detect_badge_rows = mock.Mock(return_value=[16]) bot._session_fingerprint = mock.Mock(return_value=customer_fp) bot.detect_selected_row = mock.Mock(return_value=64) bot._is_tool_selected = mock.Mock(return_value=False) bot._chat_identity_signature = mock.Mock( return_value=title_signature ) bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._run_ai_page_guard = mock.Mock(return_value=False) bot._escape_proven_blocker = mock.Mock(return_value=False) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock() bot._wait_for_message_batch = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="已回复外部联系人") bot.send_reply = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): bot._poll_once() self.assertNotIn(customer_fp.hex(), bot._flat_rejected_session_fps) bot._ensure_message_workspace.assert_not_called() bot._mark_reply_pending.assert_any_call( customer_fp, confirmed_unread=True, requires_visual_proof=False, ) bot._generate_ai_reply.assert_called_once_with( customer_fp, confirmed_unread=True, ) bot.send_reply.assert_called_once_with( "已回复外部联系人", session_id=customer_fp.hex(), expected_fp=customer_fp, ) def test_flat_fingerprint_mismatch_is_not_reclassified_as_system_entry(self): """A row-render mismatch must retry, never permanently blacklist a contact.""" bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 message_page = self._nav_surface(True) session_page = np.zeros((180, 460, 4), dtype=np.uint8) bot.scale = 1.0 bot.session_item_h = 64 bot.list_region = {"top": 100} bot.list_click_x = 200 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = {fp.hex()} bot._flat_rejected_session_fps = set() bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock(return_value=session_page) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( return_value=(session_page, 16, fp) ) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) bot._last_click_failure_reason = "selected_fingerprint_mismatch" bot.click_session = mock.Mock(return_value=False) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock() bot._poll_once() self.assertNotIn(fp.hex(), bot._flat_rejected_session_fps) self.assertIn(fp.hex(), bot._flat_visual_proof_fps) bot._ensure_message_workspace.assert_not_called() # 关键是这个联系人没被拉黑、任务照常落盘；至于本轮重试几次由排队策略决定 self.assertEqual( bot._mark_reply_pending.call_args, mock.call( fp, confirmed_unread=True, requires_visual_proof=True, bind_identity=False, ), ) def test_flat_real_row0_same_open_title_enters_visual_reply_flow(self): """A selected real chat can keep the same title when its unread row is clicked.""" bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 message_page = self._nav_surface(True) unread_page = np.zeros((180, 460, 4), dtype=np.uint8) selected_page = unread_page.copy() # Model the two visible changes from the real log: the unread badge is # gone and row0 now has selected/updated preview pixels. The chat title # legitimately remains unchanged because this conversation was already # open when its new message arrived. unread_page[12:24, 105:117, :3] = (70, 70, 245) selected_page[0:64, 120:300, :3] = (238, 224, 210) bot.scale = 1.0 bot.session_item_h = 64 bot.list_region = {"top": 100} bot.list_click_x = 200 bot._session_geometry_valid = True bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot._flat_visual_proof_fps = {fp.hex()} bot._flat_verified_session_fps = set() bot._flat_rejected_session_fps = set() bot._active_session_fp = None bot._active_identity_signature = b"same-title" bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) bot._message_nav_selected = mock.Mock(return_value=True) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock( side_effect=[unread_page, unread_page, selected_page] ) bot._check_selected_session = mock.Mock(return_value=False) bot._resume_orphaned_pending_reply = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock( side_effect=[(unread_page, 16, fp), None] ) bot._send_gate_open = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) bot.detect_badge_rows = mock.Mock(return_value=[16]) bot._session_fingerprint = mock.Mock(return_value=fp) bot.detect_selected_row = mock.Mock(return_value=32) bot._is_tool_selected = mock.Mock(return_value=False) bot._chat_identity_signature = mock.Mock(return_value=b"same-title") bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._run_ai_page_guard = mock.Mock(return_value=False) bot._escape_proven_blocker = mock.Mock(return_value=False) bot._ensure_message_workspace = mock.Mock(return_value=True) bot._mark_reply_pending = mock.Mock() bot._wait_for_message_batch = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="视觉确认后的回复") bot.send_reply = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): bot._poll_once() self.assertNotIn(fp.hex(), bot._flat_rejected_session_fps) self.assertIn(fp.hex(), bot._flat_visual_proof_fps) bot._ensure_message_workspace.assert_not_called() bot._mark_reply_pending.assert_any_call( fp, confirmed_unread=True, requires_visual_proof=True, ) bot._generate_ai_reply.assert_called_once_with( fp, confirmed_unread=True, ) bot.send_reply.assert_called_once_with( "视觉确认后的回复", session_id=fp.hex(), expected_fp=fp, ) def test_full_business_page_returns_to_messages_without_blind_escape(self): bot = WeChatBot.__new__(WeChatBot) surface = self._nav_surface(False) bot._message_nav_selected = mock.Mock(return_value=False) bot._security_gate_visible = mock.Mock(return_value=False) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._open_messages_page = mock.Mock(return_value=True) bot._run_ai_page_guard = mock.Mock(return_value=False) with mock.patch("wechat_bot.pyautogui.press") as press: self.assertTrue(bot._ensure_message_workspace("轮询前", full=surface)) press.assert_not_called() bot._open_messages_page.assert_called_once_with( "轮询前检测到当前不在消息页，" ) bot._run_ai_page_guard.assert_not_called() def test_open_messages_uses_safe_message_row_in_wide_navigation(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.scale = 2.0 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._message_page_misses = 3 bot._selected_tracking_initialized = True bot._active_session_fp = b"old" bot._active_chat_signature = b"old" bot._active_identity_signature = b"old" with ( mock.patch("wechat_bot.safe_set_foreground"), mock.patch( "wechat_bot.win32gui.GetWindowRect", return_value=(400, 300, 2600, 1600), ), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=100), mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._open_messages_page("测试：")) # 回退布局下“消息”行为逻辑 y 65~105，点击行中心 85（物理 170）。 click.assert_called_once_with(468, 470) @staticmethod def _wide_nav_surface_with_profile_block(): """宽文字导航，且“消息”不在第一位：上方还有个人资料块。""" image = np.full((700, 900, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 # 导航列浅蓝灰底色（BGR），宽 300 物理像素；右侧是白色会话列表。 image[:, :300, :3] = (250, 232, 215) # 个人资料块：头像 + 名字文字（深色内容）。 image[40:104, 20:84, :3] = (90, 90, 90) image[56:88, 100:220, :3] = (60, 60, 60) # “消息”行：图标 + 文字。 image[264:300, 40:76, :3] = (238, 126, 36) image[268:296, 100:170, :3] = (60, 60, 60) # “邮件”行。 image[340:376, 40:76, :3] = (120, 120, 120) image[344:372, 100:170, :3] = (60, 60, 60) return image def test_message_nav_band_located_by_text_when_not_first(self): """“消息”上方有个人资料块时，靠 OCR 文字定位它的行。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 reader = mock.Mock() reader.available = True reader.read_raw = mock.Mock(side_effect=[("高兴亮", 0.9), ("消息1", 0.95)]) bot._name_reader_instance = reader surface = self._wide_nav_surface_with_profile_block() y1, y2, located = bot._message_nav_band(surface) self.assertTrue(located) self.assertLessEqual(y1, 268) self.assertGreaterEqual(y2, 296) # 缓存生效：同尺寸画面不再触发 OCR。 bot._message_nav_band(surface) self.assertEqual(reader.read_raw.call_count, 2) def test_message_nav_band_falls_back_without_wide_text_column(self): """窄图标栏 / 找不到导航分界时回退旧的固定位置，不加载 OCR。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 image = np.full((700, 900, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 y1, y2, located = bot._message_nav_band(image) self.assertFalse(located) self.assertEqual((y1, y2), (130, 210)) # 回退路径绝不能触碰 OCR 模型加载。 self.assertIsNone(getattr(bot, "_name_reader_instance", None)) def test_message_nav_selected_uses_located_band(self): """选中态校验跟随动态定位的“消息”行，而不是固定 y 65~105。""" bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 image = np.full((700, 900, 4), 242, dtype=np.uint8) image[:, :, 3] = 255 bot._msg_nav_band_cache = ((700, 900), (264, 304, True)) # 高亮画在定位到的行上 → 判定为消息页。 selected = image.copy() selected[264:304, 4:120, :3] = (238, 126, 36) self.assertTrue(bot._message_nav_selected(selected)) # 高亮画在旧的固定位置（65~105 逻辑）→ 不是消息被选中。 other = image.copy() other[130:210, 4:120, :3] = (238, 126, 36) self.assertFalse(bot._message_nav_selected(other)) def test_open_messages_clicks_located_band_center(self): bot = WeChatBot.__new__(WeChatBot) bot.hwnd = 100 bot.scale = 2.0 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() surface = np.full((700, 900, 4), 242, dtype=np.uint8) surface[:, :, 3] = 255 bot._capture_full_window = mock.Mock(return_value=surface) bot._msg_nav_band_cache = ((700, 900), (400, 480, True)) bot._message_nav_selected = mock.Mock(return_value=True) bot._message_page_misses = 0 bot._selected_tracking_initialized = False bot._active_session_fp = None bot._active_chat_signature = None bot._active_identity_signature = None with ( mock.patch("wechat_bot.safe_set_foreground"), mock.patch( "wechat_bot.win32gui.GetWindowRect", return_value=(400, 300, 2600, 1600), ), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=100), mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._open_messages_page("测试：")) click.assert_called_once_with(468, 740) def test_global_unread_signature_follows_located_band(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot._list_x = 300 image = np.full((700, 900, 4), 245, dtype=np.uint8) image[:, :, 3] = 255 bot._msg_nav_band_cache = ((700, 900), (264, 304, True)) # 红点画在定位到的“消息”行内 → 有全局未读。 with_badge = image.copy() with_badge[270:290, 240:270, :3] = (81, 81, 250) self.assertTrue(bot._global_unread_signature(with_badge)) # 红点画在旧固定位置（该布局下属于别的入口）→ 不算消息未读。 wrong_row = image.copy() wrong_row[140:160, 240:270, :3] = (81, 81, 250) self.assertFalse(bot._global_unread_signature(wrong_row)) def test_unread_group_band_requires_unique_exact_ocr_label(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot._list_x = 300 bot._msg_nav_band_cache = ((700, 900), (264, 304, True)) bot._nav_column_width_px = mock.Mock(return_value=300) reader = mock.Mock() reader.available = True reader.read_layout.return_value = [ {"text": "分组", "x1": 40, "y1": 430, "y2": 458, "score": 0.99}, {"text": "未读", "x1": 90, "y1": 500, "y2": 528, "score": 0.98}, {"text": "5", "x1": 250, "y1": 502, "y2": 526, "score": 0.99}, ] bot._name_reader_instance = reader surface = np.full((700, 900, 4), 245, dtype=np.uint8) surface[:, :, 3] = 255 self.assertEqual( bot._locate_unread_group_band_by_text(surface), (480, 548), ) reader.read_layout.return_value.append( {"text": "未读", "x1": 100, "y1": 610, "y2": 638, "score": 0.97} ) self.assertIsNone(bot._locate_unread_group_band_by_text(surface)) def test_open_unread_group_requires_two_post_click_frames(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.hwnd = 100 bot._list_x = 300 bot._unread_filter_active = False bot._unread_scan_resume = False bot._unread_filtered_center_fps = set() bot._unread_candidate_names = {} bot._last_unread_discovery_log = ("", 0.0) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._unread_group_band = mock.Mock(return_value=(500, 540)) bot._locate_unread_group_band_by_text = mock.Mock(return_value=(500, 540)) bot._nav_column_width_px = mock.Mock(return_value=300) bot._capture_full_window = mock.Mock( return_value=np.zeros((700, 900, 4), dtype=np.uint8) ) before = np.zeros((120, 100, 4), dtype=np.uint8) filtered = np.ones((120, 100, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock( side_effect=[before, filtered, filtered] ) bot._session_page_signature = mock.Mock( side_effect=[b"ordinary", b"filtered", b"filtered"] ) bot._looks_like_message_list = mock.Mock(return_value=True) bot._unread_group_selected = mock.Mock(return_value=False) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() bot.report_progress = mock.Mock() bot._log_unread_discovery = mock.Mock() with ( mock.patch("wechat_bot.safe_set_foreground", return_value=True), mock.patch("wechat_bot.win32gui.GetForegroundWindow", return_value=100), mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=(0, 0, 900, 700)), mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._open_unread_group()) self.assertTrue(bot._unread_filter_active) click.assert_called_once_with(102, 520) self.assertEqual(bot.capture_session_list.call_count, 3) def test_completed_ordinary_scan_switches_to_hidden_unread_group(self): bot = WeChatBot.__new__(WeChatBot) ordinary = np.zeros((80, 100, 4), dtype=np.uint8) filtered = np.ones((80, 100, 4), dtype=np.uint8) target = (filtered, 40, b"t" * 40) bot._unread_filter_active = False bot._unread_scan_resume = False bot._strict_visual_actions = True bot.capture_session_list = mock.Mock( side_effect=[ordinary, ordinary, filtered] ) bot._target_from_session_image = mock.Mock(return_value=None) bot._deep_unread_scan_allowed = mock.Mock(return_value=True) bot._scroll_session_list_top = mock.Mock() bot._scroll_session_list_page = mock.Mock(return_value=None) bot._session_page_signature = mock.Mock(return_value=b"ordinary") bot._capture_full_window = mock.Mock(return_value=ordinary) bot._global_unread_signature = mock.Mock(return_value=b"five") bot._log_unread_discovery = mock.Mock() def open_filter(_full): bot._unread_filter_active = True return True bot._open_unread_group = mock.Mock(side_effect=open_filter) bot._scan_unread_filter = mock.Mock(return_value=target) self.assertEqual( bot._find_next_unread_session(set(), set(), full=ordinary), target, ) bot._open_unread_group.assert_called_once_with(ordinary) bot._scan_unread_filter.assert_called_once_with(filtered, set(), set()) def test_filtered_unread_list_uses_avatar_row_and_name_without_red_dot(self): bot = WeChatBot.__new__(WeChatBot) bot._unread_filter_active = True bot.identity_by_name = True bot._strict_visual_actions = True bot._flat_visual_proof_fps = set() image = np.zeros((120, 180, 4), dtype=np.uint8) target = WeChatBot._fp_from_name("客户甲@微信") bot._avatar_row_centers = mock.Mock(return_value=[52]) bot._row_display_name = mock.Mock(return_value="客户甲@微信") bot._is_system_entry_name = mock.Mock(return_value=False) bot._session_fingerprint = mock.Mock(return_value=target) bot._flat_session_rejected = mock.Mock(return_value=False) bot._is_real_conversation = mock.Mock(return_value=True) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) self.assertEqual( bot._target_from_filtered_unread_image(image, set(), set()), (52, target, "客户甲@微信"), ) def test_session_vision_model_link_error_is_not_cached(self): bot = WeChatBot.__new__(WeChatBot) bot._strict_visual_actions = True bot._session_row_ai_cache = {} bot.session_item_h = 64 bot._ui_guard_image_bytes = mock.Mock(return_value=b"row") bot._row_preview_text = mock.Mock(return_value="预览") bot.report_progress = mock.Mock() image = np.zeros((128, 180, 4), dtype=np.uint8) with mock.patch( "ai_chat.classify_wecom_session_row", side_effect=RuntimeError("temporary link error"), ): decision = bot._classify_ambiguous_session_row( image, 64, b"x" * 40, "客户甲", row_center=True, ) self.assertEqual(decision["kind"], "unknown") self.assertEqual(bot._session_row_ai_cache, {}) bot.report_progress.assert_called_once_with( "视觉模型链路失败，未读消息已保留等待重试" ) def test_filtered_unread_row_may_disappear_only_after_exact_title_proof(self): bot = WeChatBot.__new__(WeChatBot) name = "客户甲@微信" target = WeChatBot._fp_from_name(name) bot.scale = 1.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot._session_geometry_valid = True bot._active_session_fp = None bot._unread_filtered_center_fps = {target.hex()} bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock( return_value=np.zeros((300, 600, 4), dtype=np.uint8) ) bot._message_workspace_selected = mock.Mock(return_value=True) latest = np.zeros((160, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot._pending_reply_state = mock.Mock( return_value={"requires_visual_proof": True} ) bot._is_real_conversation = mock.Mock(return_value=True) bot._session_fingerprint = mock.Mock(return_value=target) bot._chat_identity_signature = mock.Mock(return_value=b"title-render") bot._raw_selected_session_fingerprint = mock.Mock(return_value=None) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._open_chat_display_name = mock.Mock(return_value=name) bot._chat_surface_signature = mock.Mock(return_value=b"chat-ready") bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.click_session(64, expected_fp=target, row_center=True) ) bot._open_chat_display_name.assert_called_once_with() bot._remember_active_surface.assert_called_once_with(target) def test_navigation_width_inference_accepts_custom_band(self): image = np.full((700, 900, 4), 248, dtype=np.uint8) image[:, :, 3] = 255 # “消息”行在 y 264~304（不在第一位），浅蓝底色只画在这一行。 image[264:304, :300, :3] = (250, 232, 215) image[264:304, 300:, :3] = (245, 245, 245) self.assertEqual( infer_navigation_width(image, 2.0, band=(264, 304))[0], 300, ) # 不传 band 时按旧固定行采样，该布局下识别不出宽度。 self.assertLess(infer_navigation_width(image, 2.0)[1], 0.12) def test_unchanged_selected_chat_does_not_activate_or_move_mouse(self): bot = WeChatBot.__new__(WeChatBot) bot.detect_selected_row = mock.Mock(return_value=-1) bot._chat_identity_signature = mock.Mock(return_value=b"identity") bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._active_session_fp = b"target" bot._active_identity_signature = b"identity" bot._active_chat_signature = b"surface" bot._selected_tracking_initialized = True bot._activate_wx = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) image = np.zeros((64, 80, 4), dtype=np.uint8) self.assertFalse(bot._check_selected_session(image)) bot._activate_wx.assert_not_called() def test_message_batch_collects_updates_then_allows_one_request(self): bot = WeChatBot.__new__(WeChatBot) bot._stop_check = None bot._active_identity_signature = b"identity" bot._chat_identity_signature = mock.Mock(return_value=b"identity") bot._chat_surface_signature = mock.Mock( side_effect=[b"start", b"start", b"second", b"third"] + [b"third"] * 20 ) bot._capture_full_window = mock.Mock(return_value=np.zeros((20, 20, 4), dtype=np.uint8)) bot._message_nav_selected = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) self.assertTrue( bot._wait_for_message_batch( b"target", window_seconds=0.02, poll_seconds=0.005, ) ) bot.wait_for_mouse_idle.assert_called_once() def test_message_batch_aborts_when_chat_identity_changes(self): bot = WeChatBot.__new__(WeChatBot) bot._stop_check = None bot._active_identity_signature = b"identity" bot._chat_identity_signature = mock.Mock(side_effect=[b"identity", b"other"]) bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._capture_full_window = mock.Mock(return_value=np.zeros((20, 20, 4), dtype=np.uint8)) bot._message_nav_selected = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) self.assertFalse( bot._wait_for_message_batch( b"target", window_seconds=0.05, poll_seconds=0.005, ) ) bot.wait_for_mouse_idle.assert_not_called() def test_message_batch_aborts_when_same_title_switches_to_another_session(self): """A same-title manual switch must not contaminate the original pending batch.""" bot = WeChatBot.__new__(WeChatBot) target = b"target-session" other = b"other-session!" bot._stop_check = None bot._active_session_fp = target bot._active_identity_signature = b"same-visible-title" bot._chat_identity_signature = mock.Mock(return_value=b"same-visible-title") bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._selected_session_fingerprint = mock.Mock( side_effect=[target, other] ) bot._capture_full_window = mock.Mock( return_value=np.zeros((20, 20, 4), dtype=np.uint8) ) bot._message_nav_selected = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) self.assertFalse( bot._wait_for_message_batch( target, window_seconds=0.05, poll_seconds=0.005, ) ) bot.wait_for_mouse_idle.assert_not_called() def test_message_batch_accepts_title_render_drift_for_same_full_session(self): bot = WeChatBot.__new__(WeChatBot) fp = b"m" * 40 state = { "batch_ready": False, "identity_signature": b"old-render", } bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._stop_check = None bot._active_session_fp = fp bot._active_identity_signature = b"old-render" bot._chat_identity_signature = mock.Mock( side_effect=[b"first-new-render", b"second-new-render"] ) bot._chat_surface_signature = mock.Mock(return_value=b"stable-surface") bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._persist_pending_replies = mock.Mock(return_value=True) bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._activate_wx = mock.Mock(return_value=True) self.assertTrue( bot._wait_for_message_batch( fp, window_seconds=0.0, poll_seconds=0.05, ) ) self.assertEqual(state["identity_signature"], b"second-new-render") def test_message_batch_retry_keeps_original_persisted_deadline(self): """A transient retry must wait only the original window's remainder.""" bot = WeChatBot.__new__(WeChatBot) target = b"t" * 40 bot._pending_reply_path = "" bot._pending_reply_sessions = { target.hex(): {"batch_ready": False}, } bot._active_session_fp = target bot._active_identity_signature = b"identity" bot._chat_identity_signature = mock.Mock(return_value=b"identity") bot._chat_surface_signature = mock.Mock(return_value=b"surface") bot._raw_selected_session_fingerprint = mock.Mock(return_value=target) bot._selected_session_fingerprint = mock.Mock(return_value=target) bot._stop_check = mock.Mock() bot._stop_check.wait.return_value = True with ( mock.patch("wechat_bot.time.time", return_value=100.0), mock.patch("wechat_bot.time.monotonic", return_value=0.0), ): self.assertFalse( bot._wait_for_message_batch( target, window_seconds=7.0, poll_seconds=0.5, ) ) original_deadline = bot._pending_reply_state(target)["batch_deadline_at"] self.assertEqual(original_deadline, 107.0) bot._stop_check.wait.reset_mock() with ( mock.patch("wechat_bot.time.time", return_value=106.8), mock.patch("wechat_bot.time.monotonic", return_value=0.0), ): self.assertFalse( bot._wait_for_message_batch( target, window_seconds=7.0, poll_seconds=0.5, ) ) self.assertEqual( bot._pending_reply_state(target)["batch_deadline_at"], original_deadline, ) self.assertAlmostEqual( bot._stop_check.wait.call_args.args[0], 0.2, places=5, ) def test_marking_batch_ready_clears_persisted_merge_deadline(self): bot = WeChatBot.__new__(WeChatBot) target = b"r" * 40 bot._pending_reply_path = "" bot._pending_reply_sessions = { target.hex(): { "batch_ready": False, "batch_started_at": 100.0, "batch_deadline_at": 120.0, "batch_window_seconds": 20.0, }, } bot._live_render_ids_for = mock.Mock(return_value=set()) self.assertTrue(bot._mark_reply_pending(target, batch_ready=True)) state = bot._pending_reply_state(target) self.assertTrue(state["batch_ready"]) self.assertNotIn("batch_started_at", state) self.assertNotIn("batch_deadline_at", state) self.assertNotIn("batch_window_seconds", state) def test_hidden_unread_is_found_on_third_scanned_page(self): bot = WeChatBot.__new__(WeChatBot) pages = [ np.full((40, 40, 4), value, dtype=np.uint8) for value in (10, 20, 30, 40) ] bot.capture_session_list = mock.Mock(side_effect=[pages[0], pages[1]]) bot._target_from_session_image = mock.Mock( side_effect=[None, None, None, (12, b"customer")] ) bot._deep_unread_scan_allowed = mock.Mock(return_value=True) bot._scroll_session_list_top = mock.Mock() bot._scroll_session_list_page = mock.Mock(side_effect=[pages[2], pages[3]]) found = bot._find_next_unread_session(set(), set(), full=pages[0]) self.assertEqual(found[1:], (12, b"customer")) self.assertIs(found[0], pages[3]) self.assertEqual(bot._scroll_session_list_page.call_count, 2) def test_deep_unread_scan_resumes_after_time_budget_instead_of_restarting(self): bot = WeChatBot.__new__(WeChatBot) pages = [ np.full((40, 40, 4), value, dtype=np.uint8) for value in (10, 20) ] bot._unread_scan_resume = False bot.capture_session_list = mock.Mock( side_effect=[pages[0], pages[0], pages[1]] ) bot._target_from_session_image = mock.Mock(return_value=None) bot._deep_unread_scan_allowed = mock.Mock(return_value=True) bot._scroll_session_list_top = mock.Mock() bot._scroll_session_list_page = mock.Mock( side_effect=[pages[1], None] ) with ( mock.patch("wechat_bot.SESSION_SCAN_MAX_SECONDS", 0.0), mock.patch("wechat_bot.time.monotonic", return_value=100.0), ): self.assertIsNone( bot._find_next_unread_session(set(), set(), full=pages[0]) ) self.assertTrue(bot._unread_scan_resume) # First pass went to the top once; it deliberately did not jump back. self.assertEqual(bot._scroll_session_list_top.call_count, 1) bot._scroll_session_list_top.reset_mock() with mock.patch("wechat_bot.time.monotonic", return_value=101.0): self.assertIsNone( bot._find_next_unread_session(set(), set(), full=pages[1]) ) self.assertFalse(bot._unread_scan_resume) # The resumed pass started at page[1] and only returned to top at bottom. bot._scroll_session_list_top.assert_called_once() def test_deep_unread_resume_is_not_cancelled_by_scan_cooldown(self): """A paused forward scan must continue while the global unread still exists.""" bot = WeChatBot.__new__(WeChatBot) page = np.full((40, 40, 4), 20, dtype=np.uint8) bot._unread_scan_resume = True bot.capture_session_list = mock.Mock(return_value=page) bot._target_from_session_image = mock.Mock(return_value=None) bot._deep_unread_scan_allowed = mock.Mock(return_value=False) bot._global_unread_signature = mock.Mock(return_value=b"still-unread") bot._scroll_session_list_top = mock.Mock() bot._scroll_session_list_page = mock.Mock(return_value=None) self.assertIsNone( bot._find_next_unread_session(set(), set(), full=page) ) bot._scroll_session_list_page.assert_called_once_with(page) self.assertFalse(bot._unread_scan_resume) def test_read_pending_conversation_is_reopened_by_fingerprint(self): bot = WeChatBot.__new__(WeChatBot) fp = b"p" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": True, "chat_text": "客户甲 10:00:00\n待回复内容", "identity_signature": b"same-title-old-render", } } bot._pending_reply_path = "" bot._active_session_fp = b"a" * 40 bot._active_identity_signature = b"another-title" bot._send_gate_open = mock.Mock(return_value=True) page = np.zeros((200, 100, 4), dtype=np.uint8) bot._find_pending_session = mock.Mock(return_value=(page, 64)) def open_target(*_args, **_kwargs): bot._active_session_fp = fp bot._active_identity_signature = b"same-title-new-render" return True bot.click_session = mock.Mock(side_effect=open_target) bot._chat_identity_signature = mock.Mock( side_effect=[b"another-title", b"same-title-new-render"] ) bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._persist_pending_replies = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="继续回复") bot._activate_wx = mock.Mock(return_value=True) bot.send_reply = mock.Mock(return_value=True) with ( mock.patch("wechat_bot.time.monotonic", return_value=100.0), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot._resume_orphaned_pending_reply()) bot.click_session.assert_called_once_with( 64, expected_fp=fp, row_center=True, ) bot._generate_ai_reply.assert_called_once_with( fp, confirmed_unread=True, ) bot.send_reply.assert_called_once_with( "继续回复", session_id=fp.hex(), expected_fp=fp, ) self.assertEqual( bot._pending_reply_state(fp)["identity_signature"], b"same-title-new-render", ) def test_pending_search_rejects_same_identity_on_different_pages(self): bot = WeChatBot.__new__(WeChatBot) fp = b"p" * 40 pages = [ np.full((80, 80, 4), value, dtype=np.uint8) for value in (10, 20, 30) ] bot._scroll_session_list_top = mock.Mock() bot.capture_session_list = mock.Mock(return_value=pages[0]) bot._pending_rows_on_page = mock.Mock( side_effect=[[12], [], [44]] ) bot._scroll_session_list_page = mock.Mock( side_effect=[pages[1], pages[2], None] ) self.assertIsNone(bot._find_pending_session(fp)) self.assertGreaterEqual(bot._scroll_session_list_top.call_count, 2) def test_pending_search_deduplicates_same_row_on_overlapping_pages(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 1.0 bot.session_item_h = 32 fp = b"o" * 40 first = np.full((120, 100, 4), 245, dtype=np.uint8) first[:, :, 3] = 255 first[18:34, 8:28, :3] = (30, 80, 150) first[50:58, 35:82, :3] = 20 first[84:104, 12:30, :3] = (90, 40, 180) second = np.full_like(first, 245) second[:, :, 3] = 255 shift = 20 second[: first.shape[0] - shift] = first[shift:] second[first.shape[0] - shift :, 40:70, :3] = 60 bot._scroll_session_list_top = mock.Mock() bot.capture_session_list = mock.Mock(side_effect=[first, first]) bot._pending_rows_on_page = mock.Mock( side_effect=[[72], [52], [72]] ) bot._scroll_session_list_page = mock.Mock( side_effect=[second, None] ) found = bot._find_pending_session(fp) self.assertIs(found[0], first) self.assertEqual(found[1], 72) def test_pending_row_scan_covers_unknown_scrolled_phase(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.session_item_h = 128 target = b"a" * 8 + b"n" * 32 page = np.zeros((300, 460, 4), dtype=np.uint8) true_center = 23 bot.detect_selected_row = mock.Mock(return_value=-1) bot.detect_badge_rows = mock.Mock(return_value=[]) bot._session_fingerprint = mock.Mock(return_value=b"x" * 40) bot._raw_session_fingerprint = mock.Mock( side_effect=lambda _img, y, row_center=True: ( target[:8] if y == true_center else b"z" * 8 ) ) bot._session_name_fingerprint = mock.Mock( side_effect=lambda _img, y, row_center=True: ( target[8:] if y == true_center else b"q" * 32 ) ) bot._is_real_conversation = mock.Mock( side_effect=lambda _img, y, **_kwargs: y == true_center ) self.assertEqual( bot._pending_rows_on_page(page, target), [true_center], ) self.assertTrue( any( call.kwargs.get("allow_flat") is True for call in bot._is_real_conversation.call_args_list ) ) def test_pending_search_scans_all_pages_then_replays_unique_page(self): bot = WeChatBot.__new__(WeChatBot) fp = b"q" * 40 pages = [ np.full((80, 80, 4), value, dtype=np.uint8) for value in (10, 20, 30) ] bot._scroll_session_list_top = mock.Mock() bot.capture_session_list = mock.Mock( side_effect=[pages[0], pages[0]] ) bot._pending_rows_on_page = mock.Mock( side_effect=[[], [], [44], [46]] ) bot._scroll_session_list_page = mock.Mock( side_effect=[ pages[1], pages[2], None, pages[1], pages[2], ] ) found = bot._find_pending_session(fp) self.assertIs(found[0], pages[2]) self.assertEqual(found[1], 46) def test_pending_search_resumes_after_budget_without_restarting_from_top(self): """Long lists must make forward progress across polling turns.""" bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 pages = [ np.full((80, 80, 4), value, dtype=np.uint8) for value in (10, 20, 30) ] bot._scroll_session_list_top = mock.Mock() bot.capture_session_list = mock.Mock( # First pass starts at page 0. The resumed pass captures page 1; # replay after a complete scan starts at page 0 again. side_effect=[pages[0], pages[1], pages[0]] ) bot._pending_rows_on_page = mock.Mock( side_effect=[[], [], [44], [46]] ) bot._scroll_session_list_page = mock.Mock( side_effect=[pages[1], pages[2], None, pages[1], pages[2]] ) # Process page 0, scroll to page 1, then exhaust this turn's budget. with mock.patch( "wechat_bot.time.monotonic", side_effect=[0.0, 46.0], ): self.assertIsNone(bot._find_pending_session(fp)) self.assertTrue(bot._pending_scan_incomplete) bot._scroll_session_list_top.assert_called_once() bot._scroll_session_list_top.reset_mock() with mock.patch("wechat_bot.time.monotonic", return_value=100.0): found = bot._find_pending_session(fp) self.assertIs(found[0], pages[2]) self.assertEqual(found[1], 46) # The resumed scan does not jump to the top before continuing. It only # returns to the top once the global uniqueness scan is complete. bot._scroll_session_list_top.assert_called_once() def test_same_avatar_with_different_title_never_resumes_cached_reply(self): bot = WeChatBot.__new__(WeChatBot) fp = b"p" * 40 other_fp = b"q" * 40 bot._pending_reply_sessions = { fp.hex(): { "batch_ready": True, "confirmed_unread": True, "chat_text": "客户甲 10:00:00\n待回复内容", "identity_signature": b"customer-a-title", } } bot._active_session_fp = b"another2" bot._active_identity_signature = b"another-title" bot._send_gate_open = mock.Mock(return_value=True) page = np.zeros((200, 100, 4), dtype=np.uint8) bot._find_pending_session = mock.Mock(return_value=(page, 64)) bot.click_session = mock.Mock(return_value=True) bot._chat_identity_signature = mock.Mock( side_effect=[b"another-title", b"customer-b-title"] ) bot._raw_selected_session_fingerprint = mock.Mock(return_value=other_fp) bot._selected_session_fingerprint = mock.Mock(return_value=other_fp) bot._generate_ai_reply = mock.Mock(return_value="绝不能发送") bot._activate_wx = mock.Mock(return_value=True) bot.send_reply = mock.Mock(return_value=True) with mock.patch("wechat_bot.time.monotonic", return_value=100.0): self.assertFalse(bot._resume_orphaned_pending_reply()) bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() def test_full_selected_fingerprint_overrides_title_render_hash_drift(self): bot = WeChatBot.__new__(WeChatBot) fp = b"t" * 40 state = {"identity_signature": b"old-render"} bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._active_session_fp = fp bot._active_identity_signature = b"old-render" bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._persist_pending_replies = mock.Mock(return_value=True) self.assertTrue( bot._chat_target_matches( fp, b"old-render", current_identity=b"new-render", ) ) self.assertTrue( bot._accept_selected_title_render( fp, state, b"new-render", ) ) self.assertEqual(state["identity_signature"], b"new-render") self.assertEqual(bot._active_identity_signature, b"new-render") def test_same_title_never_overrides_a_different_full_selected_fingerprint(self): bot = WeChatBot.__new__(WeChatBot) target = b"t" * 40 other = b"o" * 40 bot._raw_selected_session_fingerprint = mock.Mock(return_value=other) bot._selected_session_fingerprint = mock.Mock(return_value=other) self.assertFalse( bot._chat_target_matches( target, b"same-title", current_identity=b"same-title", ) ) def test_title_mismatch_without_selected_row_proof_remains_blocked(self): bot = WeChatBot.__new__(WeChatBot) target = b"t" * 40 bot._raw_selected_session_fingerprint = mock.Mock(return_value=None) bot._selected_session_fingerprint = mock.Mock(return_value=None) self.assertFalse( bot._chat_target_matches( target, b"old-render", current_identity=b"new-render", ) ) def test_legacy_pending_identity_cannot_rebind_from_a_full_selected_row(self): bot = WeChatBot.__new__(WeChatBot) legacy_fp = b"l" * 16 current_fp = b"c" * 40 state = {"identity_signature": b"legacy-title"} bot._raw_selected_session_fingerprint = mock.Mock( return_value=current_fp ) bot._selected_session_fingerprint = mock.Mock(return_value=current_fp) self.assertFalse( bot._chat_target_matches( legacy_fp, b"legacy-title", current_identity=b"new-title-render", ) ) self.assertFalse( bot._accept_selected_title_render( legacy_fp, state, b"new-title-render", ) ) self.assertEqual(state["identity_signature"], b"legacy-title") def test_title_render_rebind_failure_rolls_back_and_blocks(self): bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 state = { "identity_signature": b"old-render", "updated_at": 123.0, } bot._pending_reply_sessions = {fp.hex(): state} bot._active_session_fp = fp bot._active_identity_signature = b"old-render" bot._raw_selected_session_fingerprint = mock.Mock(return_value=fp) bot._selected_session_fingerprint = mock.Mock(return_value=fp) bot._persist_pending_replies = mock.Mock(return_value=False) self.assertFalse( bot._accept_selected_title_render( fp, state, b"new-render", ) ) self.assertEqual(state["identity_signature"], b"old-render") self.assertEqual(state["updated_at"], 123.0) self.assertEqual(bot._active_identity_signature, b"old-render") def test_pending_task_freezes_original_chat_title_signature(self): bot = WeChatBot.__new__(WeChatBot) fp = b"pending3" bot._pending_reply_sessions = {} bot._active_identity_signature = b"customer-a-title" bot._mark_reply_pending(fp, confirmed_unread=True) state = bot._pending_reply_state(fp) self.assertEqual(state["identity_signature"], b"customer-a-title") self.assertTrue(state["confirmed_unread"]) def test_no_global_unread_does_not_scroll_the_list(self): bot = WeChatBot.__new__(WeChatBot) page = np.zeros((40, 40, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=page) bot._target_from_session_image = mock.Mock(return_value=None) bot._deep_unread_scan_allowed = mock.Mock(return_value=False) bot._scroll_session_list_top = mock.Mock() self.assertIsNone(bot._find_next_unread_session(set(), set(), full=page)) bot._scroll_session_list_top.assert_not_called() def test_click_relocates_unread_by_fingerprint_before_acting(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) latest = np.zeros((500, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot.detect_badge_rows = mock.Mock(return_value=[300, 80]) bot._session_fingerprint = mock.Mock( side_effect=lambda _img, y: b"target" if y == 80 else b"other" ) bot._chat_identity_signature = mock.Mock(side_effect=[b"before", b"after"]) bot._selected_session_fingerprint = mock.Mock(return_value=b"target") bot._remember_active_surface = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._escape_proven_blocker = mock.Mock(return_value=False) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot.click_session(300, expected_fp=b"target")) # badge y=80 + 16*2 的头像中心，再加列表 top=200。 click.assert_called_once_with(600, 312) def test_click_two_nav_misses_accepts_raw_target_with_chat_evidence(self): bot = WeChatBot.__new__(WeChatBot) target = b"t" * 40 message_page = self._nav_surface(True) other_page = self._nav_surface(False) bot.scale = 1.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock( side_effect=[message_page, other_page, other_page] ) latest = np.zeros((200, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot.detect_badge_rows = mock.Mock(return_value=[32]) bot._session_fingerprint = mock.Mock(return_value=target) bot._chat_identity_signature = mock.Mock( side_effect=[b"same-title", b"same-title"] ) bot._chat_surface_signature = mock.Mock(return_value=b"chat-ready") bot._active_session_fp = None bot._raw_selected_session_fingerprint = mock.Mock(return_value=target) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._pending_reply_state = mock.Mock(return_value=None) bot._flat_visual_proof_fps = {target.hex()} bot._flat_verified_session_fps = set() # Reproduce an earlier false rejection from the same listener process. # Strong raw-row/title/chat evidence must heal it immediately. bot._flat_rejected_session_fps = {target.hex()} bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot.click_session(32, expected_fp=target)) self.assertEqual(bot._last_click_failure_reason, "") self.assertNotIn(target.hex(), bot._flat_rejected_session_fps) self.assertIn(target.hex(), bot._flat_verified_session_fps) self.assertNotIn(target.hex(), bot._flat_visual_proof_fps) bot._raw_selected_session_fingerprint.assert_called_once_with() bot._selected_session_fingerprint.assert_not_called() bot._chat_surface_signature.assert_called_once_with() bot._remember_active_surface.assert_called_once_with(target) def test_click_two_nav_misses_without_raw_selected_row_proves_page_exit(self): bot = WeChatBot.__new__(WeChatBot) target = b"target" message_page = self._nav_surface(True) other_page = self._nav_surface(False) bot.scale = 1.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock( side_effect=[message_page, other_page, other_page] ) latest = np.zeros((200, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot.detect_badge_rows = mock.Mock(return_value=[32]) bot._session_fingerprint = mock.Mock(return_value=target) bot._chat_identity_signature = mock.Mock(return_value=b"before") bot._active_session_fp = None bot._raw_selected_session_fingerprint = mock.Mock(return_value=None) bot._selected_session_fingerprint = mock.Mock(return_value=target) bot._chat_surface_signature = mock.Mock(return_value=b"chat-ready") bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): self.assertFalse(bot.click_session(32, expected_fp=target)) self.assertEqual(bot._last_click_failure_reason, "left_message_workspace") self.assertEqual(bot._capture_full_window.call_count, 3) bot._raw_selected_session_fingerprint.assert_called_once_with() bot._selected_session_fingerprint.assert_not_called() bot._chat_surface_signature.assert_not_called() bot._remember_active_surface.assert_not_called() def test_click_ignores_one_transient_post_click_navigation_frame(self): bot = WeChatBot.__new__(WeChatBot) target = b"target" message_page = self._nav_surface(True) transient_page = self._nav_surface(False) bot.scale = 1.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock( side_effect=[message_page, transient_page, message_page] ) latest = np.zeros((200, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot.detect_badge_rows = mock.Mock(return_value=[32]) bot._session_fingerprint = mock.Mock(return_value=target) bot._chat_identity_signature = mock.Mock( side_effect=[b"before", b"after"] ) bot._active_session_fp = None bot._selected_session_fingerprint = mock.Mock(return_value=target) bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): self.assertTrue(bot.click_session(32, expected_fp=target)) self.assertEqual(bot._last_click_failure_reason, "") self.assertEqual(bot._capture_full_window.call_count, 3) bot._remember_active_surface.assert_called_once_with(target) def test_click_can_reopen_flat_avatar_pending_for_visual_confirmation(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot._session_geometry_valid = True bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) latest = np.zeros((500, 460, 4), dtype=np.uint8) expected = b"f" * 40 bot.capture_session_list = mock.Mock(return_value=latest) bot._session_fingerprint = mock.Mock(return_value=expected) bot._pending_reply_sessions = { expected.hex(): {"requires_visual_proof": True} } bot.store = mock.Mock() bot.store.has_record.return_value = False bot._is_real_conversation = mock.Mock( side_effect=lambda *_args, **kwargs: bool(kwargs.get("allow_flat")) ) bot._chat_identity_signature = mock.Mock( side_effect=[b"before-title", b"after-title"] ) bot._active_session_fp = None bot._selected_session_fingerprint = mock.Mock(return_value=expected) bot._remember_active_surface = mock.Mock() bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click") as click, mock.patch("wechat_bot.time.sleep"), ): self.assertTrue( bot.click_session(64, expected_fp=expected, row_center=True) ) self.assertTrue( bot._is_real_conversation.call_args.kwargs["allow_flat"] ) click.assert_called_once_with(600, 264) def test_click_fails_closed_when_selected_fingerprint_cannot_be_read(self): bot = WeChatBot.__new__(WeChatBot) bot.scale = 2.0 bot.hwnd = 100 bot.list_region = {"top": 200} bot.list_click_x = 600 bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) latest = np.zeros((500, 180, 4), dtype=np.uint8) bot.capture_session_list = mock.Mock(return_value=latest) bot.detect_badge_rows = mock.Mock(return_value=[80]) bot._session_fingerprint = mock.Mock(return_value=b"target") bot._is_real_conversation = mock.Mock(return_value=True) bot._chat_identity_signature = mock.Mock(side_effect=[b"before", b"after"]) bot._selected_session_fingerprint = mock.Mock(return_value=None) bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot._run_ai_page_guard = mock.Mock(return_value=False) bot._escape_proven_blocker = mock.Mock(return_value=False) bot._begin_bot_mouse = mock.Mock() bot._end_bot_mouse = mock.Mock() with ( mock.patch("wechat_bot.pyautogui.click"), mock.patch("wechat_bot.time.sleep"), ): self.assertFalse(bot.click_session(80, expected_fp=b"target")) def test_generate_reply_passes_archive_history_and_stages_whole_batch(self): bot = WeChatBot.__new__(WeChatBot) fp = b"12345678" history = [ {"role": "user", "content": "上次的问题"}, {"role": "assistant", "content": "上次的回复"}, ] batch = ( "客户甲 7/29 10:00:01\n第一段\n" "客户甲 7/29 10:00:08\n第二段\n" "客户甲 7/29 10:00:18\n第三段" ) bot.get_session_history = mock.Mock(return_value=history) bot.extract_context_for = mock.Mock(return_value=batch) bot._stage_exchange = mock.Mock() bot._run_ai_page_guard = mock.Mock(return_value=False) with ( mock.patch("ai_config.AI_ENABLED", True), mock.patch("ai_config.AI_USE_VISION", False), mock.patch("ai_config.AI_CONTEXT_ENABLED", True), mock.patch("ai_chat.call_ai_text", return_value="统一回复") as call_ai, mock.patch( "registration_store.process_registration_reply", return_value=("统一回复", None), ), mock.patch("wechat_bot.time.sleep"), ): self.assertEqual(bot._generate_ai_reply(fp), "统一回复") call_ai.assert_called_once_with(batch, history=history) staged_user_text = bot._stage_exchange.call_args.args[1] self.assertEqual(staged_user_text, "第一段\n第二段\n第三段") # ── 一个卡住的待回复任务不能饿死其它会话 ───────────────────────────────── # `_poll_once` 见到 `_resume_orphaned_pending_reply()` 返回 True 就整轮 return。 # 只要「没做成任何事」也返回 True，一个永远认不回来的任务就会把未读扫描永久 # 挡掉，表现就是「回复几次之后再也不回了」。 def _resume_bot(self, **state_fields): """搭一个只有一个已读未回复任务的机器人，恢复链路全部打桩。""" bot = WeChatBot.__new__(WeChatBot) fp = b"r" * 40 state = {"confirmed_unread": True, "identity_signature": b"title"} state.update(state_fields) bot._pending_reply_sessions = {fp.hex(): state} bot._pending_reply_path = "" bot._pending_scan_progress = {} bot._pending_scan_incomplete = False bot._live_session_fp_aliases = set() bot._active_session_fp = None bot._active_identity_signature = None bot._chat_identity_signature = mock.Mock(return_value=b"title") bot._persist_pending_replies = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._find_pending_session = mock.Mock(return_value=None) bot.click_session = mock.Mock(return_value=True) bot._chat_target_matches = mock.Mock(return_value=True) bot._accept_selected_title_render = mock.Mock(return_value=True) bot._reconcile_uncertain_send = mock.Mock(return_value="unsent") bot._mark_reply_pending = mock.Mock(return_value=True) bot._wait_for_message_batch = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="回复") bot._activate_wx = mock.Mock(return_value=True) bot.send_reply = mock.Mock(return_value=True) bot._pending_reply_state = ( lambda key: bot._pending_reply_sessions.get(bytes(key).hex()) ) return bot, fp, state def test_unlocatable_pending_task_leaves_the_round_free_for_new_unread(self): """扫描完整个列表也认不回来时，绝不能吃掉本轮的未读处理。""" bot, _fp, state = self._resume_bot() self.assertFalse(bot._resume_orphaned_pending_reply()) self.assertEqual(state["resume_failures"], 1) def test_an_unfinished_scan_keeps_its_progress_without_blocking_unread(self): """翻页扫描没走完要保留进度，但同样不能挡住未读扫描。""" bot, _fp, state = self._resume_bot() def scan(_target): bot._pending_scan_incomplete = True return None bot._find_pending_session = mock.Mock(side_effect=scan) self.assertFalse(bot._resume_orphaned_pending_reply()) # 分页扫描本身是在推进，不该被记成失败而提前退避。 self.assertNotIn("resume_failures", state) def test_failed_reopen_does_not_consume_the_polling_round(self): bot, _fp, state = self._resume_bot() bot._find_pending_session = mock.Mock( return_value=(np.zeros((8, 8, 4), np.uint8), 40) ) bot.click_session = mock.Mock(return_value=False) self.assertFalse(bot._resume_orphaned_pending_reply()) self.assertEqual(state["resume_failures"], 1) def test_repeated_resume_failures_back_off_instead_of_retrying_every_round(self): bot, _fp, _state = self._resume_bot() base = wechat_bot.SESSION_SCAN_COOLDOWN_SECONDS self.assertEqual(bot._resume_cooldown_seconds({}), base) self.assertEqual(bot._resume_cooldown_seconds({"resume_failures": 1}), base * 2) self.assertEqual(bot._resume_cooldown_seconds({"resume_failures": 3}), base * 8) # 退避有上限，任务不会被无限期搁置。 self.assertEqual( bot._resume_cooldown_seconds({"resume_failures": 99}), bot._RESUME_BACKOFF_MAX_SECONDS, ) def test_a_successful_resume_clears_the_backoff(self): bot, fp, state = self._resume_bot(resume_failures=4) bot._find_pending_session = mock.Mock( return_value=(np.zeros((8, 8, 4), np.uint8), 40) ) with mock.patch("wechat_bot.time.sleep"): self.assertTrue(bot._resume_orphaned_pending_reply()) bot.send_reply.assert_called_once_with( "回复", session_id=fp.hex(), expected_fp=fp, ) self.assertNotIn("resume_failures", state) def test_stuck_pending_task_no_longer_starves_the_unread_scan(self): """端到端：卡住的任务存在时，本轮仍然必须去扫描新的未读会话。""" bot, _fp, _state = self._resume_bot() message_page = self._nav_surface(True) bot.scale = 1.0 bot.false_pos_rows = set() bot.safe_window_mode = True bot._did_initial_cleanup = True bot.wait_for_mouse_idle = mock.Mock(return_value=True) bot._dismiss_owned_blocking_window = mock.Mock(return_value=False) bot._ensure_visible = mock.Mock(return_value=True) bot._security_gate_visible = mock.Mock(return_value=False) bot._capture_full_window = mock.Mock(return_value=message_page) bot._refresh_message_geometry = mock.Mock() bot._dismiss_internal_blocker = mock.Mock(return_value=False) bot.capture_session_list = mock.Mock( return_value=np.zeros((64, 80, 4), dtype=np.uint8) ) bot._check_selected_session = mock.Mock(return_value=False) bot._find_next_unread_session = mock.Mock(return_value=None) # 真正会卡死的形态：列表很长，翻页扫描一轮走不完，于是每一轮都重扫。 def scan(_target): bot._pending_scan_incomplete = True return None bot._find_pending_session = mock.Mock(side_effect=scan) bot._poll_once() bot._find_next_unread_session.assert_called_once() # ── 每个会话的第一条消息必须回复 ───────────────────────────────────────── # 判断“是否还在跟同一个会话”一旦用裸 `!=`，同一个联系人只要头像哈希漂几位 # （或只是未读粗体换成选中常规体），就会被当成刚切过来的新会话，本轮到达的 # 消息被并进基线吞掉，客户要再发一条才会得到回复。 _NAME_FP = b"n" * 32 # 实测同一联系人漂移：78781818… → 78700818…（相差 2 位，容差 6 位） _AVATAR_FP = bytes([0x78, 0x78, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00]) _AVATAR_FP_DRIFTED = bytes([0x78, 0x70, 0x08, 0x18, 0x00, 0x00, 0x00, 0x00]) def _selected_session_bot(self, current_fp, tracked_fp, *, customer_waiting): """搭一个“当前会话画面已变化”的机器人，回复链路全部打桩。""" bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_sessions = {} bot._pending_reply_path = "" bot._live_session_fp_aliases = set() bot._capture_full_window = mock.Mock(return_value=self._nav_surface(True)) bot._message_nav_selected = mock.Mock(return_value=True) bot.detect_selected_row = mock.Mock(return_value=24) bot._session_fingerprint = mock.Mock(return_value=current_fp) bot._flat_row_requires_visual_proof = mock.Mock(return_value=False) bot._is_tool_selected = mock.Mock(return_value=False) bot._raw_selected_session_fingerprint = mock.Mock(return_value=current_fp) bot._selected_session_fingerprint = mock.Mock(return_value=current_fp) bot._chat_identity_signature = mock.Mock(return_value=b"title") bot._chat_surface_signature = mock.Mock(return_value=b"new-surface") bot._ensure_session_archive_key = mock.Mock() bot._persist_pending_replies = mock.Mock(return_value=True) bot._reconcile_uncertain_send = mock.Mock(return_value="unsent") bot._selected_tracking_initialized = tracked_fp is not None bot._active_session_fp = tracked_fp bot._active_identity_signature = b"title" bot._active_chat_signature = b"old-surface" bot._activate_wx = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock( return_value="客户甲 10:00:00\n第一条消息" ) bot._has_pending_customer_message = mock.Mock(return_value=customer_waiting) bot._wait_for_message_batch = mock.Mock(return_value=True) bot._send_gate_open = mock.Mock(return_value=True) bot._generate_ai_reply = mock.Mock(return_value="这是回复") bot.send_reply = mock.Mock(return_value=True) states = {} bot._pending_reply_state = lambda key: states.get(bytes(key)) def mark(target, **kwargs): states.setdefault(bytes(target), {}).update(kwargs) return True bot._mark_reply_pending = mock.Mock(side_effect=mark) return bot def test_avatar_hash_drift_no_longer_swallows_the_first_new_message(self): """头像哈希漂 2 位仍是同一个人，第一条消息就必须回复。""" current = self._AVATAR_FP_DRIFTED + self._NAME_FP tracked = self._AVATAR_FP + self._NAME_FP # 文字判定故意给 False：跟踪中的会话只要画面变化就应进入回复链路， # 不该退回“建基线”把消息吞掉。 bot = self._selected_session_bot(current, tracked, customer_waiting=False) with mock.patch("wechat_bot.time.sleep"): self.assertTrue(bot._check_selected_session(np.zeros((80, 80, 4), np.uint8))) bot._generate_ai_reply.assert_called_once() bot.send_reply.assert_called_once_with( "这是回复", session_id=current.hex(), expected_fp=current, ) def test_proven_render_alias_no_longer_swallows_the_first_new_message(self): """未读粗体与选中常规体已被证明是同一人，同样不能吞掉第一条消息。""" current = bytes([0x11] * 8) + self._NAME_FP tracked = bytes([0xEE] * 8) + self._NAME_FP bot = self._selected_session_bot(current, tracked, customer_waiting=False) bot._live_session_fp_aliases = { tuple(sorted((current.hex(), tracked.hex()))) } with mock.patch("wechat_bot.time.sleep"): self.assertTrue(bot._check_selected_session(np.zeros((80, 80, 4), np.uint8))) bot._generate_ai_reply.assert_called_once() def test_a_different_contact_still_only_establishes_a_baseline(self): """名称哈希不同就是另一个人，必须停在建基线，绝不能串聊天。""" current = self._AVATAR_FP + b"n" * 32 tracked = self._AVATAR_FP + b"m" * 32 bot = self._selected_session_bot(current, tracked, customer_waiting=False) bot.store = mock.Mock() bot.store.has_record = mock.Mock(return_value=False) with mock.patch("wechat_bot.time.sleep"): self.assertFalse(bot._check_selected_session(np.zeros((80, 80, 4), np.uint8))) bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() self.assertEqual(bot._active_session_fp, current) def test_session_without_an_archive_recovers_its_first_unanswered_message(self): """还没建档的会话，第一条没人回过的客户消息不能被基线吞掉。""" current = self._AVATAR_FP + self._NAME_FP bot = self._selected_session_bot(current, None, customer_waiting=True) bot.store = mock.Mock() bot.store.has_record = mock.Mock(return_value=False) bot.store.last_lines = mock.Mock( side_effect=AssertionError("无档案时不得调用 last_lines，会建出空档案") ) with mock.patch("wechat_bot.time.sleep"): self.assertTrue(bot._check_selected_session(np.zeros((80, 80, 4), np.uint8))) bot._generate_ai_reply.assert_called_once() bot.send_reply.assert_called_once() def test_session_without_an_archive_baselines_when_the_agent_spoke_last(self): """屏幕上最后一条是我方发的，说明没人在等回复，仍然只建基线。""" current = self._AVATAR_FP + self._NAME_FP bot = self._selected_session_bot(current, None, customer_waiting=False) bot.store = mock.Mock() bot.store.has_record = mock.Mock(return_value=False) with mock.patch("wechat_bot.time.sleep"): self.assertFalse(bot._check_selected_session(np.zeros((80, 80, 4), np.uint8))) bot._generate_ai_reply.assert_not_called() bot.send_reply.assert_not_called() # ── 挂载哪个窗口 ───────────────────────────────────────────────────────── # 企业微信是多进程架构，子进程会创建 ClassName 和标题都一样的顶层窗口， # 它平时隐藏、且完全不渲染内容。挂到它上面会既读不到界面，又被 _ensure_visible # 强行显示成一整块黑屏。 @staticmethod def _black_window(width: int, height: int) -> np.ndarray: return np.zeros((height, width, 4), dtype=np.uint8) @staticmethod def _rendered_window(width: int, height: int) -> np.ndarray: """深色主题主界面：整体偏暗，但有大量明暗结构。""" img = np.full((height, width, 4), 45, dtype=np.uint8) img[:, ::7] = 210 img[::5, :] = 120 return img def _patched_windows(self, windows, capture): """windows: [(hwnd, rect, visible, 进程启动时间)]，按 Z 序排列。""" rects = {hwnd: rect for hwnd, rect, _v, _s in windows} visibles = {hwnd: vis for hwnd, _r, vis, _s in windows} starts = {hwnd: start for hwnd, _r, _v, start in windows} def enum_windows(callback, extra): for hwnd, _rect, _vis, _start in windows: callback(hwnd, extra) return True patchers = ( mock.patch("wechat_bot.win32gui.EnumWindows", side_effect=enum_windows), mock.patch("wechat_bot.win32gui.GetClassName", return_value="WeWorkWindow"), mock.patch( "wechat_bot.win32gui.GetWindowRect", side_effect=lambda hwnd: rects[hwnd], ), mock.patch( "wechat_bot.win32gui.IsWindowVisible", side_effect=lambda hwnd: visibles[hwnd], ), mock.patch( "wechat_bot._window_process_start_time", side_effect=lambda hwnd: starts[hwnd], ), mock.patch("wechat_bot.capture_window_region", side_effect=capture), ) with ExitStack() as stack: for patcher in patchers: stack.enter_context(patcher) return stack.pop_all() def test_blank_child_window_never_wins_over_the_rendered_main_window(self): shell, main_window = 0x00480B1A, 0x000308E0 windows = [ # 空壳窗口排在 Z 序最前，FindWindow 会先返回它。 (shell, (0, 0, 2000, 1300), True, 1000.0), (main_window, (342, 428, 2598, 1746), True, 900.0), ] def capture(hwnd, _x, _y, width, height): if hwnd == shell: return self._black_window(width, height) return self._rendered_window(width, height) with self._patched_windows(windows, capture) as _patches: self.assertEqual(find_wx_hwnd(), main_window) def test_lone_hidden_window_is_kept_without_probing_pixels(self): """主面板收进托盘时只有一个候选，必须原样返回，不能因为“截图是黑的”被否掉。""" tray = 0x000308E0 windows = [(tray, (342, 428, 2598, 1746), False, 900.0)] capture = mock.Mock(side_effect=AssertionError("单个候选不应触发截图探测")) with self._patched_windows(windows, capture) as _patches: self.assertEqual(find_wx_hwnd(), tray) capture.assert_not_called() def test_all_blank_candidates_prefer_the_visible_earlier_process(self): """两个窗口都没渲染时（主面板也在托盘里），可见且进程更早的才是主界面。""" shell, main_window = 0x00480B1A, 0x000308E0 windows = [ (shell, (0, 0, 2000, 1300), False, 1000.0), (main_window, (342, 428, 2598, 1746), True, 900.0), ] def capture(_hwnd, _x, _y, width, height): return self._black_window(width, height) with self._patched_windows(windows, capture) as _patches: self.assertEqual(find_wx_hwnd(), main_window) def test_render_probe_separates_dark_theme_from_an_empty_shell(self): rect = (342, 428, 2598, 1746) width, height = rect[2] - rect[0], rect[3] - rect[1] with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=rect), mock.patch( "wechat_bot.capture_window_region", return_value=self._rendered_window(width, height), ), ): self.assertTrue(window_looks_rendered(0x1)) with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=rect), mock.patch( "wechat_bot.capture_window_region", return_value=self._black_window(width, height), ), ): self.assertFalse(window_looks_rendered(0x1)) # 纯色填充同样不是主界面（没有任何界面结构）。 with ( mock.patch("wechat_bot.win32gui.GetWindowRect", return_value=rect), mock.patch( "wechat_bot.capture_window_region", return_value=np.full((height, width, 4), 200, dtype=np.uint8), ), ): self.assertFalse(window_looks_rendered(0x1)) def test_render_probe_survives_a_window_that_dies_mid_capture(self): with ( mock.patch( "wechat_bot.win32gui.GetWindowRect", return_value=(342, 428, 2598, 1746), ), mock.patch( "wechat_bot.capture_window_region", side_effect=RuntimeError("窗口尺寸异常"), ), ): self.assertFalse(window_looks_rendered(0x1)) class NothingLeftToAnswerTextProofTest(TestCase): """气泡方向看错边时，复制文字必须能把客户的新消息救回来（2026-07-31 复盘）。 现场时间线：客户刚收到我方一条长回复、马上又追了一句很短的话；底部取样把 两个气泡圈在一起，长回复的墨量让整段被判成「右侧收尾」，任务被清掉、红点 又已被点掉，客户从此收不到回复。 """ CUSTOMER_TAIL = ( "高兴亮 7/31 17:12:11\n" "在这儿呢，刚看到你的消息，有什么事你说\n" "高瑞@微信@微信联系人 7/31 17:19:30\n" "哈哈哈" ) AGENT_TAIL = ( "高瑞@微信@微信联系人 7/31 17:11:49\n" "你在干嘛\n" "高兴亮 7/31 17:12:11\n" "在这儿呢，刚看到你的消息，有什么事你说" ) def _bot(self, fp, state, extracted_text): bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_sessions = {fp.hex(): state} bot._known_outgoing_speakers = mock.Mock(return_value={"高兴亮"}) bot._last_visible_bubble_is_outgoing = mock.Mock(return_value=True) bot.extract_chat_text = mock.Mock(return_value=extracted_text) bot._commit_staged_exchange = mock.Mock() bot._reset_pending_batch = mock.Mock() bot._persist_pending_replies = mock.Mock(return_value=True) bot._clear_reply_pending = mock.Mock() bot._remember_active_surface = mock.Mock() bot._log_queue_event = mock.Mock() return bot def test_customer_tail_overrides_the_outgoing_bubble_and_keeps_the_task(self): fp = b"g" * 40 state = {"confirmed_unread": True} bot = self._bot(fp, state, self.CUSTOMER_TAIL) with redirect_stdout(io.StringIO()): self.assertFalse(bot._nothing_left_to_answer(fp)) # 没传文字时必须自己取证，而不是只信像素 bot.extract_chat_text.assert_called_once_with(screens=1) bot._clear_reply_pending.assert_not_called() def test_explicit_chat_text_skips_the_extra_extraction(self): fp = b"g" * 40 bot = self._bot(fp, {"confirmed_unread": True}, "") with redirect_stdout(io.StringIO()): self.assertFalse(bot._nothing_left_to_answer(fp, self.CUSTOMER_TAIL)) bot.extract_chat_text.assert_not_called() bot._clear_reply_pending.assert_not_called() def test_agent_tail_still_settles_and_clears_the_task(self): fp = b"g" * 40 bot = self._bot(fp, {"confirmed_unread": True}, self.AGENT_TAIL) with redirect_stdout(io.StringIO()): self.assertTrue(bot._nothing_left_to_answer(fp)) bot._clear_reply_pending.assert_called_once_with(fp) def test_delivered_reply_is_archived_before_answering_the_followup(self): fp = b"g" * 40 state = { "confirmed_unread": False, "staged_reply_text": "在这儿呢，刚看到你的消息，有什么事你说", } bot = self._bot(fp, state, self.CUSTOMER_TAIL) with redirect_stdout(io.StringIO()): self.assertFalse(bot._nothing_left_to_answer(fp)) # 我方那句已经在屏幕上：先落档，再把任务转回「客户又有新消息」 bot._commit_staged_exchange.assert_called_once_with(fp.hex()) bot._reset_pending_batch.assert_called_once_with(fp) self.assertTrue(state.get("confirmed_unread")) bot._clear_reply_pending.assert_not_called() class PendingDisplayNameBindingTest(TestCase): """点击前标题还停在上一个会话时，任务不得错绑上一个客户的名字。""" def test_display_name_waits_until_the_title_matches_the_target(self): bot = WeChatBot.__new__(WeChatBot) bot._pending_reply_sessions = {} bot.identity_by_name = True bot._persist_pending_replies = mock.Mock(return_value=True) bot._log_queue_event = mock.Mock() bot._chat_identity_signature = mock.Mock(return_value=b"") fp = WeChatBot._fp_from_name("一个小迷糊@微信") # 面板还停在上一个会话「高瑞@微信」时入队：名字对不上号，不绑 bot._session_label = mock.Mock(return_value="高瑞@微信") bot._mark_reply_pending(fp, confirmed_unread=True, bind_identity=False) state = bot._pending_reply_sessions[fp.hex()] self.assertNotIn("display_name", state) # 面板切换完成后，下一次调用补绑正确的名字 bot._session_label = mock.Mock(return_value="一个小迷糊@微信") bot._mark_reply_pending(fp, batch_ready=True) self.assertEqual(state.get("display_name"), "一个小迷糊@微信") class ManualPendingCancellationTest(TestCase): def _bot(self, state): bot = WeChatBot.__new__(WeChatBot) fp = b"c" * 40 key = fp.hex() bot._pending_lock = threading.RLock() bot._pending_reply_sessions = {key: state} bot._pending_scan_progress = {key: {"page": 1}} bot._pending_exchanges = {key: ("问题", "回复")} bot._cancelled_reply_sessions = set() bot._persist_pending_replies_unlocked = mock.Mock(return_value=True) bot._queue_log_instance = mock.Mock() bot._active_session_fp = fp bot._active_hold_key = key bot._active_hold_since = 1.0 bot._active_hold_expired = True bot._uncertain_send_last_check = {} bot._uncertain_send_last_log = {} bot._uncertain_send_last_surface = {} return bot, fp, key def test_live_manual_delete_removes_state_and_blocks_inflight_recreation(self): bot, fp, key = self._bot({ "display_name": "一个小迷糊@微信", "generation_surface_signature": b"surface", }) result = bot.cancel_pending_replies([key]) self.assertEqual(result["deleted"], [key]) self.assertNotIn(key, bot._pending_reply_sessions) self.assertNotIn(key, bot._pending_exchanges) self.assertTrue(bot._reply_task_cancelled(fp)) self.assertFalse(bot._mark_reply_pending(fp, batch_ready=True)) self.assertEqual(bot._active_chat_signature, b"surface") def test_manual_delete_protects_task_after_send_dispatch_reservation(self): bot, _fp, key = self._bot({ "display_name": "甲", "send_state": "sending", "send_dispatched_at": time.time(), }) result = bot.cancel_pending_replies([key]) self.assertEqual(result["protected"], [key]) self.assertIn(key, bot._pending_reply_sessions) self.assertFalse(bot._cancelled_reply_sessions) def test_cancelled_inflight_task_is_rejected_before_any_send_action(self): bot, fp, key = self._bot({"display_name": "甲"}) bot._cancelled_reply_sessions.add(key) self.assertFalse(bot.send_reply("不会发送", expected_fp=fp)) self.assertEqual(bot.last_send_failure_reason(), "任务已被手动删除") def setUpModule(): queue_log_redirect.start() def tearDownModule(): queue_log_redirect.stop() if __name__ == "__main__": main()