Files
lc-mcp/tests/test_lc_mcp.py
ywsandClaude Opus 5.5 a04b443b6a 镜牢兔子洞速刷: 每场第一回合超频「空洞」、攻略路线卡包加分
run_task(task="mirror", strategy="rabbit_hole") 时生效, 不带 strategy 时不装:
- 选队按 rabbit_hole.json 的编队名(默认「兔子洞」);
- 每回合 P → 长按浮士德打开 E.G.O 列表 → OCR 找「空洞」, 第一回合长按卡片超频
  (侵蚀「空洞」直接打人; 普通「空洞」只叠弹孔), 其余回合单击 → Enter;
  审计 battle/hollow 记 overclock/ego/ego_unavailable/no_option;
- 路线卡包加分: 赌徒 → 地狱鸡 → 去·海·边 → 憎恶与绝望 → 2号线(OurPlay 全程困难路线),
  按 AALC 默认权重模拟每层都选到路线卡包。
长按点 press_at 出厂未校准: 只记 [ERROR], 照常 P+Enter。
机制和超频操作按零协游戏文本/教程核实; 编队、路线按 codex 检索的 OurPlay/Reddit 攻略。
实机校准步骤见 docs/feedback/2026-11-15/RABBIT-HOLE.md, 台账 R-08。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 05:12:23 +00:00

793 lines
40 KiB
Python

