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>
793 lines
40 KiB
Python
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()
|