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