fix: preserve strategy intent and recover accounts automatically
This commit is contained in:
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user