import json from types import SimpleNamespace import unittest from ranch_assistant.drop_statistics import SweepStatistics, analyze from ranch_assistant.sweeping import SweepPolicy, SweepRunner from ranch_assistant.tests.test_activities import FakeClient, scenario from ranch_assistant.tests.test_core import workspace_temp UNKNOWN_COST = object() def reward(number, **extra): return {"money": 32, "exp": 64, "items": [ {"typeId": 30005, "num": number}], "monsters": [], **extra} class OfflineRewardClient(FakeClient): """Successful wire-shaped replies; no transport or external configuration.""" def __init__(self, snapshot, events): super().__init__(snapshot) self.events = iter(events) self.trace = SimpleNamespace(events=[]) self.first_start = True def call(self, operation, payload=None): self.calls.append((operation, payload)) identifier = f"offline-{len(self.calls)}" if operation == "stageService/stageStart": if self.first_start: self.first_start = False body = {"resCode": 0, "triggerEvent": False} else: result, cost = next(self.events) event = {"resCode": 0, "hideStageId": None, "result": result} if cost is not UNKNOWN_COST: event["costTi"] = cost body = {"resCode": 0, "triggerEvent": True, "stageEvent": event} elif operation == "battleService/battleEnd": body = {"resCode": 0, "costTi": 16, "reward": reward(2)} else: body = {"resCode": 0} self.trace.events.append({"operation": operation, "kind": "response", "request_id": identifier, "http_status": 200, "body": body}) return body class CombinedDropStatisticsTests(unittest.TestCase): def setUp(self): self.catalog, self.snapshot = scenario() self.owner = self.snapshot.raw["master"]["id"] def test_runner_combines_settled_sweep_and_event_rewards(self): events = [ (reward(3), 16), (reward(0, items=[{"typeId": 99999999, "num": 4}]), 16), ({"money": 0, "exp": 0, "items": [], "monsters": []}, 16), (reward(5), 0), (reward(7), UNKNOWN_COST), ] runner = SweepRunner(self.catalog) client = OfflineRewardClient(self.snapshot, events) policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 6}}) for expected in ("sweep", "event", "event", "event", "event", "event"): stage = runner.next(self.snapshot, policy) self.assertIsNotNone(stage) runner.run(client, self.snapshot, stage, policy) self.assertEqual(runner.last_outcome, expected) self.assertEqual(runner.statistics_error, "") data = runner.statistics.snapshot(self.owner) totals, rows = analyze(self.catalog, data, "0101", "3", "all") self.assertEqual({key: totals[key] for key in ("n", "money", "exp", "spent", "known")}, {"n": 6, "money": 160, "exp": 320, "spent": 64, "known": 5}) common = next(row for row in rows if row["key"] == "item:30005") self.assertEqual((common["hits"], common["units"], common["cost_units"], common["rate"]), (4, 17, 10, 4 / 6)) self.assertEqual(common["average"], 17 / 6) self.assertEqual(common["per_stamina"], 10 / 64) event_only = next(row for row in rows if row["key"] == "item:99999999") self.assertEqual((event_only["configured"], event_only["hits"], event_only["units"], event_only["rate"]), (False, 1, 4, 1 / 6)) self.assertEqual(event_only["per_stamina"], 4 / 64) # Existing filters remain isolated, and zero/unknown-cost events still count as samples. self.assertEqual(analyze(self.catalog, data, "0101", "3")[0]["n"], 1) self.assertEqual(analyze(self.catalog, data, "0101", "3", "event")[0]["n"], 5) self.assertEqual(analyze(self.catalog, data, "0101", "3", "event")[1][0]["samples"], 5) def test_combined_scope_keeps_source_difficulty_and_owner_separate(self): store = SweepStatistics(self.catalog) self.assertTrue(store.record(self.owner, "0101", "3", "sweep", "shared", 1, reward(2), spent=16)) self.assertFalse(store.record(self.owner, "0101", "3", "sweep", "shared", 1, reward(2), spent=16)) store.record(self.owner, "0101", "3", "event", "event", 2, reward(3), spent=0) store.record(self.owner, "0101", "1", "event", "other-level", 3, reward(11), spent=16) store.record(2, "0101", "3", "event", "other-owner", 4, reward(13), spent=16) totals, rows = analyze(self.catalog, store.snapshot(self.owner), "0101", "3", "all") common = next(row for row in rows if row["key"] == "item:30005") self.assertEqual((totals["n"], totals["known"], totals["spent"]), (2, 2, 16)) self.assertEqual((common["units"], common["cost_units"], common["rate"]), (5, 5, 1)) self.assertEqual(common["per_stamina"], 5 / 16) self.assertEqual(analyze(self.catalog, store.snapshot(self.owner), "0101", "1", "all")[0]["n"], 1) self.assertEqual(analyze(self.catalog, store.snapshot(2), "0101", "3", "all")[0]["n"], 1) def test_history_import_adds_event_reward_and_deduplicates_live_request(self): battle = {"win": True, "leftTime": 0, "killNum": 0, "totalDamage": 0, "cheatNum": 0, "battlePosition": {"battleType": "stage", "stageId": "0101", "stageLevel": "3"}} entries = [ {"operation": "读取角色", "kind": "response", "body": {"master": {"id": self.owner}}}, {"operation": "battleService/battleEnd", "kind": "request", "request_id": "live-normal", "body": {"battleData": battle}}, {"operation": "battleService/battleEnd", "kind": "response", "request_id": "live-normal", "http_status": 200, "time": "2026-11-10T12:00:00+08:00", "body": {"resCode": 0, "costTi": 16, "reward": reward(2)}}, {"operation": "stageService/stageStart", "kind": "request", "request_id": "historic-event", "body": {"stageTypeId": "0101", "stageLevel": "3"}}, {"operation": "stageService/stageStart", "kind": "response", "request_id": "historic-event", "http_status": 200, "time": "2026-11-10T12:00:01+08:00", "body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"resCode": 0, "hideStageId": None, "costTi": 0, "result": reward(3)}}}, ] with workspace_temp() as folder: trace = folder / "network_debug.jsonl" text = "\n".join(json.dumps(entry) for entry in entries) trace.write_text(text, encoding="utf-8") trace.with_name("network_debug.previous.jsonl").write_text(text, encoding="utf-8") store = SweepStatistics(self.catalog) store.record(self.owner, "0101", "3", "sweep", "request:live-normal", 1, reward(2), spent=16) store.import_log(self.owner, trace) totals, rows = analyze(self.catalog, store.snapshot(self.owner), "0101", "3", "all") common = next(row for row in rows if row["key"] == "item:30005") self.assertEqual((totals["n"], totals["spent"], totals["known"]), (2, 16, 2)) self.assertEqual((common["units"], common["cost_units"], common["per_stamina"]), (5, 5, 5 / 16)) store.import_log(2, trace) self.assertEqual(store.snapshot(2)["totals"], {}) def test_reported_stage_scale_combines_all_rows_and_currency_totals(self): # Mirrors the read-only SQLite check without opening a user's database. store = SweepStatistics(self.catalog) for index in range(30): store.record(1, "0211", "3", "sweep", f"sweep-{index}", index, reward(0), spent=16) amounts = [26, 26, 26, 26, 26, 26, 26, 27] for index in range(42): items = [{"typeId": 30005 + offset, "num": amounts[offset]} for offset in range(8)] if index == 0 else [] store.record(1, "0211", "3", "event", f"event-{index}", 100 + index, {"money": 32, "exp": 64, "items": items}, spent=16) totals, rows = analyze(self.catalog, store.snapshot(1), "0211", "3", "all") self.assertEqual({key: totals[key] for key in ("n", "money", "exp", "spent", "known")}, {"n": 72, "money": 2304, "exp": 4608, "spent": 1152, "known": 72}) observed = [row for row in rows if row["units"]] self.assertEqual((len(observed), sum(row["units"] for row in observed)), (8, 209)) if __name__ == "__main__": unittest.main()