"""Account lifecycle/concurrency with temporary state and offline HTTP fakes.""" from copy import deepcopy from dataclasses import replace import json from pathlib import Path import subprocess import sys import tempfile import threading import time from types import SimpleNamespace import unittest from unittest.mock import patch from requests import Response from requests.sessions import Session as HttpSession from ranch_assistant.api import Client, Session, decode, encode from ranch_assistant.engine import Engine, demo_snapshot from ranch_assistant.model import Catalog from ranch_web.service import RevisionConflict, WebManager from ranch_web.store import session_identity class FakeClient(Client): catalog = Catalog() calls = [] def __init__(self, session, trace=None): super().__init__(session, trace=trace) self.raw = deepcopy(demo_snapshot(self.catalog).raw) role = session.role_id or 100 + (session.server_id or 1) self.raw["master"].update(id=role, roleName="离线角色 " + str(role), level=1, exp=0, timeTi=int(time.time() * 1000)) for monster in self.raw["monsters"]: monster.update(process=3, mode=2) self.http.post = self._post self.closed = False def _post(self, url, data, **kwargs): payload = decode(data, self.session.key) self.calls.append((self.session.account_id, url, payload)) if url.endswith("masterService/masterQueryDetail"): role = self.session.role_id or 100 + self.session.server_id self.raw["master"].update(id=role, roleName="离线角色 " + str(role)) if url.endswith("monsterService/monsterLock"): for monster in self.raw["monsters"]: if monster["id"] == payload["monsterId"]: monster["lock"] = payload["lock"] return SimpleNamespace(status_code=200, content=encode(self.raw | {"resCode": 0}, self.session.key), headers={}) def close(self): self.closed = True super().close() class FakeLogin: client_factory = FakeClient def __init__(self, catalog, device, *, trace=None): self.catalog, self.device, self.trace = catalog, device, trace def authenticate(self, account, password): client = FakeClient(Session(token="synthetic-center-token", account_id=account, account_name=account), trace=self.trace) response = {"servers": [{"id": identifier, "serverName": "测试区 " + str(identifier), "gameServerAddress": "https://offline.invalid/game/", "platform": "ANDROID"} for identifier in (1, 2)], "masterInfos": [{"serverId": 1, "masterName": "离线角色 101"}], "playerInfo": {"token": "synthetic-center-token"}} return client, response, {"uid": account, "center_url": "https://offline.invalid/center/", "channel": "DYD", "device_id": self.device} class ServiceTests(unittest.TestCase): def setUp(self): self.temp = self.enterContext(tempfile.TemporaryDirectory(prefix="ranch-web-runtime-test-")) self.root = Path(self.temp) / "web" # Any unmocked requests call is an immediate test failure, never traffic. self._http_request = HttpSession.request self.enterContext(patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP is forbidden"))) FakeClient.calls = [] self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin) self.addCleanup(self.manager.close) def account(self, demo=True): identifier = self.manager.create_account("测试页签", demo)["id"] self.idle(identifier) self.assertEqual(self.manager.status(identifier)["error"], "") return identifier def idle(self, identifier, timeout=10): deadline = time.monotonic() + timeout while time.monotonic() < deadline: if not self.manager.status(identifier)["busy"]: return time.sleep(.005) self.fail("Account did not become idle") def job(self, identifier, job, *, status="succeeded"): deadline = time.monotonic() + 10 while time.monotonic() < deadline: result = self.manager.job(identifier, job["id"]) if result["status"] in {"succeeded", "failed", "cancelled"}: self.assertEqual(result["status"], status, result) self.idle(identifier) return result time.sleep(.005) self.fail("Job did not complete") def login(self, identifier, account="synthetic-owner", server=1): login = self.job(identifier, self.manager.submit(identifier, "login", {"account": account, "password": "synthetic-password", "remember": True})) self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": server})) return login def enable(self, identifier): config = self.manager.get_config(identifier) config["config"]["daily_policy"].update(enabled=True, selected=["gift"]) pending = self.manager.set_config(identifier, config["config"], config["revision"]) self.assertTrue(pending["pending"]) self.job(identifier, pending["job"]) def test_real_engine_demo_config_autosave_and_revision_conflict(self): identifier = self.account() self.assertIsInstance(self.manager._worker(identifier).engine, Engine) self.assertEqual(self.manager.status(identifier)["player"]["name"], demo_snapshot(self.manager.catalog).raw["master"]["roleName"]) config = self.manager.get_config(identifier) config["config"]["policy"]["keep_money"] = 2345 result = self.manager.set_config(identifier, config["config"], config["revision"]) self.assertEqual(result["revision"], 0) self.job(identifier, result["job"]) self.assertEqual(self.manager.get_config(identifier)["config"]["policy"]["keep_money"], 2345) self.assertEqual(self.manager._worker(identifier).engine.policy.keep_money, 2345) with self.assertRaises(RevisionConflict): self.manager.set_config(identifier, config["config"], 0) def test_login_select_server_public_metadata_and_restart_restore(self): identifier = self.account(False) result = self.login(identifier) public = json.dumps(result) for secret in ("synthetic-password", "synthetic-center-token", "gameServerAddress", "center_url", "reqid"): self.assertNotIn(secret, public) self.assertEqual(result["result"]["servers"][0]["role_name"], "离线角色 101") status = self.manager.status(identifier) self.assertTrue(status["connected"]) self.assertFalse(status["demo"]) self.assertTrue(status["running"]) worker = self.manager._worker(identifier) identity = worker.active_identity before = worker.securestore.load(identity).reqid self.enable(identifier) self.job(identifier, self.manager.submit(identifier, "start")) self.manager.close() count = len(FakeClient.calls) self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin) self.addCleanup(self.manager.close) self.idle(identifier) self.assertEqual(len(FakeClient.calls), count, "Restart issued an unsolicited request") self.assertFalse(self.manager.status(identifier)["running"]) self.assertFalse(self.manager.status(identifier)["connected"]) self.assertTrue(self.manager.get_config(identifier)["config"]["daily_policy"]["enabled"]) self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity})) restored = self.manager._worker(identifier).securestore.load(identity) self.assertGreater(restored.reqid, before) self.assertTrue(self.manager.status(identifier)["running"]) self.assertTrue(self.manager._worker(identifier).engine.auto) def test_verified_login_starts_only_saved_selections_after_server_activation(self): identifier = self.account(False) self.login(identifier) self.enable(identifier) selected = deepcopy(self.manager.get_config(identifier)["config"]) self.job(identifier, self.manager.submit(identifier, "logout")) before = len(FakeClient.calls) self.job(identifier, self.manager.submit(identifier, "login", { "account": "synthetic-owner", "password": "synthetic-password"})) worker = self.manager._worker(identifier) self.assertFalse(worker.running, "SDK server discovery activated strategies") self.assertFalse(worker.engine.auto) self.assertIsNone(worker.engine.client) result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"] self.assertTrue(result["connected"]) self.assertTrue(result["running"]) self.assertTrue(worker.engine.auto) self.assertEqual(worker.config, selected, "Login changed the user's strategy selections") self.assertIn("已勾选", result["message"]) self.assertEqual(self.manager.logs(identifier)["entries"][-1]["message"], result["message"]) self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in FakeClient.calls[before:]], [["userServerService", "enterGame"], ["masterService", "masterQueryDetail"]]) def test_login_without_selected_rules_stays_enabled_and_later_selections_take_effect(self): identifier = self.account(False) self.job(identifier, self.manager.submit(identifier, "login", { "account": "synthetic-owner", "password": "synthetic-password"})) worker = self.manager._worker(identifier) selected = deepcopy(worker.config) result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"] self.assertTrue(result["connected"]) self.assertTrue(result["running"]) self.assertTrue(worker.engine.auto) self.assertEqual(worker.config, selected) self.assertIn("已勾选", result["message"]) self.assertEqual(worker.engine.plans(), []) before = len(FakeClient.calls) worker.engine.last_heartbeat = worker.schedule.clock() worker.schedule.next_poll = 0 self.job(identifier, worker.enqueue("__tick")) self.assertTrue(worker.running) self.assertTrue(worker.engine.auto) self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in FakeClient.calls[before:])) self.enable(identifier) self.assertTrue(worker.running) self.assertTrue(worker.engine.auto) self.assertTrue(worker.engine.daily_policy.enabled) def test_restore_with_unknown_write_keeps_evidence_and_never_replays(self): identifier = self.account(False) self.login(identifier) self.enable(identifier) worker = self.manager._worker(identifier) journal = worker.engine.battle_journal pending = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "未确认战斗", "path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"}) journal.update(pending, "unknown", message="已有未确认请求,禁止重发") evidence = journal.path.read_bytes() before = len(FakeClient.calls) result = self.job(identifier, self.manager.submit(identifier, "restore_session", { "session_id": worker.active_identity}))["result"] self.assertTrue(result["connected"]) self.assertFalse(result["running"]) self.assertFalse(worker.engine.auto) self.assertIn("核对", result["message"]) self.assertEqual(journal.path.read_bytes(), evidence) self.job(identifier, self.manager.submit(identifier, "start"), status="failed") worker.engine.last_heartbeat = worker.schedule.clock() self.job(identifier, worker.enqueue("__tick")) self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"]) self.assertEqual(journal.path.read_bytes(), evidence) self.assertTrue(all(url.endswith(("masterService/masterQueryDetail", "heartBeatService/keepAlive")) for _, url, _ in FakeClient.calls[before:])) def test_activation_persistence_can_be_revoked_before_final_commit(self): for operation in ("enter_server", "restore_session"): for revoke in ("stop", "logout", "forget_login", "config"): with self.subTest(operation=operation, revoke=revoke): identifier = self.account(False) self.login(identifier, account="owner-" + identifier) self.enable(identifier) worker = self.manager._worker(identifier) original_client = worker.engine.client identity = worker.active_identity if operation == "enter_server": self.job(identifier, self.manager.submit(identifier, "login", { "account": "owner-" + identifier, "password": "synthetic-password"})) 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("Activation gate not released") return original(active) payload = {"server_id": 1} if operation == "enter_server" else {"session_id": identity} before = self.manager.logs(identifier)["next"] with patch.object(worker.securestore, "set_active", side_effect=held): candidate = self.manager.submit(identifier, operation, payload) self.assertTrue(entered.wait(2)) if revoke == "config": config = self.manager.get_config(identifier)["config"] config["daily_policy"]["enabled"] = False followup = self.manager.set_config(identifier, config)["job"] else: followup = self.manager.submit(identifier, revoke) 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 revoke in {"stop", "config"}: self.assertIs(worker.engine.client, original_client) else: self.assertIsNone(worker.engine.client) self.assertFalse(any("已自动开启" in row["message"] for row in self.manager.logs(identifier, after=before)["entries"])) def test_role_workspaces_do_not_copy_targets_or_other_profiles_overrides(self): first, other = self.account(False), self.account() self.login(first) worker = self.manager._worker(first) role_one = worker.state_root config = self.manager.get_config(first) config["config"]["policy"]["keep_money"] = 9876 config["config"]["overrides"] = {next(iter(worker.catalog.monsters)): {"sell_money": 123}} self.job(first, self.manager.set_config(first, config["config"])["job"]) self.assertEqual(self.manager._worker(other).catalog.overrides, {}) self.manager.view(first, "incubator") self.idle(first) self.assertIsNotNone(self.manager.view(first, "incubator")["data"]) self.login(first, server=2) self.assertNotEqual(worker.state_root, role_one) self.assertIsNone(self.manager.view(first, "incubator")["data"], "Previous role view escaped the cache") self.idle(first) self.assertNotEqual(self.manager.get_config(first)["config"]["policy"]["keep_money"], 9876) self.assertEqual(worker.catalog.overrides, {}) saved = next(row["session_id"] for row in worker.securestore.entries() if row["session_id"] != worker.active_identity) self.job(first, self.manager.submit(first, "restore_session", {"session_id": saved})) self.assertEqual(worker.state_root, role_one) self.assertEqual(self.manager.get_config(first)["config"]["policy"]["keep_money"], 9876) def test_duplicate_account_server_role_connection_is_refused(self): first, second = self.account(False), self.account(False) self.login(first) self.job(second, self.manager.submit(second, "login", {"account": "synthetic-owner", "password": "synthetic-password"})) result = self.job(second, self.manager.submit(second, "enter_server", {"server_id": 1}), status="failed") self.assertIn("另一个", result["error"]) self.assertTrue(self.manager.status(first)["connected"]) self.assertFalse(self.manager.status(second)["connected"]) def test_stop_cancels_queued_start_and_consumer_but_not_read_only_jobs(self): identifier = self.account() self.enable(identifier) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) calls = [] def action(worker, operation, payload): calls.append(operation) if payload.get("hold"): entered.set() release.wait(5) return {"message": operation} with patch("ranch_web.actions.execute_action", side_effect=action): held = self.manager.submit(identifier, "refresh", {"hold": True}) self.assertTrue(entered.wait(2)) start = self.manager.submit(identifier, "start") consumer = self.manager.submit(identifier, "consume_probe") reader = self.manager.submit(identifier, "refresh") stopped = self.manager.submit(identifier, "stop") self.assertEqual(stopped["status"], "succeeded") self.assertFalse(self.manager.status(identifier)["running"]) release.set() self.job(identifier, held) self.job(identifier, start, status="cancelled") self.job(identifier, consumer, status="cancelled") self.job(identifier, reader) self.assertEqual(calls, ["refresh", "refresh"]) self.assertFalse(self.manager._worker(identifier).engine.auto) self.assertTrue(self.manager._worker(identifier).engine._progression_cancel.is_set()) def test_policy_queued_before_stop_saves_without_reactivating(self): identifier = self.account() self.enable(identifier) self.job(identifier, self.manager.submit(identifier, "start")) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) def hold(worker, operation, payload): entered.set() release.wait(5) return {} with patch("ranch_web.actions.execute_action", side_effect=hold): held = self.manager.submit(identifier, "refresh") self.assertTrue(entered.wait(2)) config = self.manager.get_config(identifier)["config"] config["policy"]["keep_money"] = 4567 pending = self.manager.set_config(identifier, config) self.manager.submit(identifier, "stop") release.set() self.job(identifier, held) self.job(identifier, pending["job"]) worker = self.manager._worker(identifier) self.assertEqual(worker.engine.policy.keep_money, 4567) self.assertFalse(worker.engine.auto) self.assertTrue(worker.engine._progression_cancel.is_set()) self.assertFalse(worker.running) def test_slow_account_does_not_block_other_account_status_or_cached_view(self): first, second = self.account(), self.account() self.manager.view(first, "incubator") self.idle(first) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) def action(worker, operation, payload): if worker.id == first: entered.set() release.wait(5) return {"message": "read"} with patch("ranch_web.actions.execute_action", side_effect=action): held = self.manager.submit(first, "refresh") self.assertTrue(entered.wait(2)) started = time.monotonic() self.assertTrue(self.manager.status(first)["busy"]) view = self.manager.view(first, "incubator") self.assertIsNotNone(view["data"]) self.manager.logs(first) self.assertLess(time.monotonic() - started, .2) self.job(second, self.manager.submit(second, "refresh")) self.assertTrue(self.manager.status(first)["busy"]) release.set() self.job(first, held) def test_worker_owned_manual_stop_preserves_confirmed_request(self): identifier = self.account(False) self.login(identifier) worker = self.manager._worker(identifier) monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock")) result = self.job(identifier, self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]})) self.assertTrue(worker.engine.snapshot.monsters[monster["id"]]["lock"]) self.assertIn("message", result["result"]) self.assertFalse(worker.running) def test_enter_job_is_not_terminal_until_persistence_and_summary_are_published(self): identifier = self.account(False) self.job(identifier, self.manager.submit(identifier, "login", {"account": "synthetic-owner", "password": "synthetic-password"})) worker = self.manager._worker(identifier) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) original = worker._persist_session def persist(): if worker.engine.client is not None: entered.set() release.wait(5) return original() with patch.object(worker, "_persist_session", side_effect=persist): selected = self.manager.submit(identifier, "enter_server", {"server_id": 1}) self.assertTrue(entered.wait(2)) self.assertEqual(self.manager.job(identifier, selected["id"])["status"], "running") release.set() self.job(identifier, selected) self.assertTrue(self.manager.status(identifier)["connected"]) def test_stop_between_manual_requests_prevents_remaining_dispatches(self): identifier = self.account(False) self.login(identifier) worker = self.manager._worker(identifier) client = worker.engine.client ids = [row["id"] for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock")][:2] self.assertEqual(len(ids), 2) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) original = client.http.post def post(url, data, **kwargs): value = original(url, data, **kwargs) if url.endswith("monsterService/monsterLock"): entered.set() release.wait(5) return value with patch.object(client.http, "post", side_effect=post): job = self.manager.submit(identifier, "lock", {"monster_ids": ids}) self.assertTrue(entered.wait(2)) self.manager.submit(identifier, "stop") release.set() self.job(identifier, job, status="cancelled") locks = [call for call in FakeClient.calls if call[1].endswith("monsterService/monsterLock")] self.assertEqual(len(locks), 1) self.assertTrue(any(event["kind"] == "response" and event["operation"] == "monsterService/monsterLock" for event in worker.trace.events), "Already-sent response evidence was discarded") def test_stop_during_encoding_prevents_the_encoded_write_reaching_http(self): identifier = self.account(False) self.login(identifier) worker = self.manager._worker(identifier) monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock")) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) before = len(FakeClient.calls) high_water = worker.securestore.load(worker.active_identity).reqid def paused_encode(value, key): encoded = encode(value, key) if "monsterId" in value and "lock" in value: entered.set() if not release.wait(5): raise AssertionError("Encoding gate was not released") return encoded with patch("ranch_assistant.api.encode", side_effect=paused_encode): job = self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]}) self.assertTrue(entered.wait(2)) stopped = self.manager.submit(identifier, "stop") self.assertEqual(stopped["status"], "succeeded") self.assertFalse(release.is_set()) release.set() self.job(identifier, job, status="cancelled") writes = sum(call[1].endswith("monsterService/monsterLock") for call in FakeClient.calls[before:]) self.assertEqual(writes, 0, "An encoded cancelled write reached HTTP") self.assertGreater(worker.securestore.load(worker.active_identity).reqid, high_water) def test_stop_during_requests_preparation_prevents_adapter_dispatch(self): identifier = self.account(False) self.login(identifier) worker = self.manager._worker(identifier) client = worker.engine.client http = client.http monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock")) entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) original_prepare = http.prepare_request before = len(FakeClient.calls) def paused_prepare(request): prepared = original_prepare(request) if request.url.endswith("monsterService/monsterLock"): entered.set() if not release.wait(5): raise AssertionError("Prepared-request gate was not released") return prepared def offline_send(request, **kwargs): value = client._post(request.url, request.body) response = Response() response.status_code, response._content, response.headers = value.status_code, value.content, value.headers response.url, response.request = request.url, request return response adapter = http.get_adapter("https://offline.invalid/") # Exercise requests' real post -> request -> prepare -> send pipeline. # The adapter stays fake; the class-wide live-HTTP prohibition stays on. with patch.object(http, "post", HttpSession.post.__get__(http, HttpSession)), \ patch.object(http, "request", self._http_request.__get__(http, HttpSession)), \ patch.object(http, "prepare_request", side_effect=paused_prepare), \ patch.object(adapter, "send", side_effect=offline_send): job = self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]}) self.assertTrue(entered.wait(2)) started = time.monotonic() self.manager.submit(identifier, "stop") self.assertLess(time.monotonic() - started, .2) release.set() self.job(identifier, job, status="cancelled") writes = sum(call[1].endswith("monsterService/monsterLock") for call in FakeClient.calls[before:]) self.assertEqual(writes, 0, "A prepared cancelled request reached the adapter") def test_config_change_during_automatic_poll_keeps_execution_enabled(self): identifier = self.account(False) self.login(identifier) self.enable(identifier) self.job(identifier, self.manager.submit(identifier, "start")) worker = self.manager._worker(identifier) client = worker.engine.client entered, release = threading.Event(), threading.Event() self.addCleanup(release.set) original = client.http.post def paused_response(url, data, **kwargs): response = original(url, data, **kwargs) if url.endswith("masterService/masterQueryDetail"): entered.set() if not release.wait(5): raise AssertionError("Snapshot response gate was not released") return response worker.engine.last_heartbeat = time.monotonic() worker.schedule.next_poll = 0 with patch.object(client.http, "post", side_effect=paused_response): worker.request_tick() self.assertTrue(entered.wait(2)) self.assertTrue(worker.running) config = self.manager.get_config(identifier)["config"] config["policy"]["keep_money"] += 100 pending = self.manager.set_config(identifier, config) self.assertTrue(worker.running) release.set() self.job(identifier, pending["job"]) self.assertTrue(self.manager.status(identifier)["running"], "Config cancellation disabled the execution switch") self.assertTrue(worker.engine.auto) self.assertEqual(worker.engine.policy.keep_money, config["policy"]["keep_money"]) def test_engine_pause_in_current_generation_still_disables_execution(self): identifier = self.account() self.enable(identifier) self.job(identifier, self.manager.submit(identifier, "start")) worker = self.manager._worker(identifier) worker.schedule.next_poll = 0 def stopped_poll(**kwargs): worker.engine.auto = False return worker.engine.snapshot, [], "Engine paused after validation" with patch.object(worker.engine, "poll", side_effect=stopped_poll): worker.request_tick() self.idle(identifier) self.assertFalse(self.manager.status(identifier)["running"]) self.assertFalse(worker.engine.auto) def test_view_task_indices_stay_bounded_after_many_filters_and_failure(self): identifier = self.account() worker = self.manager._worker(identifier) for index in range(120): view = self.manager.view(identifier, "incubator", {"search": str(index)}) self.job(identifier, {"id": view["job_id"]}) self.assertLessEqual(len(worker._views), 32) self.assertLessEqual(len(worker._view_jobs), 32, "Completed view task indices grow with every filter") self.assertFalse(self.manager.view(identifier, "incubator", {"search": "119"})["loading"]) with patch("ranch_web.views.build_view", side_effect=ValueError("synthetic view failure")): view = self.manager.view(identifier, "incubator", {"search": "failed"}) self.job(identifier, {"id": view["job_id"]}, status="failed") self.assertNotIn(("incubator", '{"search": "failed"}'), worker._view_jobs) retry = self.manager.view(identifier, "incubator", {"search": "failed"}) self.job(identifier, {"id": retry["job_id"]}) self.assertFalse(self.manager.view(identifier, "incubator", {"search": "failed"})["loading"]) def test_failed_counter_save_blocks_http_and_a_repaired_store_can_retry(self): identifier = self.account(False) self.login(identifier) worker = self.manager._worker(identifier) before = len(FakeClient.calls) with patch.object(worker.securestore, "save", side_effect=OSError("synthetic persistence failure")): result = self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") self.assertTrue(result["error"]) self.assertEqual(len(FakeClient.calls), before) self.job(identifier, self.manager.submit(identifier, "refresh")) self.assertGreater(len(FakeClient.calls), before) def test_account_registry_failure_closes_worker_without_holding_manager_lock(self): started = time.monotonic() with patch.object(self.manager.store, "save_accounts", side_effect=OSError("registry unavailable")): with self.assertRaisesRegex(OSError, "registry unavailable"): self.manager.create_account() self.assertLess(time.monotonic() - started, 2) self.assertEqual(self.manager.list_accounts(), []) def test_public_structural_keys_survive_but_real_secret_key_is_removed(self): worker = self.manager._worker(self.account()) value = {name: [{"key": "binding", "label": "选项", "details": {"key": "secret-nested"}}] for name in ("columns", "filters", "pages", "tabs", "form")} value.update(key="secret-protocol", token="secret-token", reqid=17, raw={"hidden": True}) result = worker.public_json(value) for name in ("columns", "filters", "pages", "tabs", "form"): self.assertEqual(result[name][0]["key"], "binding") self.assertNotIn("key", result[name][0]["details"]) self.assertNotIn("key", result) self.assertNotIn("token", result) self.assertNotIn("reqid", result) self.assertNotIn("raw", result) with self.assertRaises(ValueError): worker.public_json(Session()) def test_debug_summaries_are_small_and_details_keep_redacted_body_headers(self): identifier = self.account() worker = self.manager._worker(identifier) worker.trace.emit("response", "离线请求", headers={"Content-Type": "application/json", "Set-Cookie": "private-cookie"}, body={"monsters": [{"id": index, "name": "测试"} for index in range(80)], "token": "private-token", "password": "private-password", "key": "private-key", "reqid": 187, "file_path": str(worker.profile_root / "private.json")}) logs = self.manager.logs(identifier, debug=True) entry = next(row for row in logs["entries"] if row["details_available"]) self.assertNotIn("body", entry) self.assertLess(len(json.dumps(entry)), 1000) details = self.manager.log_detail(identifier, entry["id"])["details"] self.assertEqual(len(details["body"]["monsters"]), 80) self.assertEqual(details["headers"]["Content-Type"], "application/json") for field in ("token", "password", "key", "reqid"): self.assertEqual(details["body"][field], "<隐藏>") serialized = json.dumps(details) for secret in ("private-cookie", "private-token", "private-password", "private-key", str(worker.profile_root)): self.assertNotIn(secret, serialized) for index in range(70): worker.trace.emit("info", "entry", value=index) with self.assertRaises(KeyError): self.manager.debug_entry(identifier, entry["id"]) def test_shutdown_cancels_simulation_before_waiting_and_keeps_pending_evidence(self): first, second = self.account(), self.account() entered = threading.Event() worker = self.manager._worker(first) pending = worker.state_root / "uncertain-evidence.json" pending.write_text('{"status":"unknown"}', encoding="utf-8") def simulate(runtime, operation, payload): entered.set() runtime.engine._progression_cancel.wait(5) runtime.check_intent() return {} with patch("ranch_web.actions.execute_action", side_effect=simulate): job = self.manager.submit(first, "simulate_probe") self.assertTrue(entered.wait(2)) started = time.monotonic() self.manager.close() self.assertLess(time.monotonic() - started, 1) self.assertTrue(pending.exists()) self.assertEqual(self.manager.job(first, job["id"])["status"], "cancelled") self.assertTrue(self.manager._worker(second)._closed.is_set()) def test_no_pyside_or_gui_import_is_required(self): code = ''' import importlib.abc, sys, tempfile class NoGui(importlib.abc.MetaPathFinder): def find_spec(self, fullname, path=None, target=None): if fullname.startswith("PySide6") or fullname.endswith("_gui") or fullname == "ranch_assistant.gui": raise ImportError("GUI forbidden") sys.meta_path.insert(0, NoGui()) from ranch_web.service import WebManager with tempfile.TemporaryDirectory() as root: manager = WebManager(root, start_scheduler=False) manager.create_account(demo=True) manager.close() print("headless-ok") ''' result = subprocess.run([sys.executable, "-c", code], cwd=Path(__file__).resolve().parents[2], capture_output=True, text=True, timeout=15) self.assertEqual(result.returncode, 0, result.stderr) self.assertIn("headless-ok", result.stdout) if __name__ == "__main__": unittest.main()