feat: add daily commission history for Web 2.0.8

This commit is contained in:
AttilaNet
2026-11-13 09:59:43 +08:00
parent ad25d5b403
commit 296653d8d3
25 changed files with 2179 additions and 96 deletions
@@ -0,0 +1,405 @@
"""Offline commission observability; every game transport is a fake."""
from copy import deepcopy
from datetime import datetime
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.commission_history import CommissionHistory, beijing_day
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.quests import CN, QuestPolicy, TaskPlanner
from ranch_assistant.progression import ProgressionPlanner
from ranch_assistant.tests.test_progression import config, snapshot, step, task
class CommissionHistoryTests(unittest.TestCase):
def setUp(self):
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-offline-")))
self.catalog = Catalog()
self.tasks = {str(400 + number): task(str(400 + number), type=4,
name=name, reward={"ke": reward}) for number, (name, reward) in
enumerate((("低奖励委托", 10), ("中等奖励委托", 15), ("高奖励委托", 20)))}
self.data = ProgressionData(config(self.tasks))
self.snapshot = snapshot(currentTasks=[])
self.snapshot.raw["history"].update(loopTaskTime=self.snapshot.now, loopTaskNum=6,
loopTask={"1": ["400", "401"], "2": ["402"]}, unlockCity={"1": True, "2": True})
self.client = Mock()
self.client.call.side_effect = AssertionError("unexpected offline game operation")
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.snapshot.raw), self.snapshot.now)
def engine(self):
engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data)
engine.snapshot = self.snapshot
engine.quest_policy = QuestPolicy(enabled=True)
return engine
def record(self, engine, *, kind="progression_complete", path="taskService/taskComplete",
task_id=51, type_id="402", response=None, outcome="task"):
record = engine.battle_journal.begin(engine.snapshot, {"kind": kind, "description": "旧任务操作",
"path": path, "payload": {}, "task_id": task_id, "task_type_id": type_id, "step_number": 1})
if response is not None:
engine.battle_journal.update(record, "acknowledged", response=response, response_confirmed=True)
if outcome is not None:
engine.battle_journal.finish(engine.snapshot, record, outcome)
return record
def receipt(self, attempt, *, kind="complete", task_id=51, type_id="402", when=None, role=1,
response=None, outcome="task", phase="done", **extra):
when = self.snapshot.now if when is None else when
paths = {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
"step": "taskService/taskCompleteStep", "navigate": "", "dialogue": "", "farm": "battleService/battleEnd"}
originals = {"accept": "progression_loop_accept", "complete": "progression_complete",
"step": "progression_step", "navigate": "progression_navigate", "dialogue": "progression_dialogue", "farm": "map_battle"}
return {"attempt_id": attempt, "role_id": str(role), "kind": originals[kind], "path": paths[kind],
"task_type_id": type_id, "task_id": task_id, "step_number": 1, "phase": phase, "outcome": outcome,
"timestamp": when, "finished_at": when if phase == "done" else None, "updated_at": when,
"response": {"resCode": 0} if response is None else response,
"response_confirmed": phase == "done" and outcome == "task", "payload": {},
"baseline": {"tasks": []}, **extra}
def ledger(self, records, *, now=None, role=1, **options):
ledger = CommissionHistory(self.folder / "history.json", clock=lambda: now or self.snapshot.now, **options)
ledger.ingest(role, records, lambda key: self.tasks.get(key), self.snapshot)
return ledger
def test_early_battle_return_never_relogs_previous_commission_claim(self):
engine = self.engine()
self.record(engine, response={"resCode": 0, "reward": {"ke": 20}})
engine.battles.run = Mock(return_value="体力不足,未开始战斗")
intent = {"kind": "progression_battle", "task_type_id": "402", "task_id": 52,
"step_number": 1, "description": "下一份委托战斗"}
with patch.object(engine, "read_snapshot"), patch.object(engine, "_refresh_progression_cache"):
_, _, message = engine._run_progression_intent(intent)
self.assertEqual(message, "体力不足,未开始战斗")
self.client.call.assert_not_called()
def test_receipts_persist_instance_and_expected_reward_separately_from_actual(self):
records = [self.receipt("a", kind="accept", task_id=0, type_id="401",
response={"resCode": 0, "task": {"id": 51, "typeId": "401", "curStep": 1}}),
self.receipt("c", type_id="401", response={"resCode": 0, "reward": {"ke": 7}})]
ledger = self.ledger(records)
dto = ledger.query(1)
self.assertEqual(dto["summary"], {"accepted_count": 1, "completed_count": 1, "pending_count": 0,
"expected_ke": 15, "confirmed_ke": 7, "unknown_reward_count": 0})
self.assertEqual(len(dto["rows"]), 1)
self.assertEqual((dto["rows"][0]["expected_ke"], dto["rows"][0]["confirmed_ke"]), (15, 7))
restored = CommissionHistory(self.folder / "history.json")
restored.ingest(1, records, self.tasks.get)
self.assertEqual(restored.query(1)["summary"], dto["summary"])
self.assertIn("实际获得7氪金", dto["rows"][0]["last_action"])
def test_wallet_total_and_missing_reward_never_become_confirmed_delta(self):
self.snapshot.raw["master"]["ke"] = 9000
records = [self.receipt("c", response={"resCode": 0, "ke": 9000, "master": {"ke": 9000}})]
dto = self.ledger(records).query(1)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
self.assertEqual(dto["summary"]["unknown_reward_count"], 1)
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
def test_step_and_farming_loot_never_count_as_final_commission_reward(self):
records = [self.receipt("s", kind="step", response={"resCode": 0, "reward": {"ke": 5}}),
self.receipt("f", kind="farm", task_id=0, type_id="", outcome="win", source_task_id=51,
source_task_type_id="402", settlement_confirmed=True,
response={"resCode": 0, "stageReward": {"ke": 20}, "reward": {"ke": 20}})]
dto = self.ledger(records).query(1)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
self.assertEqual({event["kind"] for event in dto["events"]}, {"step", "farm"})
self.assertEqual(len(dto["rows"]), 1)
def test_snapshot_presence_and_pass_task_flag_create_no_history(self):
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "402", "curStep": 2}]
self.snapshot.raw["history"]["passTask"] = {"402": True}
engine = self.engine()
dto = engine.commission_history()
self.assertEqual(dto["rows"], [])
self.assertEqual(dto["summary"]["accepted_count"], 0)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.client.call.assert_not_called()
def test_reconciled_claim_without_receipt_remains_unknown(self):
self.snapshot.raw["history"]["passTask"] = {"402": True}
dto = self.ledger([self.receipt("c", phase="done", outcome="reconciled", response=None)]).query(1)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertEqual(dto["rows"][0]["status"], "unknown")
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
def test_reconciled_acceptance_needs_new_instance_and_does_not_invent_reason(self):
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
record = self.receipt("a", kind="accept", task_id=0, outcome="reconciled", response=None,
baseline={"tasks": [{"id": 51, "typeId": "402"}]},
commission_task={"id": 52, "typeId": "402", "curStep": 1})
ledger = self.ledger([record])
dto = ledger.query(1)
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["rows"][0]["task_id"], 52)
self.assertEqual(dto["rows"][0]["selection_code"], "unknown")
self.snapshot.raw["currentTasks"] = []
restored = CommissionHistory(self.folder / "history.json")
restored.ingest(1, [record], self.tasks.get, self.snapshot)
self.assertEqual(restored.query(1)["summary"]["accepted_count"], 1)
def test_old_reconciled_acceptance_cannot_bind_to_unrelated_current_instance(self):
self.snapshot.raw["currentTasks"] = [{"id": 99, "typeId": "402", "curStep": 1}]
stamp = self.snapshot.now - 2 * 86400
ledger = self.ledger([self.receipt("old-a", kind="accept", task_id=0,
when=stamp, outcome="reconciled", response=None)])
dto = ledger.query(1, beijing_day(stamp))
self.assertIsNone(dto["rows"][0]["task_id"])
self.assertEqual(dto["summary"]["accepted_count"], 0)
def test_fresh_snapshot_reconciliation_captures_exact_new_acceptance_instance(self):
engine = self.engine()
record = self.record(engine, kind="progression_loop_accept", path="taskService/taskLoopReceive",
task_id=0, outcome=None)
engine.battle_journal.update(record, "unknown")
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
engine.read_snapshot(sync_master=False)
dto = engine.commission_history()
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["rows"][0]["task_id"], 52)
self.client.call.assert_not_called()
def test_acceptance_validates_numeric_ids_and_instance_identity(self):
for identifier, valid in (("51", True), (True, False), (51.5, False), ("bad", False)):
with self.subTest(identifier=identifier):
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt(str(identifier), kind="accept", task_id=0,
response={"task": {"id": identifier, "typeId": "402", "curStep": "1"}})], self.tasks.get)
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], int(valid))
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt("wrong", kind="accept", task_id=0,
response={"resCode": 0, "task": {"id": 52, "typeId": "401", "curStep": 1}})], self.tasks.get)
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], 0)
def test_duplicate_attempts_and_receipts_deduplicate_daily_counts_by_instance(self):
records = [self.receipt("a1", kind="accept", task_id=0,
response={"task": {"id": 51, "typeId": "402", "curStep": 1}}),
self.receipt("a2", kind="accept", task_id=0,
response={"task": {"id": "51", "typeId": "402", "curStep": 1}}),
self.receipt("c1", response={"reward": {"ke": 20}}),
self.receipt("c2", task_id="51", response={"reward": {"ke": 20}})]
ledger = self.ledger(records)
ledger.ingest(1, records, self.tasks.get)
dto = ledger.query(1)
self.assertEqual(len(dto["events"]), 4)
self.assertEqual(len(dto["rows"]), 1)
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["expected_ke"], 20)
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
def test_beijing_midnight_repeat_types_and_cross_day_duplicate_claims(self):
midnight = datetime(2026, 11, 13, tzinfo=CN).timestamp()
records = [self.receipt("old", when=midnight - 1, response={"reward": {"ke": 20}}),
self.receipt("duplicate", when=midnight + 1, response={"reward": {"ke": 20}}),
self.receipt("new", task_id=52, when=midnight + 2, response={"reward": {"ke": 20}})]
ledger = self.ledger(records, now=midnight + 10)
self.assertEqual(beijing_day(midnight - 1), "2026-11-12")
self.assertEqual(ledger.query(1)["date"], "2026-11-13")
self.assertEqual(ledger.query(1, "2026-11-12")["summary"]["confirmed_ke"], 20)
dto = ledger.query(1)
self.assertEqual(len(dto["rows"]), 2)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
self.assertEqual(len({row["id"] for row in dto["rows"]}), 2)
self.assertEqual(dto["dates"], ["2026-11-13", "2026-11-12"])
def test_pending_and_failure_states_never_claim_success(self):
for phase, outcome, expected in (("request_pending", "", "pending"), ("unknown", "", "unknown"),
("done", "cancelled", "cancelled"), ("done", "loss", "failed")):
with self.subTest(expected=expected):
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt(expected, kind="step", phase=phase, outcome=outcome)], self.tasks.get)
dto = ledger.query(1)
self.assertEqual(dto["rows"][0]["status"], expected)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertNotIn(";已确认", dto["events"][0]["description"])
def test_existing_task_action_is_not_counted_as_accepted_today(self):
dto = self.ledger([self.receipt("s", kind="step")]).query(1)
self.assertEqual(dto["summary"]["accepted_count"], 0)
self.assertIsNone(dto["rows"][0]["accepted_at"])
self.assertEqual(dto["rows"][0]["selection_code"], "already_accepted")
def test_role_isolation_and_dto_mutation_cannot_change_history(self):
ledger = self.ledger([self.receipt("c", response={"reward": {"ke": 20}})])
self.assertEqual(ledger.query(2)["rows"], [])
dto = ledger.query(1)
dto["rows"][0]["events"][0]["description"] = "changed"
dto["summary"]["confirmed_ke"] = 10000
self.assertEqual(ledger.query(1)["summary"]["confirmed_ke"], 20)
self.assertNotEqual(ledger.query(1)["events"][0]["description"], "changed")
def test_bounded_retention_and_journal_rollover_preserve_imported_receipts(self):
now = self.snapshot.now
records = [self.receipt(str(number), task_id=number + 1, when=now - number,
response={"reward": {"ke": 20}}) for number in range(8)]
records.append(self.receipt("ancient", task_id=99, when=now - 91 * 86400, response={"reward": {"ke": 20}}))
ledger = self.ledger(records, max_events=4)
self.assertEqual(len(ledger.query(1)["events"]), 4)
ledger.ingest(1, [], self.tasks.get)
restored = CommissionHistory(self.folder / "history.json", max_events=4)
self.assertEqual(restored.query(1)["summary"]["completed_count"], 4)
def test_history_reads_do_not_reload_journal_or_load_full_progression(self):
engine = self.engine()
engine.game_data = None
self.record(engine, type_id="100", response={"reward": {"ke": 20}})
with patch("ranch_assistant.game_data.load_progression_data", side_effect=AssertionError("unexpected full load")), \
patch.object(engine.battle_journal, "records", side_effect=AssertionError("unexpected payload copy")), \
patch.object(engine.battle_journal, "reload", side_effect=AssertionError("unexpected journal reload")):
engine.commission_history()
engine.commission_history()
self.client.call.assert_not_called()
def test_history_write_failure_preserves_success_and_recovers_without_game_retry(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = lambda *args: {"resCode": 0, "task": {"id": 51, "typeId": "402", "curStep": 1}}
with patch.object(engine._commission_history, "_save", side_effect=OSError("fixture disk full")):
message = engine._execute_task_intent(intent)
self.assertIn("已确认", message)
dto = engine.commission_history()
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertIn("暂未写入磁盘", dto["error"])
self.assertEqual(self.client.call.call_count, 1)
self.assertIsNone(engine.battle_journal.pending(self.snapshot))
recovered = engine.commission_history()
self.assertEqual(recovered["error"], "")
self.assertTrue(engine._commission_history.path.exists())
self.assertEqual(self.client.call.call_count, 1)
def test_acceptance_timeout_stays_unknown_and_restart_never_replays(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = TimeoutError("offline timeout")
with self.assertRaises(TimeoutError):
engine._execute_task_intent(intent)
self.assertEqual(engine.commission_history()["rows"][0]["status"], "unknown")
restored = self.engine()
restored._refresh_progression_cache(force=True)
_, _, message = restored._run_progression_intent()
self.assertIn("待核对", message)
self.assertEqual(self.client.call.call_count, 1)
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
def test_accepted_reply_without_task_is_unknown_in_both_log_and_history(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = lambda *args: {"resCode": 0}
message = engine._execute_task_intent(intent)
self.assertIn("结果未知", message)
self.assertNotIn(";已确认", message)
self.assertEqual(engine.commission_history()["summary"]["accepted_count"], 0)
self.assertIsNotNone(engine.battle_journal.pending(self.snapshot))
def test_offer_diagnostics_and_selection_explain_locked_city_and_runtime(self):
engine = self.engine()
self.snapshot.raw["history"]["unlockCity"]["2"] = False
engine._refresh_progression_cache(force=True)
selected = engine.progression_planner.commission_selection
self.assertEqual(selected["task_type_id"], "401")
self.assertEqual(selected["selection_code"], "20_ineligible")
self.assertIn("城市尚未解锁", selected["selection_reason"])
with patch.object(engine, "_battle_capability", side_effect=AssertionError("UI must not inspect runtime")):
for _ in range(3):
rows = engine.commission_offer_diagnostics()
high = next(row for row in rows if row["task_type_id"] == "402")
self.assertFalse(high["eligible"])
self.assertEqual(high["reason"], "城市尚未解锁")
self.client.call.assert_not_called()
engine._commission_offer_supported = Mock(side_effect=lambda key: str(key) != "402")
engine._commission_offer_reason = "保护目标规则暂不支持"
self.snapshot.raw["history"]["unlockCity"]["2"] = True
engine._refresh_progression_cache(force=True)
self.assertIn("保护目标规则暂不支持", engine.progression_planner.commission_selection["selection_reason"])
def test_quota_and_city_filter_diagnostics_do_not_claim_receivable(self):
engine = self.engine()
engine.quest_policy.city = 1
engine._refresh_progression_cache(force=True)
high = next(row for row in engine.commission_offer_diagnostics() if row["task_type_id"] == "402")
self.assertFalse(high["eligible"])
self.assertIn("策略限定城市", high["reason"])
self.snapshot.raw["history"]["loopTaskNum"] = 0
engine._refresh_progression_cache(force=True)
rows = engine.commission_offer_diagnostics()
self.assertTrue(all(not row["eligible"] for row in rows))
self.assertIn("当日接取次数已用完", next(row for row in rows if row["city"] == 1)["reason"])
def test_unchanged_snapshot_replans_after_beijing_midnight_grace(self):
engine = self.engine()
before = datetime(2026, 11, 13, 23, 59, 59, tzinfo=CN).timestamp()
self.snapshot.raw["history"].update(loopTaskTime=before, loopTaskNum=0)
original = deepcopy(self.snapshot.raw)
with patch("ranch_assistant.model.time.time", return_value=before):
engine._refresh_progression_cache(force=True)
self.assertFalse(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
with patch("ranch_assistant.model.time.time", return_value=before + 12):
engine._refresh_progression_cache()
self.assertEqual(self.snapshot.raw, original)
self.assertTrue(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
def test_no_twenty_fallback_still_explains_rejected_fifteen(self):
self.snapshot.raw["history"]["loopTask"] = {"1": ["400", "401"]}
self.tasks["401"]["closed"] = True
for planner in (ProgressionPlanner(self.catalog, config(self.tasks)), TaskPlanner(self.catalog)):
self.catalog.data["task_info"] = self.tasks
if isinstance(planner, TaskPlanner):
action = planner.plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0]
self.assertEqual(action.payload["taskTypeId"], "400")
else:
self.assertEqual(planner.commission_plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0].task_type_id, "400")
self.assertEqual(planner.commission_selection["selection_code"], "no_20_offered")
self.assertIn("未提供20", planner.commission_selection["selection_reason"])
self.assertIn("委托已关闭", planner.commission_selection["selection_reason"])
def test_step_log_names_consumed_and_only_checked_items(self):
self.catalog.data.setdefault("item_names", {})["30001"] = "石块"
for remove, expected in ((True, "提交石块×5"), (False, "核对持有石块×5")):
with self.subTest(remove=remove):
engine = Engine(self.catalog, self.client, game_data=ProgressionData(config({"402": task("402", type=4,
reward={"ke": 20}, steps=[step("getItem", statusValue={"type": "30001", "num": 5, "remove": remove})])})))
engine.snapshot = self.snapshot
intent = {"kind": "quest_step", "task_id": 51, "task_type_id": "402", "step_number": 1,
"path": "taskService/taskCompleteStep", "payload": {}, "description": "提交步骤"}
record = engine.battle_journal.begin(self.snapshot, intent)
engine._journal_commission(record, intent, legacy=True)
engine.battle_journal.update(record, "acknowledged", response={"resCode": 0}, response_confirmed=True)
engine.battle_journal.finish(self.snapshot, record, "task")
dto = engine.commission_history()
self.assertIn(expected, dto["events"][0]["description"])
self.assertIn("20氪金", dto["events"][0]["description"])
def test_navigation_and_dialogue_are_local_evidence_with_honest_labels(self):
records = [self.receipt("n", kind="navigate", outcome="local", description="前往王城市场"),
self.receipt("d", kind="dialogue", outcome="local", description="与妮娜对话")]
dto = self.ledger(records).query(1)
self.assertEqual({event["kind"] for event in dto["events"]}, {"navigate", "dialogue"})
self.assertTrue(all(event["confirmation"] == "local" for event in dto["events"]))
self.assertEqual(dto["summary"]["accepted_count"], 0)
def test_invalid_day_and_corrupt_history_preserve_file(self):
ledger = self.ledger([])
for day in ("20261113", "2026-02-30", "2026-1-1", 20261113):
with self.subTest(day=day), self.assertRaises(ValueError):
ledger.query(1, day)
damaged = self.folder / "damaged.json"
damaged.write_text("not-json", encoding="utf-8")
ledger = CommissionHistory(damaged)
ledger.ingest(1, [self.receipt("c", response={"reward": {"ke": 20}})], self.tasks.get)
self.assertIn("无法读取", ledger.query(1)["error"])
self.assertEqual(damaged.read_text(encoding="utf-8"), "not-json")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,369 @@
"""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()