"""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()