# -*- coding: utf-8 -*-
"""不需要 Windows/AALC 的测试: python -m unittest discover -s tests"""
import json
import io
import os
import socket
import subprocess
import sys
import tempfile
import threading
import time
import types
import unittest
from types import SimpleNamespace
from unittest import mock
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, REPO)
from lc_mcp import server as srv_mod # noqa: E402
from lc_mcp.engine import find_hits # noqa: E402
from lc_mcp.fake_engine import FakeEngine # noqa: E402
from lc_mcp.protocol import AUTOMATION_INSTRUCTIONS, Server, TOOLS # noqa: E402
from lc_mcp.tasks import TaskRunner # noqa: E402
START = {'text': '开始', 'x': 100, 'y': 200, 'w': 40, 'h': 20}
def call(server, tool, **args):
resp = server.handle({'jsonrpc': '2.0', 'id': 1, 'method': 'tools/call',
'params': {'name': tool, 'arguments': args}})
res = resp['result']
data = json.loads(res['content'][0]['text'])
assert res['isError'] == (not data.get('ok', False)), res
return data
def sleeper_argv(seconds):
code = 'import sys,time; print("child", sys.argv[1:], flush=True); time.sleep(%s)' % seconds
return lambda task, params: [sys.executable, '-c', code, task, json.dumps(params)]
class MatchTest(unittest.TestCase):
def test_ignores_spaces_and_case(self):
items = [{'text': 'Hong Lu', 'x': 0, 'y': 0, 'w': 10, 'h': 10}]
self.assertEqual(find_hits('honglu', items)[0]['x'], 5)
def test_exact_first(self):
items = [{'text': '开始战斗', 'x': 0, 'y': 0, 'w': 10, 'h': 10}, START]
self.assertEqual(find_hits('开始', items)[0]['text'], '开始')
def test_empty_matches_nothing(self):
self.assertEqual(find_hits(' ', [START]), [])
class ProtocolTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.tasks = TaskRunner(self.tmp.name, argv_factory=sleeper_argv(5))
self.engine = FakeEngine(frames=[[START]], images={'battle/turn_assets.png': (50, 60)})
self.s = Server(self.engine, self.tasks)
def tearDown(self):
self.tasks.stop()
self.tmp.cleanup()
def test_initialize_and_list(self):
r = self.s.handle({'jsonrpc': '2.0', 'id': 7, 'method': 'initialize', 'params': {}})
self.assertEqual(r['id'], 7)
self.assertEqual(r['result']['instructions'], AUTOMATION_INSTRUCTIONS)
names = [t['name'] for t in self.s.handle({'jsonrpc': '2.0', 'id': 8, 'method': 'tools/list'})['result']['tools']]
self.assertEqual(names, [t['name'] for t in TOOLS])
self.assertIsNone(self.s.handle({'jsonrpc': '2.0', 'method': 'notifications/initialized'}))
self.assertEqual(self.s.handle({'jsonrpc': '2.0', 'id': 9, 'method': 'nope'})['error']['code'], -32601)
def test_click_text(self):
r = call(self.s, 'click_text', text='开 始')
self.assertTrue(r['ok'])
self.assertEqual(self.engine.actions, [('click', 120, 210, 1)])
self.assertFalse(call(self.s, 'click_text', text='不存在')['ok'])
self.assertFalse(call(self.s, 'click_text', text='开始', index=3)['ok'])
self.assertFalse(call(self.s, 'click_text', text='')['ok'])
def test_bad_arguments_are_tool_errors(self):
r = call(self.s, 'click', x='abc', y=1)
self.assertIn('bad arguments', r['error'])
self.assertFalse(call(self.s, 'click')['ok'])
def test_invalid_request_shapes_do_not_escape_or_send_input(self):
for params in (['invalid'], 'invalid', 1, True, None):
response = self.s.handle({'jsonrpc': '2.0', 'id': 7, 'method': 'tools/call', 'params': params})
self.assertEqual(response['error']['code'], -32602)
for arguments in ([], 'invalid', 1, True, None):
response = self.s.handle({'jsonrpc': '2.0', 'id': 8, 'method': 'tools/call',
'params': {'name': 'click', 'arguments': arguments}})
self.assertEqual(response['error']['code'], -32602)
self.assertEqual(self.engine.actions, [])
def test_notifications_never_reply_or_perform_request_only_actions(self):
message = {'jsonrpc': '2.0', 'method': 'tools/call',
'params': {'name': 'click', 'arguments': {'x': 1, 'y': 2}}}
self.assertIsNone(self.s.handle(message))
self.assertEqual(self.engine.actions, [])
self.assertIsNotNone(self.s.handle(dict(message, id=None)))
def test_malformed_messages_allow_following_valid_request(self):
messages = ['null', '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":[1]}',
'{"jsonrpc":"2.0","id":2,"method":"ping"}']
stdin, stdout = io.StringIO('\n'.join(messages) + '\n'), io.StringIO()
srv_mod.serve_lines(self.s, stdin.readline, stdout.write)
responses = [json.loads(line) for line in stdout.getvalue().splitlines()]
self.assertEqual([r.get('error', {}).get('code') for r in responses[:2]], [-32600, -32602])
self.assertEqual(responses[2], {'jsonrpc': '2.0', 'id': 2, 'result': {}})
def test_invalid_envelope_returns_request_error(self):
for updates in ({'jsonrpc': '1.0'}, {'method': []}, {'id': True}, {'id': []}):
message = dict({'jsonrpc': '2.0', 'id': 9, 'method': 'ping'}, **updates)
self.assertEqual(self.s.handle(message)['error']['code'], -32600)
def test_task_start_cannot_race_an_input_already_in_progress(self):
entered, release = threading.Event(), threading.Event()
self.engine.click = lambda *args: (entered.set(), release.wait(3))
worker = threading.Thread(target=lambda: call(self.s, 'click', x=1, y=2))
worker.start()
try:
self.assertTrue(entered.wait(2))
started = time.monotonic()
response = call(self.s, 'run_task', task='mirror')
self.assertFalse(response['ok'])
self.assertIsNone(self.tasks.proc)
self.assertLess(time.monotonic() - started, 1)
self.assertEqual(call(self.s, 'task_status')['state'], 'idle')
self.assertTrue(call(self.s, 'stop_task')['ok'])
finally:
release.set()
worker.join(3)
def test_drag_duration_and_rejected_arguments(self):
r = call(self.s, 'drag', from_x=200, from_y=300, to_x=200, to_y=600, duration=1.5)
self.assertTrue(r['ok'])
self.assertEqual(self.engine.actions[-1], ('drag', 200, 300, 200, 600, 1.5))
action_count = len(self.engine.actions)
for duration in (-1, 0, 11, float('nan'), float('inf')):
self.assertFalse(call(self.s, 'drag', from_x=1, from_y=2,
to_x=3, to_y=4, duration=duration)['ok'])
self.assertEqual(len(self.engine.actions), action_count)
def test_images(self):
self.assertEqual(call(self.s, 'find_image', name='battle/turn_assets.png')['x'], 50)
r = call(self.s, 'find_image', name='home/x.png')
self.assertTrue(r['ok'])
self.assertFalse(r['found'])
self.assertFalse(call(self.s, 'click_image', name='home/x.png')['ok'])
call(self.s, 'click_image', name='battle/turn_assets.png')
self.assertEqual(self.engine.actions[-1], ('click', 50, 60, 1))
self.assertEqual(call(self.s, 'list_images', prefix='battle/')['count'], 1)
def test_wait_for_text(self):
self.engine.frames = [[], [], [START]]
with mock.patch('lc_mcp.protocol.WAIT_INTERVAL', 0.01):
r = call(self.s, 'wait_for_text', text='开始', timeout=2)
self.assertTrue(r['ok'])
self.engine.frames = [[START]]
r = call(self.s, 'wait_for_text_gone', text='开始', timeout=0.05)
self.assertFalse(r['ok'])
self.assertIn('timeout', r['error'])
def test_task_lifecycle_blocks_manual_input(self):
self.assertEqual(call(self.s, 'task_status')['state'], 'idle')
r = call(self.s, 'run_task', task='mirror', count=2, exp=9) # exp 不属于 mirror, 忽略
self.assertTrue(r['ok'], r)
self.assertFalse(call(self.s, 'run_task', task='daily')['ok'])
self.assertIn('stop_task', call(self.s, 'click', x=1, y=1)['error'])
self.assertIn('stop_task', call(self.s, 'drag', from_x=1, from_y=2,
to_x=3, to_y=4)['error'])
self.assertTrue(call(self.s, 'get_state')['ok']) # 只读工具仍可用
# 轮询等子进程输出, 不用固定等待 (机器负载高时 0.5s 不够)
deadline = time.time() + 10
while True:
st = call(self.s, 'task_status')
if st['log_tail'] or time.time() > deadline:
break
time.sleep(0.05)
self.assertEqual(st['state'], 'running')
self.assertEqual(st['params'], {'count': 2})
self.assertIn("child ['mirror', '{\"count\": 2}']", '\n'.join(st['log_tail']))
self.assertEqual(call(self.s, 'stop_task')['state'], 'stopped')
self.assertEqual(call(self.s, 'task_status')['state'], 'stopped')
self.assertTrue(call(self.s, 'click', x=1, y=1)['ok'])
self.assertFalse(call(self.s, 'run_task', task='bogus')['ok'])
def test_run_task_strategy_option(self):
self.assertIn('rabbit_hole', next(t for t in TOOLS if t['name'] == 'run_task')
['inputSchema']['properties']['strategy']['enum'])
self.assertIn('不支持 strategy', call(self.s, 'run_task', task='mirror', strategy='fast')['error'])
self.assertIn('不支持 strategy', call(self.s, 'run_task', task='daily', strategy='rabbit_hole')['error'])
self.assertEqual(call(self.s, 'task_status')['state'], 'idle')
r = call(self.s, 'run_task', task='mirror', count=1, strategy='rabbit_hole')
self.assertTrue(r['ok'], r)
self.assertEqual(call(self.s, 'task_status')['params'], {'count': 1, 'strategy': 'rabbit_hole'})
self.assertEqual(call(self.s, 'stop_task')['state'], 'stopped')
def test_task_exit_codes(self):
self.tasks.argv_factory = lambda t, p: [sys.executable, '-c', 'import sys; sys.exit(3)']
call(self.s, 'run_task', task='reward')
self.tasks.proc.wait(5)
st = call(self.s, 'task_status')
self.assertEqual((st['state'], st['exit_code']), ('failed', 3))
def test_engine_unavailable(self):
s = Server(None, self.tasks, engine_error='no windows')
self.assertIn('no windows', call(s, 'get_state')['error'])
self.assertEqual(call(s, 'task_status')['state'], 'idle')
class AalcTaskArgsTest(unittest.TestCase):
def test_rejects_unknown_params(self):
from lc_mcp import aalc_task
self.assertEqual(aalc_task.main(['x', 'mirror', '{"exp": 1}']), 2)
self.assertEqual(aalc_task.main(['x', 'nope']), 2)
def test_originals_saved_before_override_and_restored(self):
from lc_mcp import aalc_task
class Cfg:
def __init__(self):
self.values, self.saved, self.flushes = {'set_mirror_count': 1, 'infinite_dungeons': True}, {}, 0
def get_value(self, key):
return self.values[key]
def unsaved_set_value(self, key, value):
self.values[key] = value
def set_value(self, key, value):
self.values[key] = self.saved[key] = value
def flush(self):
self.flushes += 1
cfg = Cfg()
before = {'set_mirror_count': 1, 'infinite_dungeons': True}
lines = []
with tempfile.TemporaryDirectory() as d, mock.patch.object(aalc_task, 'log', lines.append):
path = os.path.join(d, 'x.restore.json')
originals = aalc_task.apply_overrides(cfg, 'mirror', {'count': 5}, path)
# 指定次数时无限刷牢必须关掉, 否则 AALC 把次数改成 9999
self.assertEqual(cfg.values, {'set_mirror_count': 5, 'infinite_dungeons': False})
self.assertIn('无限刷牢', '\n'.join(lines))
with open(path, encoding='utf-8') as f:
self.assertEqual(json.load(f), before)
self.assertEqual(originals, before)
# 任务进程被强杀后, TaskRunner 用 --restore 读文件写回
aalc_task.restore_file(path, cfg)
self.assertEqual((cfg.saved, cfg.flushes), (before, 1))
self.assertFalse(os.path.exists(path))
self.assertEqual(aalc_task.apply_overrides(cfg, 'reward', {}, path), {})
self.assertFalse(os.path.exists(path)) # 没有覆盖就不留恢复文件
def test_mirror_without_count_keeps_configured_infinite_mode(self):
from lc_mcp import aalc_task
cfg = mock.Mock()
cfg.get_value.side_effect = {'set_EXP_count': 3}.get
self.assertEqual(aalc_task.apply_overrides(cfg, 'mirror', {}), {})
cfg.unsaved_set_value.assert_not_called()
self.assertEqual(aalc_task.apply_overrides(cfg, 'daily', {'exp': 1}), {'set_EXP_count': 3})
cfg.unsaved_set_value.assert_called_once_with('set_EXP_count', 1)
class TaskRestoreTest(unittest.TestCase):
"""run_task 的临时次数会随 AALC 中途存盘写进 config.yaml; 强杀后必须写回原值。"""
CHILD = ('import json, os, time; p = os.environ["LCP_RESTORE_FILE"]; '
'open(p, "w").write(json.dumps({"set_mirror_count": 1})); time.sleep(30)')
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.marker = os.path.join(self.tmp.name, 'restored.txt')
self.runs = os.path.join(self.tmp.name, 'runs')
self.restore_code = 'import os, sys; open(sys.argv[2], "a").write(open(sys.argv[1]).read()); os.remove(sys.argv[1])'
self.runner = TaskRunner(self.runs, argv_factory=lambda t, p: [sys.executable, '-c', self.CHILD],
restore_argv=lambda path: [sys.executable, '-c', self.restore_code, path, self.marker])
def tearDown(self):
self.runner.stop()
self.tmp.cleanup()
def _wait_for_restore_file(self):
deadline = time.time() + 10
while time.time() < deadline:
if any(n.endswith('.restore.json') for n in os.listdir(self.runs)):
return
time.sleep(0.05)
self.fail('child never wrote its restore file')
def test_stop_restores_overridden_config(self):
self.assertTrue(self.runner.start('mirror', {'count': 5})['ok'])
self._wait_for_restore_file()
r = self.runner.stop()
self.assertEqual((r['ok'], r['state']), (True, 'stopped'), r)
with open(self.marker) as f:
self.assertEqual(json.load(f), {'set_mirror_count': 1})
self.assertFalse([n for n in os.listdir(self.runs) if n.endswith('.restore.json')])
def test_leftover_restored_before_next_start_or_start_refused(self):
leftover = os.path.join(self.runs, 'task_20260101_000000_mirror.restore.json')
with open(leftover, 'w') as f:
json.dump({'set_mirror_count': 2}, f)
self.runner.restore_argv = lambda path: [sys.executable, '-c', 'import sys; sys.exit(1)', path]
r = self.runner.start('mirror', {'count': 5})
self.assertFalse(r['ok'])
self.assertIn('restore', r['error'])
self.assertFalse(self.runner.running())
self.assertEqual(self.runner.status()['pending_restore'], [os.path.basename(leftover)])
self.runner.restore_argv = lambda path: [sys.executable, '-c', self.restore_code, path, self.marker]
self.assertTrue(self.runner.start('mirror', {'count': 5})['ok'])
with open(self.marker) as f:
self.assertEqual(json.load(f), {'set_mirror_count': 2})
self.assertFalse(os.path.exists(leftover))
class RuntimeTest(unittest.TestCase):
def test_foreground_drag_targets_current_client_and_releases_on_failure(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='foreground')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine._grab = mock.Mock(return_value=mock.Mock(width=1600, height=720))
engine.screen.handle.hwnd = 123
engine.screen.handle.isMinimized = False
engine.screen.handle.isActive = True
engine.auto.input_handler.pos_offset.side_effect = [(500, 500), (900, 400)]
pointer = mock.Mock()
pointer.moveTo.side_effect = [None, RuntimeError('move interrupted')]
with mock.patch.dict(sys.modules, pyautogui=pointer), mock.patch('lc_mcp.aalc_engine.time.sleep'):
with self.assertRaises(RuntimeError):
engine.drag(300, 300, 700, 200, .5)
pointer.mouseDown.assert_called_once_with(500, 500)
pointer.mouseUp.assert_called_once_with(900, 400)
engine.auto.mouse_drag.assert_not_called()
def test_foreground_input_activates_game_before_sending(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='foreground')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine.auto.input_handler.pos_offset.return_value = (580, 657)
engine.screen.handle.hwnd = 123
engine.screen.handle.isMinimized = False
engine.screen.handle.isActive = False
def activate():
engine.screen.handle.isActive = True
engine.screen.handle.setForeground.side_effect = activate
pointer = mock.Mock()
with mock.patch('lc_mcp.aalc_engine.time.sleep') as sleep, mock.patch.dict(sys.modules, pyautogui=pointer):
engine.click(100, 200)
engine.screen.handle.setForeground.assert_called_once_with()
pointer.moveTo.assert_called_once_with(580, 657)
self.assertEqual(sleep.call_args_list, [mock.call(.15), mock.call(.12), mock.call(.35), mock.call(.12)])
pointer.mouseDown.assert_called_once_with(580, 657)
pointer.mouseUp.assert_called_once_with(580, 657)
engine.auto.mouse_click.assert_not_called()
def test_foreground_focus_failure_does_not_send_input(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='foreground')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine.screen.handle.hwnd = 123
engine.screen.handle.isMinimized = False
engine.screen.handle.isActive = False
engine.key_names = ['enter']
engine._focus_game = mock.Mock()
with mock.patch('lc_mcp.aalc_engine.time.sleep'):
for action in (lambda: engine.click(100, 200),
lambda: engine.keypress('enter'),
lambda: engine.type_text('test')):
with self.assertRaises(RuntimeError):
action()
engine.auto.mouse_click.assert_not_called()
engine.auto.key_press.assert_not_called()
engine.auto.input_text.assert_not_called()
def test_foreground_input_releases_on_interruption(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='foreground')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine.screen.handle.hwnd = 123
engine.screen.handle.isMinimized = False
engine.screen.handle.isActive = True
engine.auto.input_handler.pos_offset.return_value = (580, 657)
engine.key_names = ['enter']
pointer = mock.Mock()
with mock.patch.dict(sys.modules, pyautogui=pointer), \
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]):
with self.assertRaises(RuntimeError):
engine.click(100, 200)
user32 = mock.Mock()
user32.MapVirtualKeyW.return_value = 0x1C
tables = types.ModuleType('module.automation.input_handlers.input')
tables.key_list, tables.EXTENDED_KEY_VKS = {'enter': 0x0D}, frozenset({0x26})
with mock.patch.dict(sys.modules, {'module.automation.input_handlers.input': tables}), \
mock.patch('ctypes.windll', SimpleNamespace(user32=user32), create=True), \
mock.patch('time.sleep', side_effect=RuntimeError('interrupted')):
with self.assertRaises(RuntimeError):
engine.keypress('enter')
pointer.mouseUp.assert_called_once_with(580, 657)
# 前台按键带扫描码; 按住期间被打断也要抬起
self.assertEqual(user32.keybd_event.call_args_list, [mock.call(0x0D, 0x1C, 0, 0), mock.call(0x0D, 0x1C, 2, 0)])
pointer.keyDown.assert_not_called()
def test_foreground_move_settle_failure_sends_no_button_press(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='foreground')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine.screen.handle.hwnd = 123
engine.screen.handle.isMinimized = False
engine.screen.handle.isActive = True
engine.auto.input_handler.pos_offset.return_value = (580, 657)
pointer = mock.Mock()
with mock.patch.dict(sys.modules, pyautogui=pointer), \
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=RuntimeError('interrupted')):
with self.assertRaises(RuntimeError):
engine.click(100, 200)
pointer.mouseDown.assert_not_called()
def test_focus_retry_detaches_threads_even_on_failure(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.screen = mock.Mock()
engine.screen.handle.hwnd = 123
engine.screen.handle.isActive = False
engine.screen.handle.setForeground.side_effect = RuntimeError('focus refused')
api, gui, process = mock.Mock(), mock.Mock(), mock.Mock()
api.GetCurrentThreadId.return_value = 1
gui.GetForegroundWindow.return_value = 456
process.GetWindowThreadProcessId.side_effect = [(2, 200), (3, 300)]
with mock.patch.dict(sys.modules, win32api=api, win32gui=gui, win32process=process):
with self.assertRaises(RuntimeError):
engine._focus_game()
self.assertEqual(process.AttachThreadInput.call_args_list,
[mock.call(1, 2, True), mock.call(1, 3, True),
mock.call(1, 3, False), mock.call(1, 2, False)])
def test_background_click_holds_and_releases_without_moving_pointer_or_window(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='background')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
handler = mock.Mock(spec=['set_mouse_pos','set_active','mouse_down','mouse_up'])
engine.auto.input_handler = handler
sequence = mock.Mock()
engine._background_mouse = mock.Mock()
sequence.attach_mock(engine._background_mouse, 'message')
constants = mock.Mock(WM_MOUSEMOVE=512, WM_LBUTTONDOWN=513, WM_LBUTTONUP=514)
with mock.patch.dict(sys.modules, win32con=constants), \
mock.patch('lc_mcp.aalc_engine.time.sleep') as sleep:
sequence.attach_mock(sleep, 'sleep')
engine.click(100, 200)
self.assertEqual(sequence.mock_calls, [mock.call.message(512, 100, 200),
mock.call.sleep(.12),
mock.call.message(513, 100, 200, held=True),
mock.call.sleep(.12), mock.call.message(514, 100, 200),
mock.call.sleep(.12)])
engine.auto.mouse_click.assert_not_called()
handler.set_mouse_pos.assert_not_called()
handler.mouse_down.assert_not_called()
with mock.patch.dict(sys.modules, win32con=constants), \
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]):
with self.assertRaises(RuntimeError):
engine.click(100, 200)
self.assertEqual(engine._background_mouse.call_args, mock.call(514, 100, 200))
engine.screen.handle.set_window_pos.assert_not_called()
def test_background_keypress_holds_and_releases_on_error(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.key_names = ['enter']
engine.cfg = mock.Mock(simulator=False, win_input_type='background')
engine.auto = mock.Mock()
with mock.patch('lc_mcp.aalc_engine.time.sleep') as sleep:
engine.keypress('enter')
sleep.assert_called_once_with(0.12)
engine.auto.input_handler.key_down.assert_called_once_with('enter')
engine.auto.input_handler.key_up.assert_called_once_with('enter')
engine.auto.key_press.assert_not_called()
with mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=RuntimeError('interrupted')):
with self.assertRaises(RuntimeError):
engine.keypress('enter')
self.assertEqual(engine.auto.input_handler.key_up.call_count, 2)
def test_pythonw_streams_are_redirected_to_log(self):
with tempfile.TemporaryDirectory() as directory:
with mock.patch.object(srv_mod, 'HOME', directory), \
mock.patch('sys.stdout', None), mock.patch('sys.stderr', None):
stream = srv_mod._configure_streams()
try:
print('启动')
srv_mod.log('ready')
finally:
stream.close()
with open(os.path.join(directory, 'server.log'), encoding='utf-8') as f:
self.assertEqual(f.read(), '启动\n[lc_mcp] ready\n')
def test_stdio_isolates_bootstrap_output_and_uses_utf8(self):
code = '''
from lc_mcp import server
from lc_mcp.protocol import Server
from lc_mcp.fake_engine import FakeEngine
from lc_mcp.tasks import TaskRunner
import tempfile
directory = tempfile.TemporaryDirectory()
def build(fake=False):
print('bootstrap notice')
return Server(FakeEngine(frames=[[{'text':'开始', 'x':1,'y':2,'w':3,'h':4}]]), TaskRunner(directory.name))
server.build_server = build
server.main(['--stdio'])
'''
request = json.dumps({'jsonrpc': '2.0', 'id': 1, 'method': 'tools/call',
'params': {'name': 'get_state'}}, ensure_ascii=False) + '\n'
env = dict(os.environ, PYTHONUTF8='0', PYTHONIOENCODING='cp936')
p = subprocess.run([sys.executable, '-c', code], cwd=REPO, input=request.encode('utf-8'),
capture_output=True, env=env, timeout=20)
self.assertEqual(p.returncode, 0, p.stderr.decode('utf-8', 'replace'))
result = json.loads(p.stdout.decode('utf-8'))
data = json.loads(result['result']['content'][0]['text'])
self.assertEqual(data['items'][0]['text'], '开始')
self.assertIn(b'bootstrap notice', p.stderr)
def test_drag_checks_bounds_before_sending_input(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = mock.Mock(simulator=False, win_input_type='background')
engine._grab = mock.Mock(return_value=mock.Mock(width=800, height=600))
engine.auto = mock.Mock()
with self.assertRaises(ValueError):
engine.drag(100, 100, 800, 500)
engine.auto.mouse_drag.assert_not_called()
engine.cfg.simulator = True
engine.drag(100, 100, 100, 500, 1.5)
engine.auto.mouse_drag.assert_called_once_with(100, 100, drag_time=1.5, dx=0, dy=400)
def test_template_scale_tracks_client_and_restores_config_on_error(self):
from lc_mcp.aalc_engine import AalcEngine
engine = AalcEngine.__new__(AalcEngine)
engine.list_images = mock.Mock(return_value=['battle/setting_assets.png'])
engine._grab = mock.Mock(return_value=mock.Mock(width=1278, height=731))
engine.cfg = mock.Mock(set_win_size=1080)
engine.cfg.unsaved_set_value.side_effect = lambda key, value: setattr(engine.cfg, key, value)
engine.auto = mock.Mock()
def match(*args, **kwargs):
self.assertEqual(engine.cfg.set_win_size, 718.875)
return (1233, 42)
engine.auto.find_image_element.side_effect = match
self.assertEqual(engine.find_image('battle/setting_assets.png'), (1233, 42))
self.assertEqual(engine.cfg.set_win_size, 1080)
self.assertEqual(engine.auto.clear_img_cache.call_count, 1)
engine.auto.find_image_element.side_effect = RuntimeError('match failed')
with self.assertRaises(RuntimeError):
engine.find_image('battle/setting_assets.png')
self.assertEqual(engine.cfg.set_win_size, 1080)
# 同一窗口尺寸复用已缩放的模板缓存 (clear_img_cache 每次都会全量 gc)
self.assertEqual(engine.auto.clear_img_cache.call_count, 1)
engine.cfg.set_value.assert_not_called()
engine.auto.find_image_element.side_effect = lambda *a, **k: (10, 10)
engine._grab.return_value = mock.Mock(width=1920, height=1080)
engine.find_image('battle/setting_assets.png')
self.assertEqual(engine.auto.clear_img_cache.call_count, 2)
def test_template_list_is_scanned_once(self):
from lc_mcp import aalc_engine
engine = aalc_engine.AalcEngine.__new__(aalc_engine.AalcEngine)
with tempfile.TemporaryDirectory() as root:
os.makedirs(os.path.join(root, 'default', 'share', 'battle'))
open(os.path.join(root, 'default', 'share', 'battle', 'turn_assets.png'), 'wb').close()
engine.images_root = root
with mock.patch.object(aalc_engine.glob, 'glob', wraps=aalc_engine.glob.glob) as scan:
self.assertEqual(engine.list_images('battle/'), ['battle/turn_assets.png'])
self.assertEqual(engine.list_images(), ['battle/turn_assets.png'])
self.assertEqual(scan.call_count, 6) # 2 主题 x 3 语言, 只扫一轮
def free_port():
with socket.socket() as s:
s.bind(('127.0.0.1', 0))
return s.getsockname()[1]
class TransportTest(unittest.TestCase):
def test_client_disconnect_is_not_a_server_error(self):
handler = srv_mod._Handler.__new__(srv_mod._Handler)
for error in (ConnectionResetError, BrokenPipeError):
handler._handle_session = mock.Mock(side_effect=error('client closed'))
handler.handle()
handler._handle_session.assert_called_once_with()
handler._handle_session = mock.Mock(side_effect=ValueError('internal bug'))
with self.assertRaises(ValueError):
handler.handle()
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.token_file = os.path.join(self.tmp.name, 'token')
with open(self.token_file, 'w') as f:
f.write('secret-token')
self.port = free_port()
mcp = Server(FakeEngine(frames=[[START]]), TaskRunner(self.tmp.name))
self.tcp = srv_mod.make_tcp(mcp, '127.0.0.1', self.port, 'secret-token')
threading.Thread(target=self.tcp.serve_forever, daemon=True).start()
def tearDown(self):
self.tcp.shutdown()
self.tcp.server_close()
self.tmp.cleanup()
def test_wrong_token_rejected(self):
with socket.create_connection(('127.0.0.1', self.port)) as s:
s.sendall(b'AUTH wrong\n')
self.assertEqual(s.makefile('rb').readline().strip(), b'DENIED')
def test_non_ascii_token_is_denied_not_crashed(self):
with socket.create_connection(('127.0.0.1', self.port)) as s:
s.sendall('AUTH 密码\n'.encode('utf-8'))
self.assertEqual(s.makefile('rb').readline().strip(), b'DENIED')
def test_bridge_end_to_end(self):
env = dict(os.environ, LCP_PORT=str(self.port), HOME=self.tmp.name, USERPROFILE=self.tmp.name)
os.makedirs(os.path.join(self.tmp.name, 'lc_mcp'))
os.replace(self.token_file, os.path.join(self.tmp.name, 'lc_mcp', 'token'))
lines = [
'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}',
'',
'not json',
'{"jsonrpc":"2.0","method":"notifications/initialized"}',
'{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"click_text","arguments":{"text":"开始"}}}',
]
p = subprocess.run([sys.executable, os.path.join(REPO, 'lc_mcp', 'bridge.py')],
input='\n'.join(lines) + '\n', capture_output=True, text=True,
encoding='utf-8', env=env, timeout=20)
out = [json.loads(x) for x in p.stdout.splitlines()]
self.assertEqual([o.get('id') for o in out], [1, None, 2], p.stdout + p.stderr)
self.assertEqual(out[1]['error']['code'], -32700)
self.assertFalse(out[2]['result']['isError'])
def test_bridge_offline(self):
env = dict(os.environ, LCP_PORT=str(free_port()), HOME=self.tmp.name, USERPROFILE=self.tmp.name,
PYTHONUTF8='0', PYTHONIOENCODING='cp936')
os.makedirs(os.path.join(self.tmp.name, 'lc_mcp'))
os.replace(self.token_file, os.path.join(self.tmp.name, 'lc_mcp', 'token'))
req = ('{"jsonrpc":"2.0","id":1,"method":"initialize"}\n'
'{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_state"}}\n')
p = subprocess.run([sys.executable, os.path.join(REPO, 'lc_mcp', 'bridge.py')], input=req,
capture_output=True, text=True, encoding='utf-8', env=env, timeout=20)
out = [json.loads(x) for x in p.stdout.splitlines()]
self.assertIn('offline', out[0]['result']['serverInfo']['name'])
self.assertIn('未运行', out[1]['error']['message'])
self.assertEqual(p.returncode, 1)
self.assertIn('服务未运行或不可达', p.stderr)
def test_stdio_server(self):
req = ('{"jsonrpc":"2.0","id":1,"method":"ping"}\n'
'{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_state"}}\n')
env = dict(os.environ, HOME=self.tmp.name, USERPROFILE=self.tmp.name)
p = subprocess.run([sys.executable, '-m', 'lc_mcp.server', '--stdio', '--fake'], cwd=REPO, input=req,
capture_output=True, text=True, encoding='utf-8', env=env, timeout=20)
out = [json.loads(x) for x in p.stdout.splitlines()]
self.assertEqual(out[0]['result'], {})
state = json.loads(out[1]['result']['content'][0]['text'])
self.assertEqual((state['ok'], state['items']), (True, []))
class TaskErrorSurfaceTest(unittest.TestCase):
"""AALC 每日流程单次战斗失败后仍 exit 0; 状态里必须带出日志报错。"""
CHILD = ('import sys; '
'sys.stdout.write("[ERROR] [AALC] tasks\\\\battle\\\\battle.py:83: '
'超出最大尝试次数,未能进入战斗\\n"); '
'sys.stdout.write("[lc_mcp] task daily done\\n"); '
'sys.stdout.flush()')
def test_exit_zero_with_battle_error_is_reported(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', self.CHILD])
self.assertTrue(runner.start('daily', {'exp': 1})['ok'])
deadline = time.time() + 15
while time.time() < deadline and runner.running():
time.sleep(0.05)
status = runner.status()
self.assertEqual((status['state'], status['exit_code']), ('succeeded', 0), status)
self.assertIn('未能进入战斗', status['errors'][-1])
def test_clean_log_has_no_errors_field(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', 'print("[lc_mcp] ok")'])
self.assertTrue(runner.start('daily', {})['ok'])
deadline = time.time() + 15
while time.time() < deadline and runner.running():
time.sleep(0.05)
status = runner.status()
self.assertEqual(status['state'], 'succeeded')
self.assertNotIn('errors', status)
def test_early_battle_error_survives_later_debug_output(self):
# AALC 会在一场战斗失败后继续执行, 报错可能已不在最后 400 行/64 KiB。
child = ('print("[ERROR] 超出最大尝试次数,未能进入战斗")\n'
'for _ in range(5000): print("[DEBUG] 后续正常输出")\n'
'print("[lc_mcp] task daily done")\n')
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', child])
self.addCleanup(runner.stop)
self.assertTrue(runner.start('daily', {})['ok'])
runner.proc.wait(timeout=15)
status = runner.status(lines=1)
self.assertGreater(os.path.getsize(status['log']), 64 * 1024)
self.assertEqual((status['state'], status['exit_code']), ('succeeded', 0))
self.assertEqual(status['log_tail'], ['[lc_mcp] task daily done'])
self.assertIn('未能进入战斗', status.get('errors', [''])[-1])
def test_full_scan_keeps_only_last_three_errors(self):
from lc_mcp.tasks import log_errors
with tempfile.TemporaryDirectory() as d:
path = os.path.join(d, 'task.log')
with open(path, 'w', encoding='utf-8') as f:
for n in range(5):
f.write('[ERROR] problem %d\n' % n)
f.write('[DEBUG] running\n' * 500)
f.write('Traceback (most recent call last):\n')
f.write('[DEBUG] cleanup\n' * 500)
self.assertEqual(log_errors(path), ['[ERROR] problem 3', '[ERROR] problem 4',
'Traceback (most recent call last):'])
def test_finished_result_survives_log_removal_and_resets_for_next_run(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', self.CHILD])
self.addCleanup(runner.stop)
runner.start('daily', {})
runner.proc.wait(timeout=15)
first = runner.status()
os.remove(first['log'])
self.assertEqual(runner.status()['errors'], first['errors'])
runner.argv_factory = lambda t, p: [sys.executable, '-c', 'print("clean run")']
runner.start('reward', {})
runner.proc.wait(timeout=15)
self.assertNotIn('errors', runner.status())
class TaskStallSurfaceTest(unittest.TestCase):
"""空队伍卡死时进程健在、日志无报错, 只有编队人数检查在刷屏。"""
@staticmethod
def child(repeats):
return ('import sys, time\n'
'for _ in range(%d):\n'
' sys.stdout.write("[DEBUG] tasks\\\\teams\\\\team_formation.py:225: '
'对于配队人数OCR得到:0/5\\n")\n'
'sys.stdout.flush()\n'
'time.sleep(30)\n' % repeats)
def status_while_running(self, repeats):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', self.child(repeats)])
self.assertTrue(runner.start('daily', {})['ok'])
try:
deadline = time.time() + 15
while time.time() < deadline and repeats and not os.path.getsize(runner.info['log']):
time.sleep(0.05)
time.sleep(0.2)
return runner.status()
finally:
runner.stop()
def test_repeated_empty_team_check_is_reported(self):
status = self.status_while_running(12)
self.assertEqual(status['state'], 'running')
self.assertEqual(status['stall'], {'empty_team': 12})
def test_occasional_check_is_not_a_stall(self):
status = self.status_while_running(3)
self.assertEqual(status['state'], 'running')
self.assertNotIn('stall', status)
if __name__ == '__main__':
unittest.main()