fix: preserve strategy intent and recover accounts automatically

This commit is contained in:
AttilaNet
2026-11-11 19:37:15 +08:00
parent ccb945631d
commit 5c253d5cf9
26 changed files with 1628 additions and 236 deletions
@@ -27,16 +27,14 @@ class AutoReloginSchemaTests(unittest.TestCase):
catalog = Catalog()
fields = next(page["form"] for page in schema(catalog)["pages"] if page["key"] == "login")
fields = {tuple(field["path"]): field for field in fields}
enabled = fields[("auto_relogin", "enabled")]
delay = fields[("auto_relogin", "delay_minutes")]
self.assertEqual(enabled["label"], "掉线后自动重新登录")
self.assertEqual(enabled["type"], "boolean")
self.assertIs(enabled["value"], False)
self.assertNotIn(("auto_relogin", "enabled"), fields)
self.assertIsInstance(default_config()["auto_relogin"]["enabled"], bool)
self.assertEqual((delay["type"], delay["min"], delay["max"], delay["value"]), ("integer", 1, 10080, 30))
engine = SimpleNamespace(catalog=catalog, snapshot=None, demo=False)
view = build_view(engine, "login", default_config())
values = {tuple(field["path"]): field["value"] for field in view["form"]}
self.assertIs(values[("auto_relogin", "enabled")], False)
self.assertNotIn(("auto_relogin", "enabled"), values)
self.assertEqual(values[("auto_relogin", "delay_minutes")], 30)
@@ -77,8 +75,9 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.configs[identifier]["auto_relogin"] = {"enabled": False, "delay_minutes": 30}
summary = copy.deepcopy(self.manager.status(identifier))
summary.update(demo=False, connected=False, running=False, connection_state="offline",
connection_message="尚未连接游戏", error="", revision=9000)
summary["auto_relogin_status"] = {"state": "disabled", "message": "自动重登未开启", "next_attempt_at": None}
connection_message="尚未连接游戏", error="", revision=9000,
strategy_requested=False, strategy_state="stopped", strategy_message="", strategy_retry_at=None)
summary["auto_relogin_status"] = {"state": "missing_identity", "message": "尚未保存登录角色", "next_attempt_at": None}
self.summaries[identifier] = summary
self.login_data[identifier] = build_view(engine, "login", default_config())
self.login_data[identifier].update(account="offline-fixture", has_saved_password=True)
@@ -122,9 +121,10 @@ class AutoReloginBrowserTests(unittest.TestCase):
route.abort()
return
self.summaries[identifier].update(connected=False, running=False, connection_state="offline")
self.set_status(identifier, "cancelled", "手动退出登录,已取消本次自动重登")
self.waiting(identifier, message="退出登录后仍按设定时长自动重登",
requested=self.summaries[identifier]["strategy_requested"])
self.fulfill(route, {"id": "mock-logout", "operation": operation, "status": "succeeded",
"result": {"message": "已退出登录并取消自动重登"}})
"result": {"message": "已退出当前连接,仍会自动重登"}})
return
if request.method in ("POST", "PUT", "DELETE", "PATCH"):
self.unexpected_actions.append(path)
@@ -146,15 +146,21 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.summaries[identifier]["auto_relogin_status"] = {
"state": state, "message": message, "next_attempt_at": next_attempt_at}
def waiting(self, identifier=None, *, seconds=45, message="掉线后等待自动重登"):
def waiting(self, identifier=None, *, seconds=45, message="掉线后等待自动重登", requested=True):
identifier = identifier or self.first
self.configs[identifier]["auto_relogin"]["enabled"] = True
summary = self.summaries[identifier]
summary["strategy_requested"] = requested
if not requested:
summary["strategy_state"] = "stopped"
elif summary["strategy_state"] == "stopped":
summary["strategy_state"] = "offline"
target = (datetime.now(timezone.utc) + timedelta(seconds=seconds)).isoformat().replace("+00:00", "Z")
self.set_status(identifier, "waiting", message, target)
return target
def controls(self, panel):
return panel.get_by_role("checkbox", name="掉线后自动重新登录", exact=True), panel.get_by_role("spinbutton", name="重登等待时长(分钟)", exact=True)
def delay_control(self, panel):
expect(panel.get_by_role("checkbox", name="掉线后自动重新登录", exact=True)).to_have_count(0)
return panel.get_by_role("spinbutton", name="重登等待时长(分钟)", exact=True)
def saved(self, identifier, enabled, minutes):
self.page.wait_for_function("() => document.querySelector('#save-status').textContent === '策略已自动保存'")
@@ -162,27 +168,27 @@ class AutoReloginBrowserTests(unittest.TestCase):
def complete_login(self, operation, *, running=True):
self.summaries[self.first].update(connected=True, connection_state="online",
connection_message="游戏连接正常", error="", running=running)
connection_message="游戏连接正常", error="", running=running,
strategy_requested=running, strategy_state="running" if running else "stopped")
return {"id": "mock-" + operation, "operation": operation, "status": "succeeded", "result": {}}
def test_defaults_visible_explanations_and_existing_layout(self):
self.open()
panel = self.go("login")
enabled, delay = self.controls(panel)
expect(enabled).to_be_visible()
expect(enabled).not_to_be_checked()
delay = self.delay_control(panel)
expect(delay).to_be_visible()
expect(delay).to_have_value("30")
for attribute, value in (("min", "1"), ("max", "10080"), ("step", "1")):
expect(delay).to_have_attribute(attribute, value)
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启"):
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启", "退出登录", "只有", "清除登录记录", "暂停"):
expect(panel).to_contain_text(text)
self.assertTrue(enabled.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(enabled.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
self.assertTrue(delay.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(delay.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
expect(panel.get_by_role("button", name="保存", exact=True)).to_have_count(0)
for width, height in ((1280, 800), (390, 844)):
self.page.set_viewport_size({"width": width, "height": height})
self.assertLessEqual(self.page.evaluate("document.documentElement.scrollWidth"), width)
expect(enabled).to_be_visible()
expect(delay).to_be_visible()
self.assertEqual(self.writes, [])
self.assertEqual(self.actions, [])
@@ -196,7 +202,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
return {"id": "mock-login", "operation": "login", "status": "succeeded", "result": candidates}
def stop(payload):
self.summaries[self.first]["running"] = False
self.summaries[self.first].update(running=False, strategy_requested=False, strategy_state="stopped")
return {"id": "mock-stop", "operation": "stop", "status": "succeeded", "result": {"message": "策略已停止"}}
self.action_handlers.update({(self.first, "login"): login,
@@ -230,13 +236,13 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.writes, [])
def test_import_stays_stopped_and_next_restored_session_runs_imported_selection(self):
def test_import_and_restored_session_preserve_explicit_pause_and_imported_selection(self):
imported = copy.deepcopy(default_config())
imported["daily_policy"].update(enabled=True, selected=["gift"])
portable = export_config(imported)
imports = []
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线区服 / 原角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session")
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session", running=False)
def import_config(route):
imports.append(route.request.post_data_json)
@@ -253,15 +259,15 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.page.locator('[data-command="import-config"]').click()
chooser.value.set_files({"name": "offline-policy.json", "mimeType": "application/json",
"buffer": json.dumps(portable).encode("utf-8")})
expect(self.page.locator("#dialog-content")).to_contain_text("下次成功登录会自动执行已勾选功能")
expect(self.page.locator("#dialog-content")).to_contain_text("仍遵循当前开启 / 停止设置")
self.page.locator("#dialog-confirm").click()
expect(self.page.locator("#notice")).to_contain_text("策略已导入,执行已停止")
expect(self.page.locator("#notice")).to_contain_text("策略已导入")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.assertEqual(imports, [portable])
self.assertEqual(self.actions, [])
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#notice")).to_contain_text("用户暂停")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
self.assertEqual(self.configs[self.first], imported, "Restoring must preserve imported selections")
self.assertEqual(self.writes, [])
@@ -314,17 +320,12 @@ class AutoReloginBrowserTests(unittest.TestCase):
def test_native_autosave_range_validation_refresh_and_focus(self):
self.open()
panel = self.go("login")
enabled, delay = self.controls(panel)
enabled.check()
checkbox = enabled.element_handle()
self.page.wait_for_timeout(850)
self.saved(self.first, True, 30)
self.assertTrue(enabled.evaluate("(node, original) => node === original && node === document.activeElement", checkbox))
delay = self.delay_control(panel)
delay.fill("47")
original = delay.element_handle()
before = self.view_calls
self.page.wait_for_timeout(5200)
self.saved(self.first, True, 47)
self.saved(self.first, False, 47)
self.assertGreater(self.view_calls, before, "Offline login DTOs must keep refreshing")
self.assertTrue(delay.evaluate("(node, original) => node === original && node === document.activeElement", original))
for invalid in ("0", "10081", "1.5", ""):
@@ -336,9 +337,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
for valid in (1, 10080):
delay.fill(str(valid))
self.page.wait_for_timeout(850)
self.saved(self.first, True, valid)
enabled.uncheck()
self.page.wait_for_timeout(850)
self.saved(self.first, False, valid)
self.saved(self.first, False, 10080)
self.assertEqual(self.actions, [])
@@ -350,14 +349,13 @@ class AutoReloginBrowserTests(unittest.TestCase):
remember = panel.get_by_role("checkbox", name="记住账号和密码", exact=True)
remember.uncheck()
panel.get_by_role("textbox", name="游戏密码", exact=True).fill("mock-secret-never-send")
enabled, _ = self.controls(panel)
enabled.check()
self.delay_control(panel).fill("10")
hint = panel.locator("[data-auto-relogin-credentials]")
expect(hint).to_be_visible()
expect(hint).to_contain_text("缺少")
expect(hint).to_contain_text("记住账号和密码")
self.page.wait_for_timeout(1000)
self.saved(self.first, True, 30)
self.saved(self.first, False, 10)
expect(remember).not_to_be_checked()
self.assertTrue(self.writes)
payloads = json.dumps(self.writes, ensure_ascii=False)
@@ -370,26 +368,24 @@ class AutoReloginBrowserTests(unittest.TestCase):
def test_account_switch_isolates_pending_edits_status_and_minutes(self):
self.waiting(message="账号一正在等待自动重登")
self.set_status(self.second, "disabled", "账号二未开启自动重登")
self.set_status(self.second, "missing_identity", "账号二尚未保存登录角色")
self.open()
panel = self.go("login")
_, delay = self.controls(panel)
delay = self.delay_control(panel)
delay.fill("17")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
panel = self.go("login")
enabled, second_delay = self.controls(panel)
expect(enabled).not_to_be_checked()
second_delay = self.delay_control(panel)
expect(second_delay).to_have_value("30")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号二未开启")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号二尚未保存")
expect(panel).not_to_contain_text("账号一正在等待")
enabled.check()
second_delay.fill("9")
self.page.wait_for_timeout(1000)
self.saved(self.second, True, 9)
self.assertEqual(self.configs[self.first]["auto_relogin"], {"enabled": True, "delay_minutes": 17})
self.saved(self.second, False, 9)
self.assertEqual(self.configs[self.first]["auto_relogin"], {"enabled": False, "delay_minutes": 17})
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
panel = self.go("login")
expect(self.controls(panel)[1]).to_have_value("17")
expect(self.delay_control(panel)).to_have_value("17")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号一正在等待")
self.assertEqual({identifier for identifier, _ in self.writes}, {self.first, self.second})
self.assertEqual(self.actions, [])
@@ -404,8 +400,8 @@ class AutoReloginBrowserTests(unittest.TestCase):
expect(status).to_contain_text("掉线后等待自动重登")
expect(countdown).to_contain_text("秒后自动重新登录")
expect(countdown).to_contain_text("北京时间")
expect(self.controls(panel)[0]).to_be_enabled()
delay = self.controls(panel)[1]
delay = self.delay_control(panel)
expect(delay).to_be_enabled()
delay.focus()
original = delay.element_handle()
before = countdown.inner_text()
@@ -421,10 +417,12 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.set_status(self.first, "failed", reason)
expect(status).to_contain_text(reason)
expect(status.locator("img")).to_have_count(0)
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
original = copy.deepcopy(self.configs[self.first])
self.set_status(self.first, "monitoring", "重登成功,已恢复监控并自动执行已勾选功能,可在顶部停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=True)
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常",
running=True, strategy_requested=True, strategy_state="running")
expect(status).to_contain_text("已恢复监控并自动执行已勾选功能")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行已配置且已勾选的功能")
@@ -436,31 +434,35 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("服务重启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
before = len(self.writes)
self.page.reload(wait_until="networkidle")
panel = self.go("login")
expect(self.controls(panel)[0]).to_be_checked()
expect(self.controls(panel)[1]).to_have_value("30")
expect(self.delay_control(panel)).to_have_value("30")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
self.page.goto("about:blank")
self.page.close()
self.assertEqual(len(self.writes), before)
self.assertEqual(self.summaries[self.first]["auto_relogin_status"]["next_attempt_at"], target)
self.assertEqual(self.actions, [])
def test_manual_logout_cancels_countdown_without_disabling_account_setting(self):
def test_manual_logout_keeps_countdown_and_preserves_strategy_pause(self):
self.waiting()
self.summaries[self.first].update(strategy_requested=False, strategy_state="stopped")
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
panel.get_by_role("button", name="退出登录", exact=True).click()
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("已取消本次自动重登")
expect(panel.locator("[data-auto-relogin-countdown]")).to_be_hidden()
expect(self.controls(panel)[0]).to_be_checked()
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("仍按设定时长自动重登")
expect(panel.locator("[data-auto-relogin-countdown]")).to_be_visible()
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
expect(self.delay_control(panel)).to_have_value("30")
self.assertEqual(self.actions, [(self.first, "logout", {})])
self.assertEqual(self.writes, [])
if __name__ == "__main__":
@@ -72,7 +72,8 @@ class ConnectionBrowserTests(unittest.TestCase):
panel = self.go("ranch")
expect(panel.locator("tbody tr").first).to_be_visible()
row_count = panel.locator("tbody tr").count()
self.summary.update(connection_state="expired", connection_message="登录凭据已失效,请重新登录。")
failure_reason = "登录凭据已失效,请重新登录。"
self.summary.update(connection_state="expired", connection_message=failure_reason, error=failure_reason)
expect(self.page.locator("#connection")).to_have_text("登录已过期")
expect(self.page.locator("#data-summary")).to_contain_text(self.summary["connection_message"])
expect(panel.locator(".page-loading")).to_contain_text("缓存")
@@ -89,10 +90,14 @@ class ConnectionBrowserTests(unittest.TestCase):
self.assertTrue(panel.locator("input[data-config-path]").first.is_enabled())
self.summary.update(connection_state="online", connection_message="游戏连接正常", error="", last_game_success_at="2026-11-11T00:01:00Z")
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#connection")).to_have_attribute("title", "游戏连接正常")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
expect(panel.locator("[data-connection-status]")).to_be_hidden()
expect(self.page.locator("#data-summary")).not_to_contain_text("凭据已失效")
expect(self.page.locator("#status-text")).not_to_contain_text("凭据已失效")
expect(panel.locator("[data-connection-status]")).to_have_text("")
for selector in ("#data-summary", "#status-text"):
expect(self.page.locator(selector)).to_be_visible()
expect(self.page.locator(selector)).to_contain_text(f"上次失败:{failure_reason}")
expect(self.page.locator(f'.account-tab[data-account="{self.first}"] .account-dot')).not_to_have_class("account-dot error")
expect(panel.locator(".page-loading")).not_to_contain_text("缓存")
self.assertEqual(self.page.locator("#page-tabs [role=tab]").count(), 15)
self.assertEqual(self.external_requests, [])
@@ -0,0 +1,214 @@
"""Durable execution intent with synthetic API responses and loopback HTTP only."""
from __future__ import annotations
import unittest
from . import test_auto_relogin_browser as relogin
from . import test_workbench_browser as fixtures
if fixtures.AVAILABLE:
from playwright.sync_api import expect
@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required")
class RunIntentBrowserTests(unittest.TestCase):
setUpClass = classmethod(relogin.AutoReloginBrowserTests.setUpClass.__func__)
tearDownClass = classmethod(relogin.AutoReloginBrowserTests.tearDownClass.__func__)
tearDown = relogin.AutoReloginBrowserTests.tearDown
await_job = fixtures.WorkbenchBrowserTests.await_job
open = fixtures.WorkbenchBrowserTests.open
go = fixtures.WorkbenchBrowserTests.go
fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill)
set_status = relogin.AutoReloginBrowserTests.set_status
waiting = relogin.AutoReloginBrowserTests.waiting
def setUp(self):
relogin.AutoReloginBrowserTests.setUp(self)
for summary in self.summaries.values():
summary.update(strategy_requested=False, strategy_state="stopped",
strategy_message="", strategy_retry_at=None)
self.summary = self.summaries[self.first]
self.online()
self.page.add_init_script("""(() => {
const original = window.setInterval;
window.setInterval = (callback, delay, ...args) => {
if (callback.name === 'tick') {window.__pollIntent = callback;return -1;}
return original(callback, delay, ...args);
};
})();""")
def poll(self):
self.page.evaluate("async () => {await window.__pollIntent();}")
self.page.wait_for_load_state("networkidle")
def online(self, *, running=True):
self.summary.update(connected=True, connection_state="online", connection_message="游戏连接正常",
error="", running=running, strategy_requested=True,
strategy_state="running" if running else "recovering", strategy_message="",
strategy_retry_at=None, next_retry_at=None)
def recovering(self):
self.summary.update(running=False, strategy_requested=True, connection_state="retrying",
connection_message="游戏请求超时,正在恢复连接。", error="游戏请求超时",
strategy_state="recovering", strategy_message="网络超时,等待只读检查后恢复策略。")
self.summary["strategy_retry_at"] = self.page.evaluate("new Date(Date.now()+30000).toISOString()")
self.summary["next_retry_at"] = self.summary["strategy_retry_at"]
self.waiting(seconds=600)
def test_timeout_heartbeat_only_and_recovery_preserve_stop_and_failure_history(self):
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.recovering()
self.poll()
expect(toggle).to_have_text("停止")
expect(toggle).to_be_enabled()
expect(toggle).to_have_class("run-button running")
expect(toggle).to_have_attribute("aria-pressed", "true")
expect(self.page.locator("#data-summary")).to_contain_text("等待")
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
expect(self.page.locator("#connection")).to_have_text("正在重试")
expect(self.page.locator("#refresh")).to_be_disabled()
self.online(running=False)
self.poll()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text("等待恢复")
expect(self.page.locator("#data-summary")).to_contain_text("上次失败")
expect(self.page.locator("#data-summary")).to_contain_text("游戏请求超时")
expect(toggle).to_have_text("停止")
expect(self.page.locator(f'.account-tab[data-account="{self.first}"] .account-dot')).not_to_have_class("account-dot error")
self.online()
self.poll()
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行")
expect(self.page.locator("#data-summary")).to_contain_text("上次失败")
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.assertEqual(self.actions, [])
self.assertEqual(self.writes, [])
def test_stop_during_recovery_persists_pause_while_relogin_continues(self):
self.open()
self.recovering()
self.poll()
def stop(payload):
self.summary.update(strategy_requested=False, running=False, strategy_state="stopped",
strategy_message="用户已停止策略,仍会保持登录。")
return {"id": "intent-stop", "operation": "stop", "status": "succeeded", "result": {}}
def start(payload):
self.online()
return {"id": "intent-start", "operation": "start", "status": "succeeded", "result": {}}
self.action_handlers[(self.first, "stop")] = stop
self.action_handlers[(self.first, "start")] = start
toggle = self.page.locator("#strategy-toggle")
toggle.click()
expect(toggle).to_have_text("开启")
expect(toggle).to_have_attribute("aria-pressed", "false")
expect(toggle).to_be_disabled()
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
expect(self.page.locator('[data-auto-relogin-countdown]')).to_be_visible()
self.summary.update(connected=True, connection_state="online", connection_message="游戏连接正常", error="",
next_retry_at=None, strategy_retry_at=None)
self.poll()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(toggle).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
self.page.reload(wait_until="networkidle")
expect(toggle).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
toggle.click()
expect(toggle).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行")
self.assertEqual([(account, operation) for account, operation, _ in self.actions],
[(self.first, "stop"), (self.first, "start")])
self.assertEqual(self.writes, [])
def test_online_execution_block_is_distinct_from_connection_health_and_can_be_stopped(self):
self.online(running=False)
reason = '交付结果待确认 <img src=x onerror="alert(1)">'
self.summary.update(strategy_state="blocked", strategy_message=reason)
self.open()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text(reason)
expect(self.page.locator("#data-summary img")).to_have_count(0)
expect(self.page.locator("#data-summary")).not_to_contain_text("正在自动执行")
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
self.assertEqual(self.actions, [])
def test_legacy_status_falls_back_to_running_and_keeps_heartbeat_only_online(self):
for field in ("strategy_requested", "strategy_state", "strategy_message", "strategy_retry_at"):
self.summary.pop(field)
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
self.summary["running"] = False
self.poll()
expect(toggle).to_have_text("开启")
expect(toggle).to_be_enabled()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
self.assertEqual(self.actions, [])
def test_applying_preset_saves_rules_without_sending_stop_or_changing_intent(self):
view = {"loading": False, "data": {"page": "hatching", "form": [], "filters": [],
"columns": [], "rows": [], "actions": [], "details": {"preset": {
"label": "离线测试预设", "patch": {"policy": {"enabled": True, "collect": True}},
"egg_rules": {"1001010": {"enabled": True}}}}}}
self.page.route(f"**/api/accounts/{self.first}/views/hatching?*", lambda route: self.fulfill(route, view))
self.open()
panel = self.go("hatching")
panel.locator('button[data-operation="apply_preset"]').click()
expect(self.page.locator("#notice")).to_contain_text("预设已保存")
expect(self.page.locator("#notice")).to_contain_text("正在自动执行")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
self.assertEqual(len(self.writes), 1)
self.assertTrue(self.configs[self.first]["policy"]["egg_rules"]["1001010"]["enabled"])
self.assertTrue(self.summary["strategy_requested"])
self.assertEqual(self.actions, [], "Applying a preset must not submit a durable user Stop")
def test_restart_wait_and_accounts_keep_intent_and_original_log_region_separate(self):
self.summary.update(connected=False, running=False, connection_state="offline", strategy_requested=True,
strategy_state="offline", strategy_message="等待重新登录后执行已勾选功能。")
self.configs[self.first]["auto_relogin"] = {"enabled": False, "delay_minutes": 10}
self.waiting(seconds=600, message="服务重启,等待返回原区服角色")
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
expect(toggle).to_be_enabled()
expect(self.page.locator('[aria-label="重登等待时长(分钟)"]')).to_have_value("10")
expect(self.page.locator('[data-auto-relogin-countdown]')).to_be_visible()
expect(self.page.locator("#log-panel")).to_be_hidden()
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-panel")).to_be_visible()
self.page.locator("#log-search").fill("登录筛选")
original = self.page.locator("#log-panel").element_handle()
self.go("bag")
expect(self.page.locator("#log-panel")).to_be_visible()
expect(self.page.locator("#log-search")).to_have_value("")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
expect(toggle).to_have_text("开启")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
expect(toggle).to_have_text("停止")
self.go("login")
expect(self.page.locator("#log-panel")).to_be_visible()
expect(self.page.locator("#log-search")).to_have_value("登录筛选")
self.assertTrue(self.page.locator("#log-panel").evaluate("(node, original) => node === original", original))
expect(self.page.locator('[role="log"]')).to_have_count(1)
self.page.reload(wait_until="networkidle")
expect(toggle).to_have_text("停止")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.assertEqual(self.actions, [])
self.assertEqual(self.writes, [])
if __name__ == "__main__":
unittest.main()
+83 -17
View File
@@ -9,6 +9,7 @@ from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, SessionExpiredError
from ranch_assistant.model import Action
from ranch_web.policies import default_config, export_config, validate_config
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
@@ -102,7 +103,7 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(worker.engine.client.session.role_id, 102)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Authentication must not run selected writes inline")
self.assertTrue(result["running"])
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.config, selected)
@@ -128,10 +129,39 @@ class AutoReloginTests(unittest.TestCase):
def test_recovery_clears_outage_and_next_outage_gets_fresh_delay(self):
identifier, worker = self.connected()
self.enable(identifier)
self.disconnect(identifier, worker, timeout=True)
before = len(fixtures.FakeClient.calls)
self.now += 5
self.tick(identifier, worker)
self.assertEqual(self.auto_status(identifier)["state"], "idle")
self.assertTrue(worker.running, "A confirmed read lost the user's execution request")
self.assertFalse(worker.engine.auto, "A retry must not authorize writes in its own job")
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[before:]],
[["masterService", "masterQueryDetail"]])
monster = next(iter(worker.engine.snapshot.monsters))
action = Action("lock", "Synthetic selected action", "monsterService/monsterLock",
{"monsterId": monster, "lock": True})
writes = []
original = worker.engine.client.http.post
def transport(url, *args, **kwargs):
if url.endswith(action.path):
job = worker._execution
writes.append((job.operation, job.consuming, job.generation == worker._generation))
return original(url, *args, **kwargs)
with patch.object(worker.engine, "plans", return_value=[action]), \
patch.object(worker.engine.client.http, "post", side_effect=transport):
# This invokes the real Engine.poll/read_snapshot path. The
# snapshot callback must not enable the selected write inline.
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(writes, [])
self.assertFalse(worker.engine.auto)
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertEqual(writes, [("__tick", True, True)])
self.now += 100
self.disconnect(identifier, worker)
before = len(AutoLogin.calls)
@@ -142,9 +172,9 @@ class AutoReloginTests(unittest.TestCase):
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_enabling_and_changing_delay_reuses_known_outage(self):
def test_changing_delay_reuses_known_outage(self):
identifier, worker = self.connected()
self.configure(identifier, enabled=False, delay=5)
self.configure(identifier, delay=5)
self.disconnect(identifier, worker)
self.now += 70
self.configure(identifier, delay=2)
@@ -242,9 +272,14 @@ class AutoReloginTests(unittest.TestCase):
self.login(identifier, server=2)
self.assertNotEqual(self.manager.get_config(identifier)["config"]["policy"]["keep_money"], 4321)
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"]["delay_minutes"], 7)
worker = self.manager._worker(identifier)
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
self.assertTrue(self.manager.get_config(identifier)["config"]["auto_relogin"]["enabled"])
self.assertEqual(self.auto_status(identifier)["state"], "suspended")
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
self.assertEqual(self.auto_status(identifier)["state"], "waiting")
def test_portable_import_preserves_local_login_preference(self):
identifier, worker = self.connected()
@@ -257,10 +292,14 @@ class AutoReloginTests(unittest.TestCase):
public = json.dumps(self.manager.get_config(identifier)) + json.dumps(export_config(worker.config))
self.assertNotIn("synthetic-password", public)
self.assertNotIn("synthetic-center-token", public)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
def test_restart_opt_in_activates_after_thirty_minutes_and_supersedes_old_stop(self):
def test_restart_reconnects_after_thirty_minutes_and_preserves_explicit_stop(self):
identifier, worker = self.connected()
self.enable(identifier)
self.configure(identifier, delay=30)
@@ -285,14 +324,16 @@ class AutoReloginTests(unittest.TestCase):
self.now = origin + 1800
result = self.tick(identifier, worker)["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(result["running"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertEqual(worker.config, selected)
self.assertEqual(len(AutoLogin.calls), before[0] + 1)
def test_final_activation_revocation_never_starts_relogin_candidate(self):
for operation in ("stop", "logout", "forget_login", "policy", "disable", "delay"):
for operation in ("stop", "logout", "forget_login", "policy", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.enable(identifier)
@@ -337,7 +378,7 @@ class AutoReloginTests(unittest.TestCase):
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_restart_opt_in_waits_and_logout_disarms_restart(self):
def test_restart_waits_and_logout_retains_keep_login_across_restart(self):
identifier, worker = self.connected()
self.manager.close()
before = len(AutoLogin.calls)
@@ -361,13 +402,15 @@ class AutoReloginTests(unittest.TestCase):
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
self.now += 99999
self.now = worker.schedule.disconnected_at + 60
worker.schedule.clock = lambda: self.now
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(worker.running)
def test_logout_forget_and_delay_change_revoke_inflight_auth_immediately(self):
for operation in ("logout", "forget_login", "disable", "delay"):
for operation in ("logout", "forget_login", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
@@ -388,7 +431,6 @@ class AutoReloginTests(unittest.TestCase):
self.assertTrue(entered.wait(2))
if operation in {"logout", "forget_login"}:
next_job = self.manager.submit(identifier, operation)
self.assertEqual(self.auto_status(identifier)["state"], "suspended")
else:
config = self.manager.get_config(identifier)["config"]
config["auto_relogin"].update(enabled=operation != "disable", delay_minutes=2)
@@ -398,11 +440,22 @@ class AutoReloginTests(unittest.TestCase):
self.job(identifier, next_job)
self.assertEqual(len(AutoLogin.calls), before)
self.assertFalse(self.manager.status(identifier)["connected"])
if operation == "logout":
# Revoking an in-flight SDK call retains its completion
# backoff as well as keep-login authorization.
self.assertEqual(self.auto_status(identifier)["state"], "failed")
self.assertIsNotNone(self.auto_status(identifier)["next_attempt_at"])
self.assertTrue(worker.securestore.load_credentials()[0])
elif operation == "forget_login":
self.assertFalse(worker.securestore.load_credentials()[0])
self.assertIsNone(worker.active_identity)
def test_account_isolation(self):
first, first_worker = self.connected(account="owner-one")
second, second_worker = self.connected(account="owner-two")
self.configure(second, enabled=False)
self.enable(first)
self.enable(second)
self.configure(second, delay=2)
self.disconnect(first, first_worker)
self.disconnect(second, second_worker)
self.now += 60
@@ -412,6 +465,19 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(AutoLogin.calls[before:], [("owner-one", "synthetic-password")])
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(self.manager.status(second)["connected"])
self.manager.submit(first, "stop")
self.disconnect(first, first_worker)
self.now += 60
self.tick(first, first_worker)
self.tick(second, second_worker)
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(first_worker.running)
self.assertTrue(self.manager.status(first)["manual_stop"])
self.assertTrue(self.manager.status(second)["connected"])
self.assertTrue(second_worker.running)
self.assertFalse(self.manager.status(second)["manual_stop"])
self.assertEqual(AutoLogin.calls[before + 1:],
[("owner-one", "synthetic-password"), ("owner-two", "synthetic-password")])
def test_stop_policy_and_delay_cancellation_back_off_even_after_transport_error(self):
for operation in ("stop", "policy", "delay"):
+66 -17
View File
@@ -12,6 +12,7 @@ from ranch_web.activity import ActivityLogError
from ranch_web.service import WebManager
from ranch_web.scheduler import Scheduler
from ranch_web.tests import test_service as fixtures
from ranch_web.tests.test_auto_relogin import AutoLogin
class ConnectionStateTests(unittest.TestCase):
@@ -73,9 +74,9 @@ class ConnectionStateTests(unittest.TestCase):
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertEqual(self.manager.status(identifier)["connection_state"], "online")
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Session verification must not authorize selected writes inline")
def test_explicit_stop_survives_heartbeat_local_refresh_and_monitor_until_login(self):
def test_explicit_stop_survives_heartbeat_refresh_monitor_and_relogin(self):
identifier, worker = self.connected(running=True)
self.manager.submit(identifier, "stop")
worker.engine.last_heartbeat = 0
@@ -90,8 +91,16 @@ class ConnectionStateTests(unittest.TestCase):
self.assertTrue(self.manager.status(identifier)["connected"])
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.login(identifier)
self.assertFalse(worker.running, "Password login erased the same role's explicit Stop")
self.assertFalse(worker.engine.auto)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
def test_timeout_retries_only_snapshot_and_keeps_uncertain_write_evidence(self):
identifier, worker = self.connected(running=True)
@@ -127,6 +136,10 @@ class ConnectionStateTests(unittest.TestCase):
self.assertIsNone(self.manager.status(identifier)["next_retry_at"])
self.assertIsNotNone(self.manager.status(identifier)["last_game_success_at"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertFalse(self.manager.status(identifier)["manual_stop"])
self.assertEqual(journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"])
self.assertEqual(evidence.read_bytes(), before)
# Continue through the ordinary monitor/reconcile path after recovery.
@@ -140,6 +153,9 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"])
self.assertEqual(journal.pending(worker.engine.snapshot)["phase"], "unknown")
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(evidence.read_bytes(), before)
def test_business_rejection_keeps_connection_and_idle_does_not_clear_error(self):
identifier, worker = self.connected(running=True)
@@ -236,8 +252,8 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(self.manager.status(identifier)["error"], reason)
self.assertFalse(self.manager.status(identifier)["connected"])
def test_failed_restore_candidate_does_not_poison_online_client(self):
identifier, worker = self.connected()
def test_failed_restore_and_login_candidates_preserve_online_client_and_monitor(self):
identifier, worker = self.connected(running=True)
client = worker.engine.client
original = deepcopy(self.manager.status(identifier))
response = self.expiry(worker)
@@ -250,6 +266,30 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(state["last_game_success_at"], original["last_game_success_at"])
self.assertEqual(state["connection_message"], original["connection_message"])
self.assertTrue(state["connected"])
for fail in (True, False):
with self.subTest(login_failure=fail):
before = len(fixtures.FakeClient.calls)
if fail:
with patch.object(fixtures.FakeLogin, "authenticate", side_effect=ApiError("Candidate login failed")):
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}), status="failed")
else:
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
self.assertIs(worker.engine.client, client)
self.assertFalse(client.closed)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(len(fixtures.FakeClient.calls), before,
"Server discovery issued old-role strategy writes inline")
self.now += 61
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
with patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1, "An online role lost automatic polling after candidate login")
self.assertTrue(worker.schedule.monitoring)
self.assertTrue(worker.running)
def test_failed_same_protocol_restore_preserves_counter_high_water_before_wire_and_finally(self):
identifier, worker = self.connected()
@@ -321,7 +361,7 @@ class ConnectionStateTests(unittest.TestCase):
self.idle(identifier)
logs = self.manager.logs(identifier, after=old_cursor)
self.assertGreater(logs["next"], old_cursor)
self.assertTrue(any("重启" in row["message"] and "恢复" in row["message"] for row in logs["entries"]))
self.assertTrue(any("重启" in row["message"] and "重新登录" in row["message"] for row in logs["entries"]))
all_logs = self.manager.logs(identifier, debug=True)["entries"]
self.assertTrue(any("可持久保存的运行事件" == row["message"] for row in all_logs))
self.assertFalse(any("不持久保存的调试内容" == row["message"] for row in all_logs))
@@ -408,32 +448,41 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(messages[2], "账号工作区已载入")
self.assertFalse(any("无法持久保存" in message for message in messages[1:]))
def test_restart_and_explicit_logout_require_manual_restore(self):
def test_restart_and_logout_retain_explicit_stop_and_saved_login(self):
identifier, worker = self.connected()
self.manager.close()
calls = len(fixtures.FakeClient.calls)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
state = self.manager.status(identifier)
self.assertEqual(state.get("connection_state"), "offline")
self.assertIn("重启", state["connection_message"])
self.assertIn("恢复", state["connection_message"])
self.assertIn("重新登录", state["connection_message"])
self.assertFalse(state["running"])
self.assertEqual(len(fixtures.FakeClient.calls), calls)
self.tick(identifier, worker)
self.assertEqual(len(fixtures.FakeClient.calls), calls)
self.assertTrue(state["manual_stop"])
self.assertFalse(state["strategy_requested"])
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertFalse(worker.running)
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
calls = len(fixtures.FakeClient.calls)
self.now += 10000
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
self.assertEqual(self.manager.status(identifier)["auto_relogin_status"]["state"], "waiting")
# The delay is anchored in the restarted scheduler's own clock.
self.now = worker.schedule.disconnected_at + worker.config["auto_relogin"]["delay_minutes"] * 60
worker.schedule.clock = lambda: self.now
attempts = len(AutoLogin.calls)
self.tick(identifier, worker)
state = self.manager.status(identifier)
self.assertEqual(state["connection_state"], "offline")
self.assertIn("退出", state["connection_message"])
self.assertEqual(len(AutoLogin.calls), attempts + 1)
self.assertTrue(state["connected"])
self.assertEqual(state["auto_relogin_status"]["state"], "idle")
self.assertTrue(state["manual_stop"])
self.assertFalse(state["running"])
self.assertEqual(len(fixtures.FakeClient.calls), calls)
class ErrorClassificationTests(unittest.TestCase):
+346
View File
@@ -0,0 +1,346 @@
"""Durable user intent and recovery, using temporary stores and offline clients."""
from copy import deepcopy
import json
import math
import threading
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, SessionExpiredError, encode
from ranch_web.policies import export_config
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
from ranch_web.tests.test_auto_relogin import AutoLogin
class RunIntentTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
enable = fixtures.ServiceTests.enable
def connected(self, *, keep_login=False):
self.manager.login_factory = AutoLogin
identifier = self.account(False)
self.login(identifier, account="intent-owner-" + identifier[:8])
worker = self.manager._worker(identifier)
self.now = 1000.0
worker.schedule.clock = lambda: self.now
worker.schedule.uniform = lambda low, high: high
worker.engine.last_heartbeat = self.now
value = self.manager.get_config(identifier)["config"]
value["auto_relogin"] = {"enabled": keep_login, "delay_minutes": 10}
self.job(identifier, self.manager.set_config(identifier, value)["job"])
worker.schedule.next_poll = math.inf
return identifier, worker
def tick(self, identifier, worker, *, status="succeeded"):
return self.job(identifier, worker.enqueue("__tick"), status=status)
def fail_read(self, identifier, worker, error=None):
error = error or requests.ReadTimeout("offline synthetic timeout")
with patch.object(worker.engine.client.http, "post", side_effect=error) as post:
self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed")
self.assertEqual(post.call_count, 1)
def restart(self, identifier):
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
origin = worker.schedule.disconnected_at
self.now = origin if origin is not None else self.now
worker.schedule.clock = lambda: self.now
return worker
def pending(self, worker):
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "unknown synthetic battle",
"path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"})
journal.update(record, "unknown", message="请求结果未知,禁止自动重发")
return journal, journal.path.read_bytes()
def test_read_timeout_recovers_requested_execution_after_read_only_probe(self):
identifier, worker = self.connected()
self.assertTrue(worker.running)
self.fail_read(identifier, worker)
self.assertFalse(worker.running)
before = len(fixtures.FakeClient.calls)
self.now += 4
self.tick(identifier, worker)
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertTrue(worker.running, "Successful retry restored online but permanently lost execution")
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(worker.engine.auto, "Reconnect verification enabled writes in its own job")
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[before:]],
[["masterService", "masterQueryDetail"]])
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.assertTrue(worker.running)
def test_only_explicit_stop_persists_and_start_clears_it(self):
identifier, worker = self.connected()
identity = worker.active_identity
worker.stop() # Desktop adapter / cancellation is not the Stop button.
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.manager.submit(identifier, "stop")
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertFalse(worker.running, "Activation erased the user's explicit Stop")
worker = self.restart(identifier)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertFalse(worker.running)
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
worker = self.restart(identifier)
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertTrue(worker.running)
def test_stop_does_not_cancel_offline_password_reconnect(self):
identifier, worker = self.connected(keep_login=True)
self.fail_read(identifier, worker, SessionExpiredError("offline expired", code=408))
self.manager.submit(identifier, "stop")
before = len(AutoLogin.calls)
self.now += 599
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertFalse(worker.running)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
def test_logout_keeps_identity_credentials_and_reconnects_even_legacy_disabled(self):
identifier, worker = self.connected()
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
before = len(AutoLogin.calls)
self.now += 600
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(worker.running)
def test_startup_migrates_saved_identity_and_reconnects_without_button(self):
identifier, worker = self.connected()
identity = worker.active_identity
# Old installations have no intent file and could save enabled=False.
local = self.manager.store.load_config(worker._login_settings_root)
local["config"]["auto_relogin"]["enabled"] = False
self.manager.store.save_config(worker._login_settings_root, local["config"], local["revision"])
worker = self.restart(identifier)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertTrue(worker.config["auto_relogin"]["enabled"])
self.assertIsNotNone(state["auto_relogin_status"]["next_attempt_at"])
self.now += 600
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.assertEqual(worker.active_identity, identity)
def test_pending_barrier_keeps_requested_intent_and_resumes_after_resolution(self):
identifier, worker = self.connected()
journal, evidence = self.pending(worker)
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "blocked")
self.assertIn("核对", state["strategy_message"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.manager.submit(identifier, "stop")
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.assertTrue(self.manager.status(identifier)["strategy_requested"], "Start must clear Stop even while blocked")
self.assertEqual(journal.path.read_bytes(), evidence)
with patch.object(worker.engine, "_progression_pending", return_value=None):
self.tick(identifier, worker)
self.assertTrue(worker.running)
def test_intent_is_separate_from_portable_policy_and_scoped_to_role(self):
identifier, worker = self.connected()
first = worker.active_identity
config = deepcopy(worker.config)
self.manager.submit(identifier, "stop")
self.assertEqual(worker.config, config)
intent_path = worker.profile_root / "run_intent.json"
self.assertTrue(intent_path.is_file())
portable = json.dumps(export_config(worker.config))
for value in ("strategy_requested", "manual_stop", "intent-owner", first):
self.assertNotIn(value, portable)
self.login(identifier, account=worker._saved_account, server=2)
self.assertTrue(worker.running, "A different role inherited the first role's Stop")
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": first}))
self.assertFalse(worker.running)
def test_manual_refresh_does_not_enable_auto_inside_snapshot_callback(self):
identifier, worker = self.connected()
self.fail_read(identifier, worker)
self.now += 5
self.tick(identifier, worker)
seen = []
def read_only(*args, **kwargs):
worker.engine.read_snapshot(sync_master=False)
seen.append(worker.engine.auto)
return worker.engine.snapshot, [], "synthetic preview"
with patch.object(worker.engine, "poll", side_effect=read_only):
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(seen, [False])
self.assertTrue(worker.running)
def test_stop_racing_retry_callback_wins_without_disabling_keep_login(self):
identifier, worker = self.connected()
self.fail_read(identifier, worker)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.engine.client.http.post
def held(*args, **kwargs):
entered.set()
if not release.wait(5):
raise AssertionError("offline retry gate not released")
return original(*args, **kwargs)
self.now += 5
with patch.object(worker.engine.client.http, "post", side_effect=held):
job = worker.enqueue("__tick")
self.assertTrue(entered.wait(5))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, job)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
def test_failed_candidate_login_rearms_existing_online_monitor(self):
identifier, worker = self.connected()
original = worker.engine.client
with patch.object(AutoLogin, "authenticate", side_effect=ValueError("synthetic candidate failure")):
self.job(identifier, self.manager.submit(identifier, "login", {
"account": worker._saved_account, "password": "synthetic-password"}), status="failed")
self.assertIs(worker.engine.client, original)
self.assertTrue(worker.schedule.monitoring)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.now += 5
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.assertTrue(worker.running)
def test_transient_local_planner_error_has_bounded_backoff_without_stop_intent(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", side_effect=ValueError("synthetic planner unavailable")) as poll:
self.tick(identifier, worker, status="failed")
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "recovering")
self.assertIsNotNone(state["strategy_retry_at"])
self.assertEqual(worker._execution_retry_deadline, self.now + 5)
for _ in range(3):
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.now += 60 # Scheduler also applies its per-kind failure cooldown.
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False):
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.assertIsNone(self.manager.status(identifier)["strategy_retry_at"])
def test_decoded_read_business_rejection_gets_execution_backoff(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
with patch.object(worker.engine.client.http, "post", side_effect=ApiError("synthetic rejection", code=403)) as post:
self.tick(identifier, worker, status="failed")
self.assertEqual(post.call_count, 1)
self.assertFalse(worker.running)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "recovering")
self.assertIsNotNone(state["strategy_retry_at"])
self.assertEqual(state["connection_state"], "online")
def test_uncertain_journaled_write_is_never_replayed_after_recovery(self):
identifier, worker = self.connected()
journal, evidence = self.pending(worker)
self.fail_read(identifier, worker)
before = len(fixtures.FakeClient.calls)
self.now += 5
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertEqual(journal.path.read_bytes(), evidence)
for _ in range(3):
self.now += 600
self.tick(identifier, worker)
self.assertEqual(journal.path.read_bytes(), evidence)
self.assertTrue(all(url.endswith(("masterService/masterQueryDetail", "heartBeatService/keepAlive"))
for _, url, _ in fixtures.FakeClient.calls[before:]))
def test_legacy_gift_unchanged_mixed_timestamp_units_stay_blocked_until_confirmed(self):
identifier, worker = self.connected()
mid = next(iter(worker.engine.snapshot.monsters))
original_time = 1_000_000_000
worker.engine.snapshot.monsters[mid]["giftTime"] = original_time
raw = next(mon for mon in worker.engine.client.raw["monsters"] if mon["id"] == mid)
raw["giftTime"] = original_time * 1000
def gift(*args):
worker.engine.client.call("monsterService/monsterSendGift", {"monsterId": mid, "itemId": 1})
return {"message": "synthetic response lacks gift confirmation"}
with patch("ranch_web.actions.execute_action", side_effect=gift):
self.job(identifier, self.manager.submit(identifier, "consume_probe"))
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked",
"Unchanged milliseconds were mistaken for a later gift than cached seconds")
raw["giftTime"] = (original_time + 60) * 1000
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
def test_valid_gift_response_confirms_cooldown_without_waiting_for_role_read(self):
identifier, worker = self.connected()
mid = next(iter(worker.engine.snapshot.monsters))
worker.engine.snapshot.monsters[mid]["giftTime"] = 1_000_000_000
response = SimpleNamespace(status_code=200, headers={}, content=encode(
{"resCode": 0, "feel": 20, "giftDate": 1_000_000_060_000}, worker.engine.client.session.key))
def gift(*args):
worker.engine.client.call("monsterService/monsterSendGift", {"monsterId": mid, "itemId": 1})
return {"message": "synthetic confirmed gift"}
with patch("ranch_web.actions.execute_action", side_effect=gift), \
patch.object(worker.engine.client.http, "post", return_value=response):
self.job(identifier, self.manager.submit(identifier, "consume_probe"))
self.assertTrue(worker.running)
self.assertNotIn(worker.active_identity, worker._legacy_pending)
if __name__ == "__main__":
unittest.main()
+251
View File
@@ -0,0 +1,251 @@
"""Recovery deadlines and loop isolation with fake clocks and no transports."""
import math
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_web.scheduler import AccountSchedule, FAST_KINDS, Scheduler
class SchedulerRecoveryTests(unittest.TestCase):
def setUp(self):
self.now = 1000.0
self.wall = 5000.0
self.schedule = AccountSchedule(clock=lambda: self.now,
wall_clock=lambda: self.wall, uniform=lambda low, high: high)
self.config = {"interval": 30, "auto_relogin": {"enabled": False}}
self.snapshot = SimpleNamespace(now=1000, raw={"exploreTeams": []})
self.engine = SimpleNamespace(demo=False, client=object(), snapshot=self.snapshot,
heartbeat_enabled=True, last_heartbeat=self.now,
pending_recovery_due=lambda: False, master_sync_due=lambda: False,
growth_sync_due=lambda: False, _progression_pending=lambda: None,
_breakthrough_pending=None, pending_hatches=[object()],
explore_planner=SimpleNamespace(pending=lambda snapshot: None),
gift_planner=SimpleNamespace(next_ready_at=None))
self.schedule.monitor()
def due(self, running=False):
return self.schedule.due(self.engine, self.config, running)
def test_stopped_strategy_repeats_password_login_at_configured_or_default_delay(self):
for preference, delay in (({"enabled": True, "delay_minutes": 10}, 600),
({"enabled": True}, 1800)):
with self.subTest(preference=preference):
self.setUp()
self.config["auto_relogin"] = preference
self.schedule.disconnected()
self.schedule.game_failed()
self.schedule.stop()
origin = self.schedule.disconnected_at
for attempt in range(3):
deadline = self.schedule.auto_relogin_deadline(self.config)
self.now = deadline - .001
self.assertIsNone(self.due())
self.now = deadline
self.assertEqual(self.due(), "auto_relogin")
self.now += 7 # Authentication consumes time before failing.
self.schedule.auto_relogin_failed()
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), self.now + delay)
self.assertEqual(self.schedule.disconnected_at, origin)
self.assertIsNone(self.due())
def test_retries_and_settings_changes_keep_original_outage(self):
self.schedule.disconnected()
origin = (self.schedule.disconnected_at, self.schedule.disconnected_wall_at)
self.now += 100
self.wall += 10000
self.schedule.game_failed(retry=True)
self.schedule.disconnected()
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), 1600)
self.assertEqual((self.schedule.disconnected_at, self.schedule.disconnected_wall_at), origin)
self.config["auto_relogin"]["delay_minutes"] = 30
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), 2800)
def test_password_login_due_outranks_read_probe_even_when_stopped(self):
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.schedule.disconnected()
self.schedule.game_failed(retry=True)
self.now += 600
self.assertEqual(self.due(), "auto_relogin")
self.config["auto_relogin"]["enabled"] = False
self.assertEqual(self.due(), "retry")
def test_read_probe_backoff_caps_at_sixty_seconds_and_resets_on_recovery(self):
for delay in (5, 10, 20, 40, 60, 60, 60):
self.assertEqual(self.schedule.game_failed(retry=True), delay)
self.assertTrue(self.schedule.monitoring)
self.assertIsNone(self.due(running=True))
self.now += delay - .001
self.assertIsNone(self.due(running=True))
self.now += .001
self.assertEqual(self.due(running=True), "retry")
self.schedule.game_resumed()
self.assertEqual(self.schedule.game_failed(retry=True), 5)
def test_stop_preserves_monitoring_outage_and_pending_probe(self):
self.schedule.disconnected()
self.schedule.game_failed(retry=True)
retry = self.schedule.retry_deadline
self.schedule.stop()
self.assertTrue(self.schedule.monitoring)
self.assertEqual(self.schedule.retry_deadline, retry)
self.assertEqual(self.schedule.disconnected_at, 1000)
self.now = retry
self.assertEqual(self.due(), "retry")
def test_recovery_rearms_poll_without_enabling_fast_strategies(self):
for deadline in (math.inf, self.now + 3600):
with self.subTest(deadline=deadline):
self.schedule.game_failed(retry=True)
self.schedule.next_poll = deadline
self.schedule.game_resumed()
self.assertFalse(self.schedule.game_paused)
self.assertIsNone(self.schedule.retry_deadline)
self.assertEqual(self.schedule.next_poll, self.now)
self.assertEqual(self.due(), "poll")
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
def test_ordinary_success_preserves_armed_monitor_deadline(self):
for deadline in (self.now - 30, self.now + 30):
with self.subTest(deadline=deadline):
self.schedule.next_poll = deadline
self.schedule.game_resumed()
self.assertEqual(self.schedule.next_poll, deadline)
def test_recovery_keeps_explicitly_disabled_monitor_disabled(self):
self.schedule.monitor(False)
self.schedule.game_failed(retry=True)
self.schedule.game_resumed()
self.assertFalse(self.schedule.monitoring)
self.assertEqual(self.schedule.next_poll, math.inf)
self.assertIsNone(self.due())
def test_success_can_preserve_failed_auth_origin_until_verified_recovery(self):
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.schedule.disconnected()
self.now += 600
self.schedule.auto_relogin_failed()
deadline = self.schedule.auto_relogin_deadline(self.config)
origin = (self.schedule.disconnected_at, self.schedule.disconnected_wall_at)
self.schedule.game_resumed(clear_disconnection=False)
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), deadline)
self.assertEqual((self.schedule.disconnected_at, self.schedule.disconnected_wall_at), origin)
self.assertEqual(self.schedule.auto_relogin_failed_at, self.now)
self.schedule.game_resumed()
self.assertIsNone(self.schedule.auto_relogin_deadline(self.config))
self.assertIsNone(self.schedule.auto_relogin_failed_at)
def test_continuously_due_maintenance_cannot_starve_snapshot_poll(self):
for kind in ("heartbeat", "reconcile", "master_sync", "growth_sync"):
with self.subTest(kind=kind):
self.setUp()
if kind == "heartbeat":
self.engine.last_heartbeat = 0
else:
predicate = {"reconcile": "pending_recovery_due", "master_sync": "master_sync_due",
"growth_sync": "growth_sync_due"}[kind]
setattr(self.engine, predicate, lambda: True)
self.assertEqual(self.due(), kind)
self.schedule.game_resumed(clear_disconnection=False)
self.assertEqual(self.due(), "poll")
self.schedule.poll_finished(self.config)
self.now += 30
self.assertEqual(self.due(), kind)
self.assertEqual(self.due(), "poll")
def test_continuously_due_hatch_cannot_starve_snapshot_poll(self):
self.schedule.next_fast["hatch"] = self.now
self.assertEqual(self.due(running=True), "hatch")
self.assertEqual(self.due(running=True), "poll")
def test_failed_poll_cools_down_even_when_random_interval_is_zero(self):
self.schedule.uniform = lambda low, high: 0
self.schedule.maintenance_failed("poll")
self.schedule.poll_finished(self.config)
self.assertIsNone(self.due())
self.now += 29.999
self.assertIsNone(self.due())
self.now += .001
self.assertEqual(self.due(), "poll")
def test_failed_fast_kind_cools_down_without_blocking_monitor(self):
for kind in FAST_KINDS:
with self.subTest(kind=kind):
self.setUp()
self.schedule.next_fast[kind] = self.now
self.schedule.maintenance_failed(kind)
self.assertEqual(self.due(running=True), "poll")
self.schedule.next_poll = math.inf
self.now += 29.999
self.assertIsNone(self.due(running=True))
self.now += .001
self.assertEqual(self.due(running=True), kind)
def test_paused_session_allows_no_maintenance_or_strategy_without_probe(self):
self.engine.last_heartbeat = 0
self.schedule.next_fast = dict.fromkeys(FAST_KINDS, self.now)
self.schedule.game_failed()
self.now += 10000
self.assertIsNone(self.due(running=True))
def test_paused_game_does_not_rearm_fast_tasks_from_durable_run_intent(self):
self.config["policy"] = {"enabled": True, "fill": True}
self.schedule.game_failed(retry=True)
self.schedule.arm(self.engine, self.config, True)
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
def test_recovery_keeps_all_uncertain_write_barriers(self):
unknown = {"phase": "unknown", "attempt_id": "offline-attempt"}
self.config["policy"] = {"enabled": True, "fill": True}
for kind in ("progression", "explore", "breakthrough"):
with self.subTest(kind=kind):
self.engine._progression_pending = lambda: unknown if kind == "progression" else None
self.engine.explore_planner.pending = lambda snapshot: unknown if kind == "explore" else None
self.engine._breakthrough_pending = unknown if kind == "breakthrough" else None
self.schedule.game_failed(retry=True)
self.schedule.game_resumed()
self.schedule.arm(self.engine, self.config, True)
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
self.assertEqual(unknown, {"phase": "unknown", "attempt_id": "offline-attempt"})
class SchedulerLoopRecoveryTests(unittest.TestCase):
def run_passes(self, workers, passes):
# Run the real loop synchronously. The fake event ends it after exact passes.
with patch("ranch_web.scheduler.threading.Thread"):
scheduler = Scheduler(workers)
scheduler.closed = Mock()
scheduler.closed.wait.side_effect = [False] * passes + [True]
with self.assertLogs("ranch_web.scheduler", level="ERROR"):
scheduler._run()
return scheduler
def test_one_broken_account_does_not_kill_other_account_or_next_pass(self):
first = SimpleNamespace(request_tick=Mock(side_effect=RuntimeError("offline queue error")))
second = SimpleNamespace(request_tick=Mock())
scheduler = self.run_passes(lambda: [first, second], 3)
self.assertEqual(first.request_tick.call_count, 3)
self.assertEqual(second.request_tick.call_count, 3)
self.assertEqual(scheduler.closed.wait.call_count, 4)
def test_registry_failure_recovers_on_next_pass(self):
first, second = SimpleNamespace(request_tick=Mock()), SimpleNamespace(request_tick=Mock())
workers = Mock(side_effect=[RuntimeError("offline registry error"), [first, second]])
self.run_passes(workers, 2)
first.request_tick.assert_called_once_with()
second.request_tick.assert_called_once_with()
def test_lazy_registry_failure_does_not_stop_future_passes(self):
worker = SimpleNamespace(request_tick=Mock())
def workers():
yield worker
raise RuntimeError("offline iterator error")
self.run_passes(workers, 2)
self.assertEqual(worker.request_tick.call_count, 2)
if __name__ == "__main__":
unittest.main()
+149 -9
View File
@@ -17,7 +17,7 @@ from requests.sessions import Session as HttpSession
from ranch_assistant.api import Client, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog
from ranch_assistant.model import Action, Catalog
from ranch_web.service import RevisionConflict, WebManager
from ranch_web.store import session_identity
@@ -162,7 +162,8 @@ class ServiceTests(unittest.TestCase):
restored = self.manager._worker(identifier).securestore.load(identity)
self.assertGreater(restored.reqid, before)
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(self.manager._worker(identifier).engine.auto)
self.assertFalse(self.manager._worker(identifier).engine.auto,
"Restoring a connection must not run selected writes inline")
def test_verified_login_starts_only_saved_selections_after_server_activation(self):
identifier = self.account(False)
@@ -180,7 +181,7 @@ class ServiceTests(unittest.TestCase):
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
self.assertEqual(worker.config, selected, "Login changed the user's strategy selections")
self.assertIn("已勾选", result["message"])
self.assertEqual(self.manager.logs(identifier)["entries"][-1]["message"], result["message"])
@@ -193,10 +194,13 @@ class ServiceTests(unittest.TestCase):
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
selected = deepcopy(worker.config)
# First activation migrates the login preference to keep-login. The
# strategy selections themselves must remain identical.
selected["auto_relogin"]["enabled"] = True
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
self.assertEqual(worker.config, selected)
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.engine.plans(), [])
@@ -210,8 +214,11 @@ class ServiceTests(unittest.TestCase):
for _, url, _ in FakeClient.calls[before:]))
self.enable(identifier)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Saving selections must not authorize writes inline")
self.assertTrue(worker.engine.daily_policy.enabled)
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
def test_restore_with_unknown_write_keeps_evidence_and_never_replays(self):
identifier = self.account(False)
@@ -230,6 +237,9 @@ class ServiceTests(unittest.TestCase):
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertIn("核对", result["message"])
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertFalse(self.manager.status(identifier)["manual_stop"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
worker.engine.last_heartbeat = worker.schedule.clock()
@@ -240,6 +250,9 @@ class ServiceTests(unittest.TestCase):
for _, url, _ in FakeClient.calls[before:]))
def test_activation_persistence_can_be_revoked_before_final_commit(self):
other = self.account(False)
self.login(other, account="independent-owner")
self.enable(other)
for operation in ("enter_server", "restore_session"):
for revoke in ("stop", "logout", "forget_login", "config"):
with self.subTest(operation=operation, revoke=revoke):
@@ -275,11 +288,16 @@ class ServiceTests(unittest.TestCase):
else:
followup = self.manager.submit(identifier, revoke)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(other)["running"], "Cancellation leaked to another account")
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertEqual(worker.running, revoke == "config",
"Only explicit Stop can persistently stop the still-online original role")
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(other)["running"])
self.assertFalse(self.manager.status(other)["manual_stop"])
self.assertEqual(self.manager.status(identifier)["manual_stop"], revoke == "stop")
if revoke in {"stop", "config"}:
self.assertIs(worker.engine.client, original_client)
else:
@@ -351,6 +369,28 @@ class ServiceTests(unittest.TestCase):
self.assertEqual(calls, ["refresh", "refresh"])
self.assertFalse(self.manager._worker(identifier).engine.auto)
self.assertTrue(self.manager._worker(identifier).engine._progression_cancel.is_set())
worker = self.manager._worker(identifier)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker._set_strategy_requested
def persist(requested):
if requested:
entered.set()
if not release.wait(5):
raise AssertionError("Start intent gate not released")
return original(requested)
with patch.object(worker, "_set_strategy_requested", side_effect=persist):
starting = self.manager.submit(identifier, "start")
self.assertTrue(entered.wait(2))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, starting, status="cancelled")
state = self.manager.status(identifier)
self.assertFalse(state["strategy_requested"], "A canceled Start overwrote the later durable Stop")
self.assertTrue(state["manual_stop"])
self.assertFalse(state["running"])
def test_policy_queued_before_stop_saves_without_reactivating(self):
identifier = self.account()
@@ -415,7 +455,13 @@ class ServiceTests(unittest.TestCase):
result = self.job(identifier, self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]}))
self.assertTrue(worker.engine.snapshot.monsters[monster["id"]]["lock"])
self.assertIn("message", result["result"])
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.running, "The manual helper persisted an implicit Stop")
self.assertEqual(sum(url.endswith("monsterService/monsterLock") for _, url, _ in FakeClient.calls), 1)
def test_enter_job_is_not_terminal_until_persistence_and_summary_are_published(self):
identifier = self.account(False)
@@ -574,10 +620,14 @@ class ServiceTests(unittest.TestCase):
release.set()
self.job(identifier, pending["job"])
self.assertTrue(self.manager.status(identifier)["running"], "Config cancellation disabled the execution switch")
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Config persistence must not authorize writes inline")
self.assertEqual(worker.engine.policy.keep_money, config["policy"]["keep_money"])
worker.engine.last_heartbeat = time.monotonic()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
def test_engine_pause_in_current_generation_still_disables_execution(self):
def test_engine_pause_keeps_request_and_blocks_unconfirmed_legacy_writes(self):
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
@@ -593,6 +643,96 @@ class ServiceTests(unittest.TestCase):
self.idle(identifier)
self.assertFalse(self.manager.status(identifier)["running"])
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
# These legacy paths disable Engine.auto after an unconfirmed result
# without creating a battle/exploration pending record. Restoring user
# intent must preserve a write barrier across reads and process restart.
for kind in ("gift", "hatch", "feed"):
with self.subTest(kind=kind):
identifier = self.account(False)
self.login(identifier, account="legacy-" + identifier)
worker = self.manager._worker(identifier)
identity = worker.active_identity
clock = [1000.0]
worker.schedule.clock = lambda: clock[0]
worker.engine.last_heartbeat = clock[0]
monsters = list(worker.engine.snapshot.monsters)
if kind == "gift":
# Engine overlays confirmed gift timestamps in seconds,
# while an unchanged raw server snapshot uses milliseconds.
mon = next(row for row in worker.engine.client.raw["monsters"] if row["id"] == monsters[0])
mon["giftTime"] = 1_700_000_000_000
worker.engine.gift_planner.confirmed[monsters[0]] = {
"owner": str(worker.engine.snapshot.raw["master"]["id"]),
"type": str(mon["typeId"]), "feel": int(mon.get("feel") or 0),
"giftTime": 1_700_000_060}
action = Action(kind, "Unconfirmed gift", "monsterService/monsterSendGift",
{"monsterId": monsters[0], "itemId": 1})
elif kind == "hatch":
slot = worker.engine.client.raw["stacks"][0]
slot["monsterId"] = -1
action = Action(kind, "Unconfirmed hatch", "stackService/stackAddMonster",
{"eggs": [{"itemId": 1, "stackId": slot["id"]}]})
worker.engine.pending_hatches = [action]
else:
action = Action(kind, "Unconfirmed feed", "monsterService/monsterIntensify",
{"targetId": monsters[0], "foods": [monsters[1]]})
before = len(FakeClient.calls)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.schedule.next_fast[kind] = 0
worker.schedule.next_poll = float("inf")
else:
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"), status="failed")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(state["running"])
self.job(identifier, self.manager.submit(identifier, "refresh"))
for _ in range(3):
clock[0] += 121
worker.engine.last_heartbeat = clock[0]
worker.schedule.next_poll = 0
tick = worker.enqueue("__tick")
self.idle(identifier)
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.job(identifier, tick["id"])["status"], "succeeded")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
unchanged = deepcopy(worker.engine.client.raw)
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
def restore(session, *, trace):
candidate = FakeClient(session, trace=trace)
candidate.raw = deepcopy(unchanged)
return candidate
worker._restore_factory = restore
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
worker = self.manager._worker(identifier)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.engine.pending_hatches = [action]
worker.schedule.next_fast[kind] = 0
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Restart discarded the unconfirmed legacy write barrier")
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertEqual(state["strategy_state"], "blocked")
def test_view_task_indices_stay_bounded_after_many_filters_and_failure(self):
identifier = self.account()
+7 -3
View File
@@ -43,6 +43,7 @@ class TaskLogTests(unittest.TestCase):
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
enable = fixtures.ServiceTests.enable
def tick(self, identifier, kind, *, status="succeeded"):
worker = self.manager._worker(identifier)
@@ -129,11 +130,14 @@ class TaskLogTests(unittest.TestCase):
self.assertEqual(self.entries(identifier, after)[0]["category"], "general")
def test_fast_and_auth_errors_keep_source_category_and_error_level(self):
identifier = self.account()
worker = self.manager._worker(identifier)
for kind, category in (("hatch", "hatching"), ("gift", "gifts"), ("explore", "exploration"), ("breakthrough", "ranch"), ("auto_relogin", "login")):
with self.subTest(kind=kind):
worker._running = True
# Each error owns a bounded retry deadline. Use independent
# enabled workers so one error cannot suppress the next case.
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
worker = self.manager._worker(identifier)
after = self.manager.logs(identifier)["next"]
with patch.object(worker.engine, "poll_automation", side_effect=ValueError("task failed")), \
patch.object(worker, "_auto_relogin_status", return_value={"state": "waiting"}), \
+18 -4
View File
@@ -432,7 +432,7 @@ class WebIntegrationTests(unittest.TestCase):
point = next(point for point in dto["chart"]["series"] if point["id"] == "item:30005")
self.assertAlmostEqual(point["value"], .2)
def test_dto_egg_edit_autosaves_into_real_engine_plan_and_restart_stays_stopped(self):
def test_dto_egg_edit_autosaves_and_restart_preserves_explicit_execution_request(self):
config, row = self.hatch_config()
column = next(column for column in self.view("bag")["columns"] if column["key"] == "enabled")
self.assertEqual([row["id"] if part == "{id}" else part for part in column["edit"]["path"]], row["rule_path"] + ["enabled"])
@@ -454,7 +454,10 @@ class WebIntegrationTests(unittest.TestCase):
self.app.state.manager = self.manager
self.wait_idle()
self.assertEqual(self.config(), applied)
self.assertFalse(self.manager.status(self.account)["running"])
state = self.manager.status(self.account)
self.assertTrue(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(self.manager._worker(self.account).engine.auto)
def test_same_species_config_and_catalog_overrides_are_independent_between_accounts(self):
@@ -541,7 +544,7 @@ class WebIntegrationTests(unittest.TestCase):
self.assertFalse(self.manager._worker(account).engine.auto)
self.assertEqual(client.writes, [])
def test_legacy_schema_one_import_is_a_job_and_never_starts_engine(self):
def test_legacy_schema_one_import_preserves_execution_request_without_inline_writes(self):
from ranch_assistant.model import Policy
from ranch_assistant.policy_io import portable_policy
@@ -555,10 +558,21 @@ class WebIntegrationTests(unittest.TestCase):
before = deepcopy(engine.snapshot.raw)
value = self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202)
self.job(value)
self.assertFalse(self.manager.status(self.account)["running"])
state = self.manager.status(self.account)
self.assertTrue(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(engine.auto)
self.assertEqual(engine.snapshot.raw, before)
self.assertTrue(self.config()["config"]["policy"]["egg_rules"][row["id"]]["enabled"])
self.action("stop")
self.job(self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202))
state = self.manager.status(self.account)
self.assertFalse(state["running"])
self.assertFalse(state["strategy_requested"])
self.assertTrue(state["manual_stop"])
self.assertFalse(engine.auto)
self.assertEqual(engine.snapshot.raw, before)
exported = self.job(self.response(self.http.get(self.path("config/export")), 202))["result"]
self.assertEqual(exported["schema"], 2)
self.assertEqual(exported["format"], "ranch-helper-policies")