Files
myrzx_bot/ranch_web/tests/test_service.py
T

860 lines
46 KiB
Python

"""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 Action, 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.assertFalse(self.manager._worker(identifier).engine.auto,
"Restoring a connection must not run selected writes inline")
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.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
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)
# First activation migrates the login preference to keep-login. The
# strategy selections themselves must remain identical.
selected["auto_relogin"]["enabled"] = True
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
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.assertFalse(worker.engine.auto, "Saving selections must not authorize writes inline")
self.assertTrue(worker.engine.daily_policy.enabled)
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
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.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertFalse(self.manager.status(identifier)["manual_stop"])
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):
other = self.account(False)
self.login(other, account="independent-owner")
self.enable(other)
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)
self.assertTrue(self.manager.status(other)["running"], "Cancellation leaked to another account")
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertEqual(worker.running, revoke == "config",
"Only explicit Stop can persistently stop the still-online original role")
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(other)["running"])
self.assertFalse(self.manager.status(other)["manual_stop"])
self.assertEqual(self.manager.status(identifier)["manual_stop"], revoke == "stop")
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())
worker = self.manager._worker(identifier)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker._set_strategy_requested
def persist(requested):
if requested:
entered.set()
if not release.wait(5):
raise AssertionError("Start intent gate not released")
return original(requested)
with patch.object(worker, "_set_strategy_requested", side_effect=persist):
starting = self.manager.submit(identifier, "start")
self.assertTrue(entered.wait(2))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, starting, status="cancelled")
state = self.manager.status(identifier)
self.assertFalse(state["strategy_requested"], "A canceled Start overwrote the later durable Stop")
self.assertTrue(state["manual_stop"])
self.assertFalse(state["running"])
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.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.running, "The manual helper persisted an implicit Stop")
self.assertEqual(sum(url.endswith("monsterService/monsterLock") for _, url, _ in FakeClient.calls), 1)
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.assertFalse(worker.engine.auto, "Config persistence must not authorize writes inline")
self.assertEqual(worker.engine.policy.keep_money, config["policy"]["keep_money"])
worker.engine.last_heartbeat = time.monotonic()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
def test_engine_pause_keeps_request_and_blocks_unconfirmed_legacy_writes(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)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
# These legacy paths disable Engine.auto after an unconfirmed result
# without creating a battle/exploration pending record. Restoring user
# intent must preserve a write barrier across reads and process restart.
for kind in ("gift", "hatch", "feed"):
with self.subTest(kind=kind):
identifier = self.account(False)
self.login(identifier, account="legacy-" + identifier)
worker = self.manager._worker(identifier)
identity = worker.active_identity
clock = [1000.0]
worker.schedule.clock = lambda: clock[0]
worker.engine.last_heartbeat = clock[0]
monsters = list(worker.engine.snapshot.monsters)
if kind == "gift":
# Engine overlays confirmed gift timestamps in seconds,
# while an unchanged raw server snapshot uses milliseconds.
mon = next(row for row in worker.engine.client.raw["monsters"] if row["id"] == monsters[0])
mon["giftTime"] = 1_700_000_000_000
worker.engine.gift_planner.confirmed[monsters[0]] = {
"owner": str(worker.engine.snapshot.raw["master"]["id"]),
"type": str(mon["typeId"]), "feel": int(mon.get("feel") or 0),
"giftTime": 1_700_000_060}
action = Action(kind, "Unconfirmed gift", "monsterService/monsterSendGift",
{"monsterId": monsters[0], "itemId": 1})
elif kind == "hatch":
slot = worker.engine.client.raw["stacks"][0]
slot["monsterId"] = -1
action = Action(kind, "Unconfirmed hatch", "stackService/stackAddMonster",
{"eggs": [{"itemId": 1, "stackId": slot["id"]}]})
worker.engine.pending_hatches = [action]
else:
action = Action(kind, "Unconfirmed feed", "monsterService/monsterIntensify",
{"targetId": monsters[0], "foods": [monsters[1]]})
before = len(FakeClient.calls)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.schedule.next_fast[kind] = 0
worker.schedule.next_poll = float("inf")
else:
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"), status="failed")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(state["running"])
self.job(identifier, self.manager.submit(identifier, "refresh"))
for _ in range(3):
clock[0] += 121
worker.engine.last_heartbeat = clock[0]
worker.schedule.next_poll = 0
tick = worker.enqueue("__tick")
self.idle(identifier)
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.job(identifier, tick["id"])["status"], "succeeded")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
unchanged = deepcopy(worker.engine.client.raw)
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
def restore(session, *, trace):
candidate = FakeClient(session, trace=trace)
candidate.raw = deepcopy(unchanged)
return candidate
worker._restore_factory = restore
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
worker = self.manager._worker(identifier)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.engine.pending_hatches = [action]
worker.schedule.next_fast[kind] = 0
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Restart discarded the unconfirmed legacy write barrier")
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertEqual(state["strategy_state"], "blocked")
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()