Files
myrzx_bot/ranch_assistant/tests/test_combined_drop_statistics.py
AttilaNet 0109cc0d1c Include event rewards by default in drop analysis
Default statistics to combined sweep and event samples, show the source counts, and verify merged rewards and stamina efficiency across live-shaped and imported settlements.
2026-11-10 12:03:22 +08:00

157 lines
8.5 KiB
Python

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