"""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 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.assertTrue(worker.engine.auto) 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.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(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) 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() 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) self.assertFalse(worker.running) self.assertFalse(worker.engine.auto) def test_restart_opt_in_activates_after_thirty_minutes_and_supersedes_old_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.assertTrue(result["running"]) self.assertTrue(worker.running) self.assertTrue(worker.engine.auto) self.assertEqual(worker.config, selected) self.assertEqual(len(AutoLogin.calls), before[0] + 1) def test_final_activation_revocation_never_starts_relogin_candidate(self): for operation in ("stop", "logout", "forget_login", "policy", "disable", "delay"): 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_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()