Files
lc-mcp/tests/test_lc_mcp.py
T
ywsandClaude Opus 5.5 96a31bc1ae 按台账修镜牢: 饰品弹窗兜底、按键扫描码、卡包按体系加分
按 docs/ISSUES.md 处理本机回归后待修/待数据的条目:

- I-06/R-04 开局「获得E.G.O饰品」弹窗死循环: 确认模板连续第 3 次命中起改点
  按钮中心(勾号 +76/1440), 连续 20 次还在就记 [ERROR]、抛 TaskAbort 结束任务
  (上游 continue 跳过了循环计数)。单测执行上游真实 select_init_ego_gift。
- I-05/R-03 键盘寻路 0 成功: 前台按键改发带扫描码和扩展键标志的 keybd_event,
  各模式按住 0.12 秒(上游注释: Unity 6 校验扫描码/扩展键); 连续 3 个节点进不去
  就本次任务停用键盘寻路(方案 B)。MCP key 工具前台同样处理。LCP_KEY_HOLD=0 关。
- I-07/R-02 事件表 6 -> 9 条: 蜘蛛巢、归乡路途两段(拿「归途」), 按 wiki.gg 核对结果;
  全表按本机装的零协 release 2026111301 重新核对唯一性。
- I-13 复查 5992827: 「进入」先模板确认再 OCR(原来每轮都跑一次整屏 OCR);
  选队页重试重新截图; 入场切队失败记 [ERROR] 且本局不再重翻列表。
- R-01/I-08 卡包按体系加分: wiki.gg 122 个卡包(楼层/专属饰品/Featured 分类) +
  零协中文名生成 lc_mcp/data/theme_pack_systems.json(scripts/build_theme_pack_systems.py);
  灰机 wiki 对云端 403、BWIKI 无卡包条目, 中文社区攻略用 codex CLI 联网检索,
  推荐/避开并入表的 community。选卡包时临时加到 AALC 权重上, 按当前难度只看会出现
  的卡包; 审计记 system_bonus。LCP_THEME_PACK_SYSTEMS=0 关。
- 文档: ISSUES/BACKLOG/README 更新, 新增 docs/feedback/2026-11-15/REGRESSION.md
  (本轮回归清单)和 theme-pack-research.md(检索记录)。

单测 703 个全过(Linux)。实机未验。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 01:24:46 +00:00

782 lines
39 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_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()