Files
myrzx_bot/ranch_web/tests/test_auto_relogin.py
T

540 lines
28 KiB
Python

"""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_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
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
enable = fixtures.ServiceTests.enable
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()
self.enable(identifier)
selected = deepcopy(worker.config)
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
result = self.tick(identifier, worker)["result"]
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.assertTrue(self.manager.status(identifier)["running"])
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)
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.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)
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_changing_delay_reuses_known_outage(self):
identifier, worker = self.connected()
self.configure(identifier, 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(worker.running)
self.assertFalse(worker.engine.auto)
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)
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(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()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
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)
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_reconnects_after_thirty_minutes_and_preserves_explicit_stop(self):
identifier, worker = self.connected()
self.enable(identifier)
self.configure(identifier, delay=30)
self.manager.submit(identifier, "stop")
selected = deepcopy(worker.config)
self.manager.close()
before = len(AutoLogin.calls), len(fixtures.FakeClient.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.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertIsNone(worker.engine.client)
self.assertEqual((len(AutoLogin.calls), len(fixtures.FakeClient.calls)), before)
origin = worker.schedule.disconnected_at
worker.schedule.clock = lambda: self.now
self.now = origin + 1799
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertEqual(len(AutoLogin.calls), before[0])
self.now = origin + 1800
result = self.tick(identifier, worker)["result"]
self.assertTrue(result["connected"])
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", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.enable(identifier)
self.disconnect(identifier, worker)
original_client = worker.engine.client
identity = worker.active_identity
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.securestore.set_active
def held(active):
if active == identity and not release.is_set():
entered.set()
if not release.wait(5):
raise AssertionError("Relogin activation gate not released")
return original(active)
self.now += 60
before = self.manager.logs(identifier)["next"]
with patch.object(worker.securestore, "set_active", side_effect=held):
candidate = worker.enqueue("__tick")
self.assertTrue(entered.wait(2))
if operation in {"stop", "logout", "forget_login"}:
followup = self.manager.submit(identifier, operation)
else:
config = self.manager.get_config(identifier)["config"]
if operation == "policy":
config["daily_policy"]["enabled"] = False
else:
config["auto_relogin"].update(enabled=operation != "disable", delay_minutes=2)
followup = self.manager.set_config(identifier, config)["job"]
self.assertFalse(worker.running)
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
if operation in {"logout", "forget_login"}:
self.assertIsNone(worker.engine.client)
else:
self.assertIs(worker.engine.client, original_client)
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_restart_waits_and_logout_retains_keep_login_across_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 = worker.schedule.disconnected_at + 60
worker.schedule.clock = lambda: self.now
self.tick(identifier, worker)
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", "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)
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"])
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.enable(first)
self.enable(second)
self.configure(second, delay=2)
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"])
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"):
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()