720 lines
37 KiB
Python
720 lines
37 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 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()
|