370 lines
21 KiB
Python
370 lines
21 KiB
Python
"""Independent offline review repros; all records and accounts are synthetic."""
|
|
from copy import deepcopy
|
|
from datetime import datetime, timezone
|
|
import json
|
|
from pathlib import Path
|
|
import tempfile
|
|
from types import SimpleNamespace
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
|
|
from ranch_assistant.battles import BattleJournal
|
|
from ranch_assistant.commission_history import CommissionHistory, journal_event
|
|
from ranch_assistant.engine import Engine
|
|
from ranch_assistant.game_data import ProgressionData
|
|
from ranch_assistant.model import Catalog, Policy, Snapshot
|
|
from ranch_assistant.progression import ProgressionPlanner
|
|
from ranch_assistant.quests import QuestPolicy
|
|
|
|
|
|
NOW = datetime(2026, 11, 13, 4, tzinfo=timezone.utc).timestamp()
|
|
DAY = "2026-11-13"
|
|
INFO = {"id": "review20", "type": 4, "name": "Review commission", "reward": {"ke": 20},
|
|
"startStep": {"condition": {}}, "steps": [{"statusType": "none", "statusValue": {}}]}
|
|
|
|
|
|
def review_snapshot(role=71, tasks=()):
|
|
return Snapshot({"master": {"id": role, "level": 20, "money": 2000, "ti": 50, "ke": 99999},
|
|
"currentTasks": deepcopy(list(tasks)), "history": {"unlockCity": {"1": True}},
|
|
"items": [], "monsters": [], "stacks": [], "rooms": [], "teams": []})
|
|
|
|
|
|
def review_record(attempt="review-claim", *, kind="complete", task_id=81, timestamp=NOW, **changes):
|
|
record = {"attempt_id": attempt, "role_id": "71", "task_id": task_id, "task_type_id": "review20",
|
|
"kind": {"accept": "progression_loop_accept", "complete": "progression_reward",
|
|
"step": "progression_step", "battle": "progression_battle"}[kind],
|
|
"path": {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
|
|
"step": "taskService/taskCompleteStep", "battle": ""}[kind],
|
|
"timestamp": timestamp, "updated_at": timestamp, "finished_at": timestamp,
|
|
"phase": "done", "outcome": "task", "payload": {},
|
|
"commission": {"name": INFO["name"], "expected_ke": 20, "city": 1,
|
|
"selection_code": "highest_reward", "selection_reason": "review-selected"},
|
|
"baseline": {"tasks": []}, "response_confirmed": True,
|
|
"response": {"resCode": 0, "reward": {"ke": 20}}}
|
|
if kind == "accept":
|
|
record.update(task_id=None, response={"resCode": 0,
|
|
"task": {"id": task_id, "typeId": "review20", "curStep": 1}})
|
|
record.update(changes)
|
|
return record
|
|
|
|
|
|
class CommissionHistoryIndependentReviewTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-independent-review-")))
|
|
self.enterContext(patch("socket.socket.connect", side_effect=AssertionError("offline review forbids network")))
|
|
self.history = CommissionHistory(self.folder / "history.json", clock=lambda: NOW)
|
|
|
|
def ingest(self, records, snapshot=None, history=None, role="71"):
|
|
target = history if history is not None else self.history
|
|
target.ingest(role, records, lambda key: INFO, snapshot)
|
|
return target.query(role, DAY)
|
|
|
|
def test_cancelled_accept_with_task_body_is_never_confirmed(self):
|
|
record = review_record(kind="accept", outcome="cancelled")
|
|
event = journal_event(record, INFO, review_snapshot())
|
|
self.assertEqual(event["status"], "cancelled")
|
|
result = self.ingest([record])
|
|
self.assertEqual(result["summary"]["accepted_count"], 0)
|
|
self.assertEqual(result["summary"]["expected_ke"], 0)
|
|
self.assertIsNone(result["rows"][0]["accepted_at"])
|
|
|
|
def test_pending_receipt_body_does_not_count_as_a_claim(self):
|
|
record = review_record(phase="request_pending", outcome="", response_confirmed=False)
|
|
result = self.ingest([record])
|
|
self.assertEqual(result["summary"]["completed_count"], 0)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
|
self.assertEqual(result["summary"]["pending_count"], 1)
|
|
self.assertIsNone(result["rows"][0]["confirmed_ke"])
|
|
|
|
def test_cancelled_and_failed_outcomes_stay_terminal_in_aggregate(self):
|
|
for outcome, status in (("cancelled", "cancelled"), ("unsupported", "cancelled"), ("loss", "failed")):
|
|
with self.subTest(outcome=outcome):
|
|
ledger = CommissionHistory(clock=lambda: NOW)
|
|
result = self.ingest([review_record(kind="battle", outcome=outcome)], history=ledger)
|
|
self.assertEqual(result["events"][0]["status"], status)
|
|
self.assertEqual(result["rows"][0]["status"], status)
|
|
self.assertEqual(result["summary"]["pending_count"], 0)
|
|
self.assertEqual(result["summary"]["completed_count"], 0)
|
|
|
|
def test_unknown_result_stays_unknown_and_pending_in_summary(self):
|
|
result = self.ingest([review_record(phase="task_unknown", outcome="", response=None,
|
|
response_confirmed=False)])
|
|
self.assertEqual(result["rows"][0]["status"], "unknown")
|
|
self.assertEqual(result["summary"]["pending_count"], 1)
|
|
self.assertEqual(result["summary"]["completed_count"], 0)
|
|
|
|
def test_duplicate_claim_attempts_count_one_instance_once(self):
|
|
result = self.ingest([review_record("claim-one"), review_record("claim-two", timestamp=NOW + 1)])
|
|
self.assertEqual(len(result["events"]), 2, "retain both attempts as evidence")
|
|
self.assertEqual(len(result["rows"]), 1)
|
|
self.assertEqual(result["summary"]["completed_count"], 1)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 20)
|
|
|
|
def test_duplicate_claim_on_later_day_does_not_create_new_reward(self):
|
|
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
|
|
after = before + 120
|
|
result = self.ingest([review_record("claim-before", timestamp=before),
|
|
review_record("claim-after", timestamp=after)])
|
|
self.assertEqual(result["summary"]["completed_count"], 0)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
|
self.assertEqual(self.history.query("71", "2026-11-12")["summary"]["confirmed_ke"], 20)
|
|
|
|
def test_same_type_different_instances_are_counted_separately(self):
|
|
result = self.ingest([review_record("claim-one", task_id=81),
|
|
review_record("claim-two", task_id=82, timestamp=NOW + 1)])
|
|
self.assertEqual(len(result["rows"]), 2)
|
|
self.assertEqual(result["summary"]["completed_count"], 2)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 40)
|
|
|
|
def test_reconciled_accept_is_reconsidered_when_snapshot_changes(self):
|
|
record = review_record(kind="accept", task_id=81, response=None,
|
|
response_confirmed=False, outcome="reconciled")
|
|
first = self.ingest([record], review_snapshot())
|
|
self.assertEqual(first["summary"]["accepted_count"], 0)
|
|
second = self.ingest([record], review_snapshot(tasks=[{"id": 81, "typeId": "review20", "curStep": 1}]))
|
|
self.assertEqual(second["summary"]["accepted_count"], 1)
|
|
self.assertEqual(second["rows"][0]["task_id"], 81)
|
|
|
|
def test_old_accept_today_claim_uses_beijing_day_for_each_count(self):
|
|
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
|
|
after = before + 120
|
|
today = self.ingest([review_record("accept-old", kind="accept", timestamp=before),
|
|
review_record("claim-today", timestamp=after)])
|
|
yesterday = self.history.query("71", "2026-11-12")
|
|
self.assertEqual(today["summary"]["accepted_count"], 0)
|
|
self.assertEqual(today["summary"]["expected_ke"], 0)
|
|
self.assertEqual(today["summary"]["completed_count"], 1)
|
|
self.assertEqual(today["summary"]["confirmed_ke"], 20)
|
|
self.assertEqual(yesterday["summary"]["accepted_count"], 1)
|
|
self.assertEqual(yesterday["summary"]["completed_count"], 0)
|
|
self.assertEqual(today["rows"][0]["accepted_at"], before)
|
|
|
|
def test_missing_historical_metadata_never_invents_reason_or_reward(self):
|
|
record = review_record(commission={}, response={"resCode": 0, "ke": 99999})
|
|
result = self.ingest([record], review_snapshot())
|
|
row = result["rows"][0]
|
|
self.assertIsNone(row["accepted_at"])
|
|
self.assertIsNone(row["confirmed_ke"])
|
|
self.assertNotIn("review-selected", row["selection_reason"])
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
|
self.assertEqual(result["summary"]["unknown_reward_count"], 1)
|
|
|
|
def test_unconfirmed_historical_accept_does_not_describe_itself_as_confirmed(self):
|
|
result = self.ingest([review_record(kind="accept", commission={}, phase="request_pending",
|
|
outcome="", response=None, response_confirmed=False)])
|
|
self.assertEqual(result["summary"]["accepted_count"], 0)
|
|
self.assertNotIn("已确认", result["rows"][0]["selection_reason"])
|
|
|
|
def test_invalid_reward_values_are_unknown_not_catalog_or_wallet_amounts(self):
|
|
for value in (None, True, "20", -1, 1.5, float("nan"), float("inf")):
|
|
with self.subTest(value=value):
|
|
ledger = CommissionHistory(clock=lambda: NOW)
|
|
result = self.ingest([review_record(response={"resCode": 0, "reward": {"ke": value}})],
|
|
history=ledger)
|
|
self.assertEqual(result["summary"]["completed_count"], 1)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
|
self.assertIsNone(result["rows"][0]["confirmed_ke"])
|
|
|
|
def test_read_and_restart_are_idempotent_and_return_detached_data(self):
|
|
records = [review_record()]
|
|
expected = self.ingest(records)
|
|
before = self.history.path.read_bytes()
|
|
for _ in range(3):
|
|
self.assertEqual(self.ingest(records), expected)
|
|
self.assertEqual(self.history.query("71", DAY), expected)
|
|
self.assertEqual(self.history.path.read_bytes(), before)
|
|
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
|
|
self.assertEqual(self.ingest(records, history=restored), expected)
|
|
copy = restored.query("71", DAY)
|
|
copy["rows"][0]["name"] = "caller mutation"
|
|
self.assertEqual(restored.query("71", DAY), expected)
|
|
|
|
def test_role_and_separate_account_paths_are_isolated(self):
|
|
self.ingest([review_record()])
|
|
other = review_record(role_id="72", response={"resCode": 0, "reward": {"ke": 15}})
|
|
self.ingest([other], role="72")
|
|
self.assertEqual(self.history.query("71", DAY)["summary"]["confirmed_ke"], 20)
|
|
self.assertEqual(self.history.query("72", DAY)["summary"]["confirmed_ke"], 15)
|
|
separate = CommissionHistory(self.folder / "other-account" / "history.json", clock=lambda: NOW)
|
|
self.assertEqual(separate.query("71", DAY)["events"], [])
|
|
|
|
def test_ledger_survives_rolling_journal_eviction_and_restart(self):
|
|
snapshot = review_snapshot()
|
|
journal = BattleJournal(self.folder / "journal.json")
|
|
journal.role(snapshot)["records"].append(review_record())
|
|
journal.save()
|
|
self.ingest(journal.role(snapshot)["records"])
|
|
journal.role(snapshot)["records"].extend({"attempt_id": f"other-{i}", "role_id": "71"}
|
|
for i in range(501))
|
|
journal.save()
|
|
self.assertEqual(len(journal.role(snapshot)["records"]), 500)
|
|
self.assertNotIn("review-claim", {r["attempt_id"] for r in journal.role(snapshot)["records"]})
|
|
self.ingest(journal.role(snapshot)["records"])
|
|
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
|
|
result = restored.query("71", DAY)
|
|
self.assertEqual(result["summary"]["completed_count"], 1)
|
|
self.assertEqual(result["summary"]["confirmed_ke"], 20)
|
|
|
|
def test_event_cap_and_retention_preserve_newest_events_on_restart(self):
|
|
ledger = CommissionHistory(self.folder / "bounded.json", max_events=2, retention_days=2, clock=lambda: NOW)
|
|
self.ingest([review_record(f"event-{i}", task_id=81 + i, timestamp=NOW + i)
|
|
for i in (-3 * 86400, 0, 1, 2)], history=ledger)
|
|
restored = CommissionHistory(ledger.path, max_events=2, retention_days=2, clock=lambda: NOW)
|
|
result = restored.query("71", DAY)
|
|
self.assertEqual({e["id"] for e in result["events"]}, {"event-1", "event-2"})
|
|
|
|
def test_corrupt_history_is_reported_and_original_bytes_preserved(self):
|
|
path = self.folder / "corrupt.json"
|
|
path.write_text('{"broken":', encoding="utf-8")
|
|
before = path.read_bytes()
|
|
ledger = CommissionHistory(path, clock=lambda: NOW)
|
|
result = self.ingest([review_record()], history=ledger)
|
|
self.assertTrue(result["error"])
|
|
self.assertEqual(result["events"], [])
|
|
self.assertEqual(path.read_bytes(), before)
|
|
|
|
def test_incomplete_persisted_event_reports_error_instead_of_crashing_read(self):
|
|
path = self.folder / "incomplete-event.json"
|
|
path.write_text(json.dumps({"version": 1, "roles": {"71": {"bad-event": {
|
|
"id": "bad-event", "time": NOW, "date": DAY, "kind": "complete", "status": "confirmed"}}}}),
|
|
encoding="utf-8")
|
|
before = path.read_bytes()
|
|
ledger = CommissionHistory(path, clock=lambda: NOW)
|
|
result = ledger.query("71", DAY)
|
|
self.assertTrue(result["error"])
|
|
self.assertEqual(path.read_bytes(), before)
|
|
|
|
def test_cancelled_history_row_is_labelled_cancelled_by_web(self):
|
|
from ranch_web.policies import default_config
|
|
from ranch_web.views import build_view
|
|
|
|
history = self.ingest([review_record(kind="accept", outcome="cancelled")])
|
|
engine = Engine(Catalog())
|
|
engine.snapshot = review_snapshot()
|
|
engine.commission_history = Mock(return_value=history)
|
|
dto = build_view(engine, "commissions", default_config(), {"tab": "history", "date": DAY})
|
|
self.assertEqual(dto["rows"][0]["status_label"], "已取消")
|
|
self.assertIn("已取消", dto["details"][dto["rows"][0]["id"]]["行动记录"])
|
|
|
|
|
|
class CommissionRunMessageIndependentReviewTests(unittest.TestCase):
|
|
def test_uncertain_accept_is_not_resent_after_engine_restart(self):
|
|
with tempfile.TemporaryDirectory(prefix="commission-uncertain-review-") as directory:
|
|
client = Mock()
|
|
client.call.side_effect = TimeoutError("synthetic uncertain write")
|
|
path = Path(directory) / "budget.json"
|
|
data = ProgressionData({"task_info": {"review20": deepcopy(INFO)}, "scripts": {},
|
|
"stage_info": {}, "game_setting": {"cityInfo": {"1": {}}}})
|
|
engine = Engine(Catalog(), client, path, game_data=data)
|
|
engine.snapshot = review_snapshot()
|
|
engine.snapshot.raw["history"].update(loopTaskTime=engine.snapshot.now, loopTaskNum=6,
|
|
loopTask={"1": ["review20"]})
|
|
engine.quest_policy.enabled = True
|
|
engine._refresh_progression_cache(force=True)
|
|
intent = next(i for i in engine._progression_intents if not i.blocked)
|
|
self.assertEqual(intent.kind, "progression_loop_accept")
|
|
with self.assertRaises(TimeoutError):
|
|
engine._run_progression_intent(intent)
|
|
self.assertEqual(client.call.call_count, 1)
|
|
self.assertIsNotNone(engine.battle_journal.pending(engine.snapshot))
|
|
restored = Engine(Catalog(), client, path, game_data=data)
|
|
restored.snapshot = review_snapshot()
|
|
restored.quest_policy.enabled = True
|
|
for _ in range(3):
|
|
_, _, message = restored._run_progression_intent(intent)
|
|
self.assertIn("核对", message)
|
|
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
|
|
self.assertEqual(restored.commission_history()["summary"]["completed_count"], 0)
|
|
self.assertEqual(client.call.call_count, 1)
|
|
|
|
def test_history_save_failure_recovers_without_replaying_game_request(self):
|
|
with tempfile.TemporaryDirectory(prefix="commission-storage-review-") as directory:
|
|
client = Mock()
|
|
client.call.side_effect = AssertionError("history must never replay a game write")
|
|
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
|
|
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
|
|
engine.snapshot = review_snapshot()
|
|
engine._commission_history.clock = lambda: NOW
|
|
engine.battle_journal.role(engine.snapshot)["records"].append(review_record())
|
|
engine.battle_journal.save()
|
|
with patch.object(engine._commission_history, "_save", side_effect=PermissionError("synthetic disk error")):
|
|
engine._sync_commission_history()
|
|
result = engine.commission_history(DAY)
|
|
self.assertTrue(result["error"])
|
|
self.assertEqual(result["summary"]["completed_count"], 1)
|
|
engine._sync_commission_history()
|
|
self.assertFalse(engine.commission_history(DAY)["error"])
|
|
restored = CommissionHistory(engine._commission_history.path, clock=lambda: NOW)
|
|
self.assertEqual(restored.query("71", DAY)["summary"]["completed_count"], 1)
|
|
client.call.assert_not_called()
|
|
|
|
def test_battle_early_return_cannot_replay_old_commission_success(self):
|
|
for early_return in ("resources", "cancelled", "lock"):
|
|
with self.subTest(early_return=early_return), tempfile.TemporaryDirectory(
|
|
prefix="commission-message-review-") as directory:
|
|
client = Mock()
|
|
client.call.side_effect = AssertionError("offline review forbids game writes")
|
|
client.snapshot.side_effect = AssertionError("offline review forbids game reads")
|
|
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
|
|
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
|
|
engine.snapshot = review_snapshot()
|
|
engine.quest_policy.enabled = True
|
|
engine._commission_history.clock = lambda: NOW
|
|
state = engine.battle_journal.role(engine.snapshot)
|
|
state["records"].append(review_record())
|
|
engine.battle_journal.save()
|
|
engine._sync_commission_history()
|
|
history_before = engine.commission_history(DAY)
|
|
journal_before = deepcopy(state["records"])
|
|
engine.plans = Mock(return_value=[])
|
|
engine.read_snapshot = Mock(return_value=engine.snapshot)
|
|
engine._refresh_progression_cache = Mock()
|
|
engine._intent_policy = Mock(return_value=SimpleNamespace(enabled=True, team="teamA"))
|
|
intent = {"kind": "progression_battle", "task_id": 82, "task_type_id": "review20",
|
|
"step_number": 1, "block_reason": ""}
|
|
if early_return == "resources":
|
|
expected = "review-resource-shortage"
|
|
engine.battles.resource_reason = Mock(return_value=expected)
|
|
elif early_return == "cancelled":
|
|
expected = "任务 / 战斗已取消,未开始"
|
|
def cancel_during_preflight(*args):
|
|
engine._progression_cancel.set()
|
|
return ""
|
|
engine.battles.resource_reason = Mock(side_effect=cancel_during_preflight)
|
|
else:
|
|
expected = "同账号已有任务 / 战斗正在执行"
|
|
engine.battles.run = Mock(return_value=expected)
|
|
with patch.object(engine.battle_journal, "begin", wraps=engine.battle_journal.begin) as begin:
|
|
_, _, message = engine._run_progression_intent(intent)
|
|
begin.assert_not_called()
|
|
client.call.assert_not_called()
|
|
client.snapshot.assert_not_called()
|
|
self.assertEqual(state["records"], journal_before)
|
|
self.assertEqual(engine.commission_history(DAY), history_before)
|
|
self.assertEqual(message, expected, "a previous confirmed claim must not replace the new blocked message")
|
|
|
|
|
|
class CommissionSelectionIndependentReviewTests(unittest.TestCase):
|
|
def test_fallback_to_ten_explains_rejected_fifteen_when_twenty_absent(self):
|
|
tasks = {}
|
|
for amount in (10, 15):
|
|
tasks[str(amount)] = deepcopy(INFO) | {"id": str(amount), "name": f"review-{amount}",
|
|
"closed": amount == 15, "reward": {"ke": amount}}
|
|
data = {"task_info": tasks, "scripts": {}, "stage_info": {},
|
|
"game_setting": {"cityInfo": {"1": {}, "2": {}}}}
|
|
snapshot = review_snapshot()
|
|
snapshot.raw["history"].update(loopTaskTime=snapshot.now, loopTaskNum=6,
|
|
loopTask={"1": ["10"], "2": ["15"]}, unlockCity={"1": True, "2": True})
|
|
planner = ProgressionPlanner(Catalog(), data)
|
|
actions = planner.commission_plan(snapshot, QuestPolicy(enabled=True), Policy())
|
|
self.assertEqual(actions[0].task_type_id, "10")
|
|
self.assertEqual([b["task_type_id"] for b in planner.commission_selection["higher_reward_blockers"]], ["15"])
|
|
reason = planner.commission_selection["selection_reason"]
|
|
self.assertIn("review-15", reason)
|
|
self.assertIn("关闭", reason)
|
|
self.assertIn("20", reason)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|