474 lines
28 KiB
Python
474 lines
28 KiB
Python
"""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}
|
|
delay = fields[("auto_relogin", "delay_minutes")]
|
|
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.assertNotIn(("auto_relogin", "enabled"), values)
|
|
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,
|
|
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)
|
|
|
|
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.waiting(identifier, message="退出登录后仍按设定时长自动重登",
|
|
requested=self.summaries[identifier]["strategy_requested"])
|
|
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="掉线后等待自动重登", requested=True):
|
|
identifier = identifier or self.first
|
|
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 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 === '策略已自动保存'")
|
|
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,
|
|
strategy_requested=running, strategy_state="running" if running else "stopped")
|
|
return {"id": "mock-" + operation, "operation": operation, "status": "succeeded", "result": {}}
|
|
|
|
def test_defaults_visible_controls_and_existing_layout(self):
|
|
self.open()
|
|
panel = self.go("login")
|
|
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)
|
|
expect(panel.get_by_label("游戏账号", exact=True)).to_have_value("offline-fixture")
|
|
expect(panel.get_by_label("游戏密码", exact=True)).to_be_visible()
|
|
expect(panel.get_by_role("checkbox", name="记住账号和密码", exact=True)).to_be_checked()
|
|
expect(panel.get_by_label("区服 / 角色", exact=True)).to_be_visible()
|
|
expect(panel.get_by_role("button", name="进入选中区服", exact=True)).to_be_disabled()
|
|
expect(panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True)).to_be_disabled()
|
|
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("尚未保存登录角色")
|
|
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(delay).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].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,
|
|
(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_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", running=False)
|
|
|
|
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")
|
|
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, 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", ""):
|
|
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, False, valid)
|
|
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")
|
|
self.delay_control(panel).fill("10")
|
|
hint = panel.locator("[data-auto-relogin-credentials]")
|
|
expect(hint).to_be_visible()
|
|
expect(hint).to_have_text("未保存账号或密码,自动重登不可用。")
|
|
self.page.wait_for_timeout(1000)
|
|
self.saved(self.first, False, 10)
|
|
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, "missing_identity", "账号二尚未保存登录角色")
|
|
self.open()
|
|
panel = self.go("login")
|
|
delay = self.delay_control(panel)
|
|
delay.fill("17")
|
|
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
|
|
panel = self.go("login")
|
|
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).not_to_contain_text("账号一正在等待")
|
|
second_delay.fill("9")
|
|
self.page.wait_for_timeout(1000)
|
|
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.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, [])
|
|
|
|
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("北京时间")
|
|
delay = self.delay_control(panel)
|
|
expect(delay).to_be_enabled()
|
|
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 = '重新登录失败:密码错误 <img src=x onerror="alert(1)">'
|
|
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_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, 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("正在自动执行")
|
|
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_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.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_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_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_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__":
|
|
unittest.main()
|