feat: add configurable delayed password relogin

This commit is contained in:
AttilaNet
2026-11-11 11:48:52 +08:00
parent 4a1b06ee9d
commit 5b1ef25048
12 changed files with 1068 additions and 24 deletions
@@ -0,0 +1,325 @@
"""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
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.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))
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 never initiate game login or start strategies")
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 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_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 = '重新登录失败:密码错误 <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)
self.set_status(self.first, "monitoring", "重登成功,已恢复监控,策略保持停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=False)
expect(status).to_contain_text("已恢复监控,策略保持停止")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
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("服务重启")
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("秒后自动重新登录")
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()
+13 -1
View File
@@ -188,7 +188,9 @@ class ApiTests(unittest.TestCase):
def test_connection_metadata_survives_summary_dto(self):
metadata = {"connection_state": "retrying", "connection_message": "网络请求超时;策略已停止,正在只读重试",
"last_game_success_at": "2026-11-11T02:05:36.000+00:00", "next_retry_at": "2026-11-11T02:05:41.000+00:00"}
"last_game_success_at": "2026-11-11T02:05:36.000+00:00", "next_retry_at": "2026-11-11T02:05:41.000+00:00",
"auto_relogin_status": {"state": "waiting", "message": "等待重新登录原区服和角色",
"next_attempt_at": "2026-11-11T02:35:36.000+00:00"}}
self.manager.accounts[self.account_id].update(metadata)
for url in (self.url + "/status", "/api/accounts"):
response = self.client.get(url)
@@ -196,6 +198,16 @@ class ApiTests(unittest.TestCase):
summary = response.json()[0] if url == "/api/accounts" else response.json()
self.assertEqual({key: summary[key] for key in metadata}, metadata)
def test_auto_relogin_summary_only_exposes_three_public_fields(self):
self.manager.accounts[self.account_id]["auto_relogin_status"] = {
"state": "blocked", "message": "请先保存密码", "next_attempt_at": None,
"account": "must-stay-local", "password": "never-public", "savedSession": {"role_id": 999}}
for url in (self.url + "/status", "/api/accounts"):
response = self.client.get(url)
summary = response.json()[0] if url == "/api/accounts" else response.json()
self.assertEqual(summary["auto_relogin_status"], {
"state": "blocked", "message": "请先保存密码", "next_attempt_at": None})
def test_game_login_is_queued_and_credentials_stay_server_side(self):
response = self.client.post(self.url + "/actions/login", json={"account": "fake-account", "password": "GAME_PASSWORD", "remember": True})
self.assertEqual(response.status_code, 202)
+383
View File
@@ -0,0 +1,383 @@
"""Auto password login regressions; temporary stores, fake clocks, no live HTTP."""
from copy import deepcopy
from datetime import datetime
import json
import threading
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, SessionExpiredError
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
class AutoLogin(fixtures.FakeLogin):
calls = []
def authenticate(self, account, password):
self.trace.begin("离线渠道验证")
self.calls.append((account, password))
client, response, context = super().authenticate(account, password)
# Real official masterInfos carry both serverId and character id.
response["masterInfos"] = [{"serverId": sid, "id": 100 + sid} for sid in (1, 2)]
return client, response, context
class AutoReloginTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
def connected(self, *, remember=True, server=2, account=None):
self.manager.login_factory = AutoLogin
AutoLogin.calls = []
identifier = self.account(False)
account = account or "synthetic-owner-" + identifier[:8]
self.job(identifier, self.manager.submit(identifier, "login", {
"account": account, "password": "synthetic-password", "remember": remember}))
self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": server}))
worker = self.manager._worker(identifier)
self.now = 1000.0
worker.schedule.clock = lambda: self.now
self.configure(identifier)
return identifier, worker
def configure(self, identifier, *, enabled=True, delay=1):
value = self.manager.get_config(identifier)
value["config"]["auto_relogin"] = {"enabled": enabled, "delay_minutes": delay}
self.job(identifier, self.manager.set_config(identifier, value["config"], value["revision"])["job"])
def disconnect(self, identifier, worker, *, timeout=False):
error = requests.ReadTimeout("offline test") if timeout else SessionExpiredError("expired test", code=408)
with patch.object(worker.engine.client, "_post", side_effect=error), \
patch.object(worker.engine.client.http, "post", side_effect=error):
self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed")
def tick(self, identifier, worker, *, status="succeeded"):
return self.job(identifier, worker.enqueue("__tick"), status=status)
def auto_status(self, identifier):
return self.manager.status(identifier)["auto_relogin_status"]
def test_config_defaults_strict_types_and_limits(self):
self.assertEqual(validate_config({})["auto_relogin"], {"enabled": False, "delay_minutes": 30})
for field, values in (("enabled", [0, 1, "true", None]),
("delay_minutes", [True, False, 0, 10081, 1.5, "30", None])):
for value in values:
with self.subTest(field=field, value=value), self.assertRaises(ValueError):
validate_config({"auto_relogin": {field: value}})
for minutes in (1, 10080):
self.assertEqual(validate_config({"auto_relogin": {"delay_minutes": minutes}})
["auto_relogin"]["delay_minutes"], minutes)
with self.assertRaises(ValueError):
validate_config({"auto_relogin": {"password": "forbidden"}})
def test_first_expiry_deadline_survives_idle_refresh_and_duplicate_ticks(self):
identifier, worker = self.connected()
identity = worker.active_identity
self.disconnect(identifier, worker)
status = self.auto_status(identifier)
self.assertEqual(status["state"], "waiting")
datetime.fromisoformat(status["next_attempt_at"])
before = len(AutoLogin.calls)
self.now += 59
for _ in range(3):
self.tick(identifier, worker)
self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed")
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], status["next_attempt_at"])
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.engine.client.session.server_id, 2)
self.assertEqual(worker.engine.client.session.role_id, 102)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(worker.schedule.monitoring)
self.assertIsNone(self.auto_status(identifier)["next_attempt_at"])
for _ in range(3):
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_timeout_retries_do_not_postpone_password_login(self):
identifier, worker = self.connected()
self.disconnect(identifier, worker, timeout=True)
deadline = self.auto_status(identifier)["next_attempt_at"]
before = len(AutoLogin.calls)
for seconds in (5, 15, 35, 59):
self.now = 1000 + seconds
with patch.object(worker.engine.client.http, "post", side_effect=requests.Timeout("still offline")):
self.tick(identifier, worker, status="failed") if seconds != 59 else self.tick(identifier, worker)
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], deadline)
self.now = 1060
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_recovery_clears_outage_and_next_outage_gets_fresh_delay(self):
identifier, worker = self.connected()
self.disconnect(identifier, worker, timeout=True)
self.now += 5
self.tick(identifier, worker)
self.assertEqual(self.auto_status(identifier)["state"], "idle")
self.now += 100
self.disconnect(identifier, worker)
before = len(AutoLogin.calls)
self.now += 59
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_enabling_and_changing_delay_reuses_known_outage(self):
identifier, worker = self.connected()
self.configure(identifier, enabled=False, delay=5)
self.disconnect(identifier, worker)
self.now += 70
self.configure(identifier, delay=2)
first = self.auto_status(identifier)["next_attempt_at"]
self.configure(identifier, delay=1)
self.assertLess(self.auto_status(identifier)["next_attempt_at"], first)
before = len(AutoLogin.calls)
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_no_saved_password_blocks_without_token_fallback(self):
identifier, worker = self.connected(remember=False)
self.disconnect(identifier, worker)
status = self.auto_status(identifier)
self.assertEqual(status["state"], "blocked")
self.assertIn("密码", status["message"])
self.assertIsNone(status["next_attempt_at"])
before = len(AutoLogin.calls), len(fixtures.FakeClient.calls)
self.now += 100000
for _ in range(3):
self.tick(identifier, worker)
self.assertEqual((len(AutoLogin.calls), len(fixtures.FakeClient.calls)), before)
def test_credentials_mismatch_and_missing_target_never_authenticate(self):
for target in (False, True):
with self.subTest(target=target):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
if target:
worker.securestore.remove(worker.active_identity)
else:
worker.securestore.save_credentials("another-owner", "another-password", True)
self.now += 60
before = len(AutoLogin.calls)
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.assertEqual(self.auto_status(identifier)["state"], "blocked")
self.assertTrue(self.auto_status(identifier)["message"])
def test_official_server_role_and_uid_mismatches_rejected_before_enter(self):
for field in ("servers", "role", "uid", "account_name"):
with self.subTest(field=field):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
original = AutoLogin.authenticate
def wrong(flow, account, password):
client, response, context = original(flow, account, password)
if field == "servers":
response["servers"] = response["servers"][:1]
elif field == "role":
response["masterInfos"][-1]["id"] = 999
elif field == "uid":
client.session.account_id = context["uid"] = "other-uid"
else:
client.session.account_name = "other-account"
return client, response, context
self.now += 60
before = len(fixtures.FakeClient.calls)
with patch.object(AutoLogin, "authenticate", wrong):
self.tick(identifier, worker)
self.assertFalse(self.manager.status(identifier)["connected"])
self.assertFalse(any(url.endswith("userServerService/enterGame")
for _, url, _ in fixtures.FakeClient.calls[before:]))
self.assertEqual(self.auto_status(identifier)["state"], "failed")
def test_failure_waits_full_delay_instead_of_busy_loop(self):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
self.now += 60
with patch.object(AutoLogin, "authenticate", side_effect=ApiError("离线认证失败")) as auth:
self.tick(identifier, worker)
deadline = self.auto_status(identifier)["next_attempt_at"]
for seconds in (0, .2, 1, 59):
self.now = 1060 + seconds
self.tick(identifier, worker)
self.assertEqual(auth.call_count, 1)
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], deadline)
self.now = 1120
self.tick(identifier, worker)
self.assertEqual(auth.call_count, 2)
def test_login_preference_survives_first_enter_role_switch_and_logout(self):
identifier = self.account(False)
self.configure(identifier, delay=7)
self.login(identifier, server=1)
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"],
{"enabled": True, "delay_minutes": 7})
config = self.manager.get_config(identifier)["config"]
config["policy"]["keep_money"] = 4321
self.job(identifier, self.manager.set_config(identifier, config)["job"])
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)
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")
def test_portable_import_preserves_local_login_preference(self):
identifier, worker = self.connected()
portable = export_config(default_config(), worker.engine.snapshot)
self.job(identifier, self.manager.submit(identifier, "import_config", {"config": portable}))
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"],
{"enabled": True, "delay_minutes": 1})
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)
def test_restart_opt_in_waits_and_logout_disarms_restart(self):
identifier, worker = self.connected()
self.manager.close()
before = len(AutoLogin.calls)
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.clock()
worker.schedule.clock = lambda: origin + self.now - 1000
self.assertEqual(self.auto_status(identifier)["state"], "waiting")
self.now = 1059
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.now = 1060.1
self.tick(identifier, worker)
self.assertTrue(self.manager.status(identifier)["connected"])
self.job(identifier, self.manager.submit(identifier, "logout"))
self.manager.close()
before = len(AutoLogin.calls)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
self.now += 99999
worker.schedule.clock = lambda: self.now
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
def test_logout_forget_and_delay_change_revoke_inflight_auth_immediately(self):
for operation in ("logout", "forget_login", "disable", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = AutoLogin.authenticate
def paused(flow, account, password):
entered.set()
if not release.wait(5):
raise AssertionError("Auth gate not released")
return original(flow, account, password)
self.now += 60
before = len(AutoLogin.calls)
with patch.object(AutoLogin, "authenticate", paused):
tick = worker.enqueue("__tick")
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)
next_job = self.manager.set_config(identifier, config)["job"]
release.set()
self.job(identifier, tick, status="cancelled")
self.job(identifier, next_job)
self.assertEqual(len(AutoLogin.calls), before)
self.assertFalse(self.manager.status(identifier)["connected"])
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.disconnect(first, first_worker)
self.disconnect(second, second_worker)
self.now += 60
before = len(AutoLogin.calls)
self.tick(first, first_worker)
self.tick(second, second_worker)
self.assertEqual(AutoLogin.calls[before:], [("owner-one", "synthetic-password")])
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(self.manager.status(second)["connected"])
def test_stop_policy_and_delay_cancellation_back_off_even_after_transport_error(self):
for operation in ("stop", "policy", "delay"):
for transport_error in (False, True):
with self.subTest(operation=operation, transport_error=transport_error):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
attempts = []
original = AutoLogin.authenticate
def held(flow, account, password):
attempts.append(self.now)
entered.set()
if not release.wait(5):
raise AssertionError("Auth gate not released")
if transport_error:
raise requests.ReadTimeout("cancelled SDK eventually timed out")
return original(flow, account, password)
self.now = 1060
with patch.object(AutoLogin, "authenticate", held):
tick = worker.enqueue("__tick")
self.assertTrue(entered.wait(2))
self.assertTrue(worker._execution.consuming)
next_job = None
delay = 60
if operation == "stop":
self.manager.submit(identifier, "stop")
else:
config = self.manager.get_config(identifier)["config"]
if operation == "delay":
config["auto_relogin"]["delay_minutes"] = 2
delay = 120
else:
config["policy"]["keep_money"] += 1
next_job = self.manager.set_config(identifier, config)["job"]
# Backoff starts when the old authentication finishes,
# not when cancellation was requested.
self.now = 1070
release.set()
self.job(identifier, tick, status="cancelled")
if next_job:
self.job(identifier, next_job)
self.assertEqual(self.auto_status(identifier)["state"], "failed")
deadline = self.auto_status(identifier)["next_attempt_at"]
for seconds in (0, .2, delay - 1):
self.now = 1070 + seconds
self.tick(identifier, worker)
self.assertEqual(attempts, [1060])
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], deadline)
self.now = 1070 + delay
self.tick(identifier, worker)
self.assertEqual(attempts, [1060, 1070 + delay])
if __name__ == "__main__":
unittest.main()