406 lines
24 KiB
Python
406 lines
24 KiB
Python
"""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()
|