"""Offline auto-relogin UI contract; only disposable demos and mocked DTOs. Run: python -m unittest ranch_web.tests.browser.test_auto_relogin_browser -v No game actions, private account directories, or private access files are used. """ from __future__ import annotations import copy from datetime import datetime, timedelta, timezone import json from types import SimpleNamespace import unittest from unittest.mock import patch from urllib.parse import urlsplit from ranch_assistant.model import Catalog from ranch_web.policies import default_config, export_config from ranch_web.views import build_view, schema from . import test_workbench_browser as fixtures if fixtures.AVAILABLE: from playwright.sync_api import expect class AutoReloginSchemaTests(unittest.TestCase): def test_login_schema_and_view_expose_native_controls_with_defaults(self): 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.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.assertEqual(values[("auto_relogin", "delay_minutes")], 30) @unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required") class AutoReloginBrowserTests(unittest.TestCase): @classmethod def setUpClass(cls): cls.http_guard = patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP is forbidden")) cls.http_guard.start() try: fixtures.WorkbenchBrowserTests.setUpClass.__func__(cls) except BaseException: cls.http_guard.stop() raise @classmethod def tearDownClass(cls): try: fixtures.WorkbenchBrowserTests.tearDownClass.__func__(cls) finally: cls.http_guard.stop() await_job = fixtures.WorkbenchBrowserTests.await_job open = fixtures.WorkbenchBrowserTests.open go = fixtures.WorkbenchBrowserTests.go fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill) def setUp(self): fixtures.WorkbenchBrowserTests.setUp(self) self.context.set_default_timeout(5000) self.external_requests, self.unexpected_actions, self.writes, self.actions = [], [], [], [] self.action_handlers = {} self.view_calls = 0 self.configs, self.summaries, self.login_data = {}, {}, {} engine = SimpleNamespace(catalog=Catalog(), snapshot=None, demo=False) for identifier in (self.first, self.second): self.configs[identifier] = copy.deepcopy(default_config()) 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} 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) def local_fixture(route): request = route.request if not request.url.startswith(self.base + "/"): self.external_requests.append(request.url) route.abort() return path = urlsplit(request.url).path if path == "/api/accounts": self.fulfill(route, list(self.summaries.values())) return for identifier in (self.first, self.second): prefix = f"/api/accounts/{identifier}" if path == prefix + "/status": self.fulfill(route, self.summaries[identifier]) return if path == prefix + "/config": if request.method == "PUT": body = copy.deepcopy(request.post_data_json) self.writes.append((identifier, body)) self.configs[identifier] = body["config"] self.summaries[identifier]["revision"] += 1 self.fulfill(route, {"config": self.configs[identifier], "revision": self.summaries[identifier]["revision"]}) return if path == prefix + "/views/login": self.view_calls += 1 self.fulfill(route, {"loading": False, "data": self.login_data[identifier], "revision": self.summaries[identifier]["revision"]}) return if path.startswith(prefix + "/actions/"): operation = path.rsplit("/", 1)[-1] self.actions.append((identifier, operation, request.post_data_json)) handler = self.action_handlers.get((identifier, operation)) if handler: self.fulfill(route, handler(request.post_data_json)) return if operation != "logout": self.unexpected_actions.append(operation) route.abort() return self.summaries[identifier].update(connected=False, running=False, connection_state="offline") self.set_status(identifier, "cancelled", "手动退出登录,已取消本次自动重登") self.fulfill(route, {"id": "mock-logout", "operation": operation, "status": "succeeded", "result": {"message": "已退出登录并取消自动重登"}}) return if request.method in ("POST", "PUT", "DELETE", "PATCH"): self.unexpected_actions.append(path) route.abort() else: route.continue_() self.context.route("**/*", local_fixture) def tearDown(self): try: self.assertEqual(self.external_requests, []) self.assertEqual(self.unexpected_actions, [], "UI must only submit explicitly requested fixture actions") self.assertEqual(self.errors, []) finally: fixtures.WorkbenchBrowserTests.tearDown(self) def set_status(self, identifier, state, message, next_attempt_at=None): self.summaries[identifier]["auto_relogin_status"] = { "state": state, "message": message, "next_attempt_at": next_attempt_at} def waiting(self, identifier=None, *, seconds=45, message="掉线后等待自动重登"): identifier = identifier or self.first self.configs[identifier]["auto_relogin"]["enabled"] = True 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 saved(self, identifier, enabled, minutes): self.page.wait_for_function("() => document.querySelector('#save-status').textContent === '策略已自动保存'") self.assertEqual(self.configs[identifier]["auto_relogin"], {"enabled": enabled, "delay_minutes": minutes}) def complete_login(self, operation, *, running=True): self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", error="", running=running) 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() 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 ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启"): 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)")) 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() self.assertEqual(self.writes, []) self.assertEqual(self.actions, []) def test_server_candidates_wait_for_role_then_run_only_selected_features_and_allow_stop(self): self.configs[self.first]["daily_policy"].update(enabled=True, selected=["gift"]) original = copy.deepcopy(self.configs[self.first]) candidates = {"servers": [{"id": 7, "name": "离线测试区", "role_name": "离线角色"}]} def login(payload): self.login_data[self.first].update(candidates) return {"id": "mock-login", "operation": "login", "status": "succeeded", "result": candidates} def stop(payload): self.summaries[self.first]["running"] = False return {"id": "mock-stop", "operation": "stop", "status": "succeeded", "result": {"message": "策略已停止"}} self.action_handlers.update({(self.first, "login"): login, (self.first, "enter_server"): lambda payload: self.complete_login("enter_server"), (self.first, "stop"): stop}) self.open() panel = self.go("login") panel.get_by_label("游戏账号", exact=True).fill("offline-role-test") panel.get_by_label("游戏密码", exact=True).fill("synthetic-password") panel.get_by_role("button", name="账号密码登录 / 获取区服", exact=True).click() expect(panel.get_by_label("区服 / 角色", exact=True)).to_contain_text("离线测试区") expect(self.page.locator("#connection")).to_have_text("游戏离线") toggle = self.page.locator("#strategy-toggle") expect(toggle).to_have_text("开启") expect(toggle).to_be_disabled() expect(self.page.locator("#notice")).to_be_hidden() self.assertFalse(self.summaries[self.first]["running"]) panel.get_by_role("button", name="进入选中区服", exact=True).click() expect(toggle).to_have_text("停止") expect(toggle).to_have_attribute("aria-pressed", "true") expect(self.page.locator("#notice")).to_contain_text("已自动开启策略") expect(self.page.locator("#status-text")).to_contain_text("已配置且已勾选的功能") expect(self.page.locator("#data-summary")).to_contain_text("顶部“停止”") expect(self.page.locator("#page-tabs [role=tab]")).to_have_count(15) self.assertEqual(self.configs[self.first], original, "Logging in must preserve every feature selection") toggle.click() expect(toggle).to_have_text("开启") expect(self.page.locator("#data-summary")).to_contain_text("策略已停止") self.assertEqual([operation for _, operation, _ in self.actions], ["login", "enter_server", "stop"]) self.assertEqual(self.actions[1][2], {"server_id": "7"}) self.assertEqual(self.configs[self.first], original) self.assertEqual(self.writes, []) def test_import_stays_stopped_and_next_restored_session_runs_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") def import_config(route): imports.append(route.request.post_data_json) self.configs[self.first] = copy.deepcopy(imported) self.summaries[self.first]["running"] = False self.summaries[self.first]["revision"] += 1 self.fulfill(route, {"id": "mock-import", "operation": "import_config", "status": "succeeded", "result": {}}) self.page.route(f"**/api/accounts/{self.first}/config/import", import_config) self.open() panel = self.go("login") self.page.locator('.menu > summary').nth(2).click() with self.page.expect_file_chooser() as chooser: 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("下次成功登录会自动执行已勾选功能") self.page.locator("#dialog-confirm").click() 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("已自动开启策略") 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, []) def test_failed_candidates_and_disconnected_success_jobs_never_report_login_success(self): self.login_data[self.first].update(servers=[{"id": 7, "name": "候选区服"}], saved_sessions=[{"id": "offline-session", "label": "候选角色"}]) for operation, label in (("enter_server", "进入选中区服"), ("restore_session", "恢复选中会话(无需重新输密码)")): for job_status in ("failed", "succeeded"): with self.subTest(operation=operation, job_status=job_status): self.action_handlers[(self.first, operation)] = lambda payload, op=operation, status=job_status: { "id": "mock-candidate", "operation": op, "status": status, "error": "候选角色验证失败", "result": {"message": "候选声称登录成功"}} self.open() panel = self.go("login") self.page.evaluate("""() => { window.loginFeedback = []; new MutationObserver(() => { for (const id of ['status-text', 'notice']) { const node = document.getElementById(id); if (node && !node.hidden) window.loginFeedback.push(node.textContent); } }).observe(document.body, {subtree:true, childList:true, characterData:true, attributes:true, attributeFilter:['hidden']}); }""") panel.get_by_role("button", name=label, exact=True).click() expect(self.page.locator("#notice.error")).to_be_visible() expect(self.page.locator("#notice")).to_contain_text("候选角色验证失败" if job_status == "failed" else "尚未连接游戏") expect(self.page.locator("#connection")).to_have_text("游戏离线") expect(self.page.locator("#strategy-toggle")).to_be_disabled() feedback = "\n".join(self.page.evaluate("window.loginFeedback")) for false_success in ("已完成", "已读取角色", "已自动开启策略", "候选声称登录成功"): self.assertNotIn(false_success, feedback) self.assertNotIn("start", [operation for _, operation, _ in self.actions]) self.assertEqual(self.writes, []) def test_stop_after_restore_is_shown_from_confirmed_server_status(self): 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", running=False) self.open() panel = self.go("login") panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click() expect(self.page.locator("#connection")).to_have_text("已登录") expect(self.page.locator("#notice")).to_contain_text("策略已停止") expect(self.page.locator("#notice")).not_to_contain_text("已自动开启") expect(self.page.locator("#data-summary")).to_contain_text("策略已停止") expect(self.page.locator("#strategy-toggle")).to_have_text("开启") self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})]) 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.fill("47") original = delay.element_handle() before = self.view_calls self.page.wait_for_timeout(5200) self.saved(self.first, True, 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", ""): count = len(self.writes) delay.fill(invalid) self.page.wait_for_timeout(650) expect(delay).to_have_value(invalid) self.assertEqual(len(self.writes), count, "Invalid or partial minutes must stay local") 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, 10080) self.assertEqual(self.actions, []) def test_missing_remembered_password_hint_never_sends_password_or_changes_remember(self): self.login_data[self.first]["has_saved_password"] = False self.summaries[self.first].pop("auto_relogin_status") self.open() panel = self.go("login") 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() 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) expect(remember).not_to_be_checked() self.assertTrue(self.writes) payloads = json.dumps(self.writes, ensure_ascii=False) self.assertNotIn("mock-secret-never-send", payloads) self.assertNotIn('"password"', payloads) self.assertNotIn('"remember"', payloads) self.assertEqual(self.actions, []) self.login_data[self.first]["has_saved_password"] = True expect(hint).to_be_hidden(timeout=7000) def test_account_switch_isolates_pending_edits_status_and_minutes(self): self.waiting(message="账号一正在等待自动重登") self.set_status(self.second, "disabled", "账号二未开启自动重登") self.open() panel = self.go("login") _, delay = self.controls(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() expect(second_delay).to_have_value("30") 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.page.locator(f'.account-tab[data-account="{self.first}"]').click() panel = self.go("login") expect(self.controls(panel)[1]).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, []) def test_expired_countdown_login_failure_and_recovered_monitoring_are_status_only(self): self.waiting() self.summaries[self.first]["connection_state"] = "expired" self.open() panel = self.go("login") status = panel.locator("[data-auto-relogin-status]") countdown = panel.locator("[data-auto-relogin-countdown]") 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.focus() original = delay.element_handle() before = countdown.inner_text() self.page.wait_for_timeout(2100) self.assertNotEqual(countdown.inner_text(), before) self.assertTrue(delay.evaluate("(node, original) => node === original && node === document.activeElement", original)) self.set_status(self.first, "waiting", "等待服务端执行", "2000-01-01T00:00:00Z") expect(countdown).to_contain_text("等待服务端执行自动重登") self.set_status(self.first, "logging_in", "正在重新登录原区服角色") expect(status).to_contain_text("正在重新登录原区服角色") expect(countdown).to_be_hidden() reason = '重新登录失败:密码错误 ' 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() 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) expect(status).to_contain_text("已恢复监控并自动执行已勾选功能") expect(self.page.locator("#strategy-toggle")).to_have_text("停止") expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行已配置且已勾选的功能") self.assertEqual(self.configs[self.first], original) self.assertEqual(self.actions, []) def test_restart_wait_persists_across_reload_and_closing_page_has_no_actions(self): target = self.waiting(message="服务重启,等待设定时长后回到原区服角色") 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() 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(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() 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): self.waiting() 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() self.assertEqual(self.actions, [(self.first, "logout", {})]) if __name__ == "__main__": unittest.main()