合并 main 的合并前复核修复到镜牢选队分支

Browse Source
分支从 8a9495b 分出,缺 main 上 a74fda0 的急停与驱动复核修复。
两边都保留,不取单边:

- 急停:沿用分支的 GetAsyncKeyState 轮询与 End 键(pynput 钩子在该
  机器收不到键,F12 是 Steam 截图键);移植 main 的 on_stop 释放驱动
  按住的鼠标键、250 毫秒强退兜底、listening() 管理监听生命周期。
  按键状态改为独立绑定(SHORT 返回值),接口不可用时启动即报告。
- 驱动输入:同时保留句柄级前台校验、press_ms/settle 与 main 的
  停止标志、输入锁和按键记录;点击经 down()/up() 以便急停释放。
  前台校验改用本模块的类型化 _api 绑定。
- 代理每次点击按当前句柄重新 bind_window:代理复用时不再拿安装时
  的旧句柄拒绝游戏重启后的全部点击。
- aalc_task:listening() 包住整个任务,内部安装两个选队补丁。
- 分支新增测试改为替换模块接口,不再直接 patch ctypes.windll
  (Linux 上 9 项报错);README 急停键改为 End。

验证:Linux / Python 3.12 全套 474 项通过;git diff --check 通过。
Windows 热键、驱动和选队仍需实机回归。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yws
2026-11-14 03:19:53 +00:00
co-authored by Claude Opus 5.5
14 changed files with 490 additions and 182 deletions
+29
View File
@@ -164,6 +164,35 @@ class RunAalcTest(unittest.TestCase):
self.assertIn('preflight', info) self.assertIn('preflight', info)
self.assertEqual(self.tools(mcp), ['run_task']) self.assertEqual(self.tools(mcp), ['run_task'])
def test_user_stop_never_retries(self):
for status in ({'state': 'stopped', 'exit_code': 130},
{'state': 'stopped'}, {'state': 'failed', 'exit_code': 130}):
mcp = FakeMcp([status], [DONE])
with self.subTest(status=status), self.assertRaises(auto_cycle.UserAborted):
self.run_aalc(mcp)
self.assertEqual(self.tools(mcp), ['run_task'])
def test_mirror_emergency_stop_ends_cycle_before_upgrade_or_navigation(self):
mcp = FakeMcp([DONE], [{'state': 'stopped', 'exit_code': 130}])
poll = auto_cycle.poll_task
with tempfile.TemporaryDirectory() as tmp:
with mock.patch.object(auto_cycle, 'probe', mcp.probe), \
mock.patch.object(auto_cycle, 'poll_task',
side_effect=lambda t, s, **kw: poll(t, s, sleep=lambda _: None)), \
mock.patch.object(auto_cycle, 'lunacy_guard', return_value=(True, 'ok')), \
mock.patch.object(auto_cycle, 'ensure_team1', return_value=True), \
mock.patch.object(auto_cycle, 'goto_identities') as navigate, \
mock.patch.object(auto_cycle, 'run') as upgrade, \
mock.patch('builtins.print'):
code = auto_cycle.main(['--mirror', '1', '--report-dir', tmp])
report = json.loads(next(Path(tmp).glob('cycle_*.json')).read_text(encoding='utf-8'))
self.assertEqual(code, 130)
self.assertFalse(report['ok'])
self.assertIn('用户停止', report['result'])
navigate.assert_not_called()
upgrade.assert_not_called()
self.assertEqual(self.tools(mcp), ['run_task', 'run_task'])
def test_exit_zero_with_errors_is_failure(self): def test_exit_zero_with_errors_is_failure(self):
mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])]) mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])])
ok, info = self.run_aalc(mcp) ok, info = self.run_aalc(mcp)
+71 -39
View File
@@ -301,8 +301,8 @@ class DriverWiringTest(unittest.TestCase):
def test_actual_task_entry_enables_driver_for_all_and_daily(self): def test_actual_task_entry_enables_driver_for_all_and_daily(self):
from lc_mcp import aalc_task from lc_mcp import aalc_task
for task in ('all', 'daily'): for task, problems in [('all', []), ('daily', []), ('all', ['invalid config'])]:
with self.subTest(task=task): with self.subTest(task=task, problems=problems):
auto, handler_type = vendor_auto() auto, handler_type = vendor_auto()
auto.clear_img_cache = mock.Mock() auto.clear_img_cache = mock.Mock()
auto.click_element = mock.Mock(return_value=False) auto.click_element = mock.Mock(return_value=False)
@@ -329,14 +329,21 @@ class DriverWiringTest(unittest.TestCase):
mock.patch.object(aalc_task, 'install_exact_team_match'), \ mock.patch.object(aalc_task, 'install_exact_team_match'), \
mock.patch.object(aalc_task, 'install_robust_set_foreground'), \ mock.patch.object(aalc_task, 'install_robust_set_foreground'), \
mock.patch.object(aalc_task, 'WindowGuard'), \ mock.patch.object(aalc_task, 'WindowGuard'), \
mock.patch.object(aalc_task.killswitch, 'install') as install_hotkey, \
mock.patch.object(aalc_task, 'log'), \ mock.patch.object(aalc_task, 'log'), \
mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \ mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \
mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \ mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \
mock.patch.object(aalc_task.preflight, 'check', return_value=[]), \ mock.patch.object(aalc_task.preflight, 'check', return_value=problems), \
mock.patch.object(di, 'DriverInput', return_value=drv), \ mock.patch.object(di, 'DriverInput', return_value=drv), \
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)): mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
self.assertEqual(aalc_task.run(task, {}), 0) self.assertEqual(aalc_task.run(task, {}), 3 if problems else 0)
drv.click.assert_called_once_with(10, 20, times=1) install_hotkey.return_value.stop.assert_called_once()
if problems:
drv.click.assert_not_called()
else:
drv.click.assert_called_once_with(10, 20, times=1)
install_hotkey.call_args.kwargs['on_stop']()
drv.emergency_stop.assert_called_once()
def test_disabled_and_simulator_leave_initialization_unchanged(self): def test_disabled_and_simulator_leave_initialization_unchanged(self):
for enabled, simulator in [('0', False), ('1', True)]: for enabled, simulator in [('0', False), ('1', True)]:
@@ -350,6 +357,23 @@ class DriverWiringTest(unittest.TestCase):
class DriverFailureTest(unittest.TestCase): class DriverFailureTest(unittest.TestCase):
def test_emergency_stop_releases_press_and_blocks_subsequent_clicks(self):
drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(drv, 'move_to', return_value=True), \
mock.patch.object(di, 'click_point_is_on_foreground', lambda *a, **k: (True, 'ok')), \
mock.patch.object(di.time, 'sleep', side_effect=lambda _: drv.emergency_stop()):
# settle=0: 第一次 sleep 是按下后的按住时长, 急停发生在按住期间
self.assertFalse(drv.click(10, 20, times=3, settle=0))
drv._dll.mouse_down.assert_called_once_with(1)
drv._dll.mouse_up.assert_called_with(1)
self.assertFalse(drv.ready)
self.assertFalse(drv.click(30, 40))
self.assertFalse(drv.move_relative(20, 30))
self.assertFalse(drv.down())
drv._dll.moveR.assert_not_called()
self.assertEqual(drv._pressed, set())
def test_release_even_if_sleep_is_interrupted(self): def test_release_even_if_sleep_is_interrupted(self):
drv = di.DriverInput() drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock() drv._open, drv._dll = True, mock.Mock()
@@ -437,8 +461,18 @@ class ForegroundFallbackTest(unittest.TestCase):
[mock.call(33, 11, True), mock.call(33, 11, False)]) [mock.call(33, 11, True), mock.call(33, 11, False)])
if __name__ == '__main__':
unittest.main() def win_api(**functions):
"""按 API 名替换 driver_input._api 返回的函数。"""
return mock.patch.object(di, '_api', side_effect=lambda library, name, result, args: functions[name])
def window_rect(left, top, right, bottom):
def get_window_rect(hwnd, ptr):
r = ptr._obj
r.left, r.top, r.right, r.bottom = left, top, right, bottom
return 1
return get_window_rect
class ForegroundCheckTest(unittest.TestCase): class ForegroundCheckTest(unittest.TestCase):
@@ -455,37 +489,21 @@ class ForegroundCheckTest(unittest.TestCase):
return d return d
def test_rejects_when_no_foreground_window(self): def test_rejects_when_no_foreground_window(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow', with mock.patch.object(di, 'foreground_window', return_value=None):
return_value=0):
ok, why = di.click_point_is_on_foreground(100, 100) ok, why = di.click_point_is_on_foreground(100, 100)
self.assertFalse(ok) self.assertFalse(ok)
self.assertIn('前台窗口', why) self.assertIn('前台窗口', why)
def test_rejects_when_point_outside_foreground_window(self): def test_rejects_when_point_outside_foreground_window(self):
def fake_get_window_rect(hwnd, ptr): with mock.patch.object(di, 'foreground_window', return_value=12345), \
r = ptr._obj win_api(GetWindowRect=window_rect(0, 0, 50, 50)):
r.left, r.top, r.right, r.bottom = 0, 0, 50, 50
return 1
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=12345), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
fake_get_window_rect), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
ok, why = di.click_point_is_on_foreground(999, 999) ok, why = di.click_point_is_on_foreground(999, 999)
self.assertFalse(ok) self.assertFalse(ok)
self.assertIn('不在前台窗口内', why) self.assertIn('不在前台窗口内', why)
def test_accepts_when_point_inside_foreground_window(self): def test_accepts_when_point_inside_foreground_window(self):
def fake_get_window_rect(hwnd, ptr): with mock.patch.object(di, 'foreground_window', return_value=12345), \
r = ptr._obj win_api(GetWindowRect=window_rect(0, 0, 1920, 1080)):
r.left, r.top, r.right, r.bottom = 0, 0, 1920, 1080
return 1
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=12345), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
fake_get_window_rect):
ok, why = di.click_point_is_on_foreground(500, 500) ok, why = di.click_point_is_on_foreground(500, 500)
self.assertTrue(ok) self.assertTrue(ok)
self.assertEqual(why, 'ok') self.assertEqual(why, 'ok')
@@ -553,30 +571,29 @@ class HwndForegroundCheckTest(unittest.TestCase):
""" """
def test_accepts_when_foreground_is_the_target(self): def test_accepts_when_foreground_is_the_target(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow', with mock.patch.object(di, 'foreground_window', return_value=999):
return_value=999):
ok, why = di.click_point_is_on_foreground(100, 100, 999) ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertTrue(ok) self.assertTrue(ok)
self.assertEqual(why, 'ok') self.assertEqual(why, 'ok')
def test_accepts_child_window_of_target(self): def test_accepts_child_window_of_target(self):
"""游戏可能有子窗口拿到焦点, 也算在目标窗口上。""" """游戏可能有子窗口拿到焦点, 也算在目标窗口上。"""
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow', is_child = mock.Mock(return_value=True)
return_value=1000), \ with mock.patch.object(di, 'foreground_window', return_value=1000), \
mock.patch.object(di.ctypes.windll.user32, 'IsChild', win_api(IsChild=is_child):
return_value=True):
ok, _ = di.click_point_is_on_foreground(100, 100, 999) ok, _ = di.click_point_is_on_foreground(100, 100, 999)
is_child.assert_called_once_with(999, 1000)
self.assertTrue(ok) self.assertTrue(ok)
def test_rejects_when_foreground_is_another_window(self): def test_rejects_when_foreground_is_another_window(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow', titles = {1000: 'Browser', 999: 'LimbusCompany'}
return_value=1000), \ with mock.patch.object(di, 'foreground_window', return_value=1000), \
mock.patch.object(di.ctypes.windll.user32, 'IsChild', win_api(IsChild=mock.Mock(return_value=False)), \
return_value=False), \ mock.patch.object(di, 'window_title', side_effect=titles.get):
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
ok, why = di.click_point_is_on_foreground(100, 100, 999) ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertFalse(ok) self.assertFalse(ok)
self.assertIn('前台不是目标窗口', why) self.assertIn('前台不是目标窗口', why)
self.assertIn('Browser', why)
def test_bind_window_is_used_by_click(self): def test_bind_window_is_used_by_click(self):
"""绑定窗口后, click() 必须走句柄级校验。""" """绑定窗口后, click() 必须走句柄级校验。"""
@@ -597,3 +614,18 @@ class HwndForegroundCheckTest(unittest.TestCase):
self.assertFalse(d.click(10, 10)) self.assertFalse(d.click(10, 10))
self.assertEqual(seen['hwnd'], 4242, 'click 没把绑定的句柄传下去') self.assertEqual(seen['hwnd'], 4242, 'click 没把绑定的句柄传下去')
d._dll.mouse_down.assert_not_called() d._dll.mouse_down.assert_not_called()
def test_proxy_rebinds_current_window_before_each_click(self):
"""游戏重启后句柄会变; 代理复用时若仍拿安装时的旧句柄, 前台校验会拒绝所有点击。"""
drv = di.DriverInput(dll_path='X.dll', log=lambda m: None).bind_window(111)
handle = SimpleNamespace(hwnd=222, isMinimized=False, setForeground=mock.Mock())
proxy = ap.DriverClickProxy(mock.Mock(), drv, SimpleNamespace(handle=handle), log=lambda _: None)
with mock.patch.object(di, 'is_console_session', return_value=True), \
mock.patch.object(di, 'foreground_window', return_value=222), \
mock.patch.object(di, 'client_to_screen', return_value=(5, 6)):
self.assertEqual(proxy._screen_pos(1, 2), (5, 6))
self.assertEqual(drv.hwnd, 222)
if __name__ == '__main__':
unittest.main()
+145 -32
View File
@@ -9,9 +9,12 @@
实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但 实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但
keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。 keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质。 改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质,
以及急停时"先放开鼠标、卡住也按时退出"的保证。
""" """
import sys import sys
import tempfile
import threading
import unittest import unittest
from pathlib import Path from pathlib import Path
from unittest import mock from unittest import mock
@@ -19,10 +22,16 @@ from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1])) sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from lc_mcp import killswitch # noqa: E402 from lc_mcp import killswitch # noqa: E402
PRESSED = -32768 # SHORT 0x8000: GetAsyncKeyState 的"当前按下"位
def key_state(value):
return mock.patch.object(killswitch, '_key_state_api', return_value=lambda vk: value)
class ResolveVkTest(unittest.TestCase): class ResolveVkTest(unittest.TestCase):
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 —— """键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
否则用户以为设成了 F11, 实际还在监听 F12。""" 否则用户以为设成了 F11, 实际还在监听别的键。"""
def test_common_keys(self): def test_common_keys(self):
self.assertEqual(killswitch.resolve_vk('f12'), 0x7B) self.assertEqual(killswitch.resolve_vk('f12'), 0x7B)
@@ -30,6 +39,10 @@ class ResolveVkTest(unittest.TestCase):
self.assertEqual(killswitch.resolve_vk('esc'), 0x1B) self.assertEqual(killswitch.resolve_vk('esc'), 0x1B)
self.assertEqual(killswitch.resolve_vk('pause'), 0x13) self.assertEqual(killswitch.resolve_vk('pause'), 0x13)
def test_default_is_end_not_steam_screenshot_key(self):
self.assertEqual(killswitch.DEFAULT_KEY, 'end')
self.assertEqual(killswitch.resolve_vk(None), 0x23)
def test_accepts_angle_brackets(self): def test_accepts_angle_brackets(self):
self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B) self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B)
@@ -37,14 +50,15 @@ class ResolveVkTest(unittest.TestCase):
self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B) self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B)
def test_empty_uses_default(self): def test_empty_uses_default(self):
self.assertEqual(killswitch.resolve_vk(''), killswitch.VK[killswitch.DEFAULT_KEY]) for key in ('', None, ' '):
self.assertEqual(killswitch.resolve_vk(None), killswitch.VK[killswitch.DEFAULT_KEY]) self.assertEqual(killswitch.resolve_vk(key), killswitch.VK[killswitch.DEFAULT_KEY])
def test_unknown_returns_none(self): def test_unknown_returns_none(self):
self.assertIsNone(killswitch.resolve_vk('nosuchkey')) self.assertIsNone(killswitch.resolve_vk('nosuchkey'))
class InstallTest(unittest.TestCase): class InstallTest(unittest.TestCase):
"""装不上不能把任务带崩,但必须说清楚怎么应急。"""
def test_reports_unknown_key_and_suggests_fallback(self): def test_reports_unknown_key_and_suggests_fallback(self):
lines = [] lines = []
@@ -54,24 +68,35 @@ class InstallTest(unittest.TestCase):
self.assertIn('认不出键名', joined) self.assertIn('认不出键名', joined)
self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段') self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段')
def test_reports_when_keyboard_api_is_unavailable(self):
lines = []
with mock.patch.object(killswitch, '_key_state_api', side_effect=AttributeError('no user32')):
got = killswitch.install(log=lines.append)
self.assertIsNone(got)
joined = '\n'.join(lines)
self.assertIn('急停热键不可用', joined)
self.assertIn('Ctrl+Alt+Del', joined)
def test_installs_and_logs_the_key(self): def test_installs_and_logs_the_key(self):
lines = [] lines = []
with mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self): with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
switch = killswitch.install(log=lines.append, key='f11') switch = killswitch.install(log=lines.append, key='f11')
self.assertIsInstance(switch, killswitch.KillSwitch) self.assertIsInstance(switch, killswitch.KillSwitch)
self.assertEqual(switch.vk, 0x7A) self.assertEqual(switch.vk, 0x7A)
self.assertIn('F11', '\n'.join(lines)) joined = '\n'.join(lines)
self.assertIn('F11', joined)
self.assertIn('游戏窗口保留', joined)
def test_env_var_overrides_default(self): def test_env_var_overrides_default(self):
with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), \ with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), key_state(0), \
mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self): mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
switch = killswitch.install(log=lambda m: None) switch = killswitch.install(log=lambda m: None)
self.assertEqual(switch.vk, 0x1B) self.assertEqual(switch.vk, 0x1B)
def test_start_failure_is_reported_not_raised(self): def test_start_failure_is_reported_not_raised(self):
lines = [] lines = []
with mock.patch.object(killswitch.KillSwitch, 'start', with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start',
side_effect=RuntimeError('boom')): side_effect=RuntimeError('boom')):
got = killswitch.install(log=lines.append) got = killswitch.install(log=lines.append)
self.assertIsNone(got) self.assertIsNone(got)
self.assertIn('启动失败', '\n'.join(lines)) self.assertIn('启动失败', '\n'.join(lines))
@@ -81,60 +106,148 @@ class PollingTest(unittest.TestCase):
"""轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。""" """轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。"""
def test_high_bit_means_pressed(self): def test_high_bit_means_pressed(self):
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState', for value in (PRESSED, PRESSED | 1):
return_value=0x8000): with self.subTest(value=value), key_state(value):
self.assertTrue(killswitch._pressed(0x7B)) self.assertTrue(killswitch._pressed(0x7B))
def test_low_bits_are_not_pressed(self): def test_low_bits_are_not_pressed(self):
# 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下 # 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState', with key_state(0x0001):
return_value=0x0001):
self.assertFalse(killswitch._pressed(0x7B)) self.assertFalse(killswitch._pressed(0x7B))
def test_zero_is_not_pressed(self): def test_zero_is_not_pressed(self):
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState', with key_state(0):
return_value=0):
self.assertFalse(killswitch._pressed(0x7B)) self.assertFalse(killswitch._pressed(0x7B))
def test_poll_thread_fires_on_press(self):
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
exited = threading.Event()
with key_state(PRESSED), mock.patch.object(killswitch, 'START_DELAY', 0), \
mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
sw.start()
self.assertTrue(exited.wait(2))
sw._thread.join(2)
self.assertTrue(sw.fired)
def test_broken_api_stops_polling_with_a_message(self):
lines = []
sw = killswitch.KillSwitch(0x23, log=lines.append)
with mock.patch.object(killswitch, '_key_state_api', side_effect=OSError('gone')), \
mock.patch.object(killswitch, 'START_DELAY', 0), \
mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw.start()
sw._thread.join(2)
self.assertFalse(sw.is_alive())
fake_exit.assert_not_called()
self.assertIn('急停热键失效', '\n'.join(lines))
class FireTest(unittest.TestCase): class FireTest(unittest.TestCase):
def _switch(self): def _switch(self, log=lambda m: None, on_stop=None):
return killswitch.KillSwitch(0x7B, log=lambda m: None, key_name='f12') return killswitch.KillSwitch(0x23, log=log, key_name='end', on_stop=on_stop)
def test_exits_with_user_abort_code(self): def test_exits_with_user_abort_code_and_only_fires_once(self):
sw = self._switch() sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit: with mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw._fire() sw._fire()
sw._fire()
sw._fire()
fake_exit.assert_called_once_with(killswitch.EXIT_CODE) fake_exit.assert_called_once_with(killswitch.EXIT_CODE)
def test_only_fires_once(self):
sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw._fire()
sw._fire()
sw._fire()
self.assertEqual(fake_exit.call_count, 1, '重复触发不该重复退出')
def test_logs_that_game_is_kept(self): def test_logs_that_game_is_kept(self):
lines = [] lines = []
sw = killswitch.KillSwitch(0x7B, log=lines.append, key_name='f12')
with mock.patch.object(killswitch.os, '_exit'): with mock.patch.object(killswitch.os, '_exit'):
sw._fire() self._switch(log=lines.append)._fire()
joined = '\n'.join(lines) joined = '\n'.join(lines)
self.assertIn('F12', joined) self.assertIn('END', joined)
self.assertIn('重新开始', joined) self.assertIn('重新开始', joined)
def test_releases_input_before_logging_and_exiting(self):
calls = []
sw = self._switch(log=lambda m: calls.append('log'), on_stop=lambda: calls.append('release'))
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: calls.append(code)):
sw._fire()
self.assertEqual(calls, ['release', 'log', 130])
def test_broken_cleanup_or_log_cannot_disable_the_hotkey(self):
def cleanup():
raise OSError('driver disconnected')
log = mock.Mock(side_effect=OSError('closed log'))
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
self._switch(log=log, on_stop=cleanup)._fire()
fake_exit.assert_called_once_with(130)
def test_hung_cleanup_cannot_block_exit_deadline(self):
release, exited = threading.Event(), threading.Event()
sw = self._switch(on_stop=release.wait)
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
worker = threading.Thread(target=sw._fire, daemon=True)
worker.start()
try:
self.assertTrue(exited.wait(2), '清理卡住也必须触发强退')
finally:
release.set()
worker.join(2)
def test_real_emergency_exit_is_reported_as_stopped(self):
from lc_mcp.tasks import TaskRunner
child = """
import json, os, time
from lc_mcp import killswitch
from lc_mcp.aalc_task import RESTORE_ENV
with open(os.environ[RESTORE_ENV], 'w') as f: json.dump({'set_mirror_count': 1}, f)
killswitch._key_state_api = lambda: (lambda vk: -32768)
killswitch.install(log=lambda msg: None)
time.sleep(10)
"""
with tempfile.TemporaryDirectory() as tmp:
runner = TaskRunner(tmp, argv_factory=lambda t, p: [sys.executable, '-c', child])
self.assertTrue(runner.start('mirror', {'count': 2})['ok'])
self.addCleanup(runner.proc.kill)
runner.proc.wait(timeout=5)
status = runner.status()
self.assertEqual((status['state'], status['exit_code']), ('stopped', 130))
self.assertTrue(status['pending_restore'], '强退保留配置恢复文件, 下次启动前由服务处理')
class StopTest(unittest.TestCase): class StopTest(unittest.TestCase):
def test_stop_is_safe_on_none(self): def test_stop_is_safe_on_none(self):
killswitch.stop(None) killswitch.stop(None) # 不该抛
def test_stop_calls_switch(self):
sw = mock.Mock()
killswitch.stop(sw)
sw.stop.assert_called_once()
def test_stop_swallows_errors(self): def test_stop_swallows_errors(self):
sw = mock.Mock() sw = mock.Mock()
sw.stop.side_effect = RuntimeError('boom') sw.stop.side_effect = RuntimeError('boom')
killswitch.stop(sw) killswitch.stop(sw) # 不该抛
def test_stopped_switch_does_not_poll(self):
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
with key_state(PRESSED), mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw.stop()
sw.start()
sw._thread.join(2)
fake_exit.assert_not_called()
def test_listening_passes_cleanup_and_stops_on_return_and_exception(self):
cleanup = object()
for failure in (False, True):
switch = mock.Mock()
with self.subTest(failure=failure), \
mock.patch.object(killswitch, 'install', return_value=switch) as install:
try:
with killswitch.listening(on_stop=cleanup):
if failure:
raise RuntimeError('task failed')
except RuntimeError:
pass
self.assertIs(install.call_args.kwargs['on_stop'], cleanup)
switch.stop.assert_called_once()
if __name__ == '__main__': if __name__ == '__main__':