fix: preserve strategy intent and recover accounts automatically

This commit is contained in:
AttilaNet
2026-11-11 19:37:15 +08:00
parent ccb945631d
commit 5c253d5cf9
26 changed files with 1628 additions and 236 deletions
+149 -9
View File
@@ -17,7 +17,7 @@ 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_assistant.model import Action, Catalog
from ranch_web.service import RevisionConflict, WebManager
from ranch_web.store import session_identity
@@ -162,7 +162,8 @@ class ServiceTests(unittest.TestCase):
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)
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)
@@ -180,7 +181,7 @@ class ServiceTests(unittest.TestCase):
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.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"])
@@ -193,10 +194,13 @@ class ServiceTests(unittest.TestCase):
"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.assertTrue(worker.engine.auto)
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(), [])
@@ -210,8 +214,11 @@ class ServiceTests(unittest.TestCase):
for _, url, _ in FakeClient.calls[before:]))
self.enable(identifier)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
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)
@@ -230,6 +237,9 @@ class ServiceTests(unittest.TestCase):
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()
@@ -240,6 +250,9 @@ class ServiceTests(unittest.TestCase):
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):
@@ -275,11 +288,16 @@ class ServiceTests(unittest.TestCase):
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.assertFalse(worker.running)
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:
@@ -351,6 +369,28 @@ class ServiceTests(unittest.TestCase):
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()
@@ -415,7 +455,13 @@ class ServiceTests(unittest.TestCase):
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)
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)
@@ -574,10 +620,14 @@ class ServiceTests(unittest.TestCase):
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.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_in_current_generation_still_disables_execution(self):
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"))
@@ -593,6 +643,96 @@ class ServiceTests(unittest.TestCase):
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()