Files
myrzx_bot/ranch_assistant/tests/test_drop_statistics.py
T
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

281 lines
17 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import copy
import json
import os
import sqlite3
from types import SimpleNamespace
import unittest
from unittest.mock import patch
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.drop_statistics import SweepStatistics, analyze, normalize_reward, reward_text
from ranch_assistant.engine import Engine
from ranch_assistant.gui import Window
from ranch_assistant.statistics_gui import StatisticsPage
from ranch_assistant.model import Catalog
from ranch_assistant.sweeping import SweepPolicy, SweepRunner
from ranch_assistant.tests.test_activities import scenario, FakeClient
from ranch_assistant.tests.test_core import workspace_temp
REWARD = {"money": 32, "exp": 64, "ke": 0, "ti": 0, "items": [
{"id": 100, "typeId": 30005, "num": 2}, {"id": 100, "typeId": 30005, "num": 3},
{"id": 101, "typeId": 1001010, "num": 1}], "monsters": []}
class DropStatisticsTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
def test_quantity_is_aggregated_but_presence_is_counted_once_per_sample(self):
store = SweepStatistics(self.catalog)
store.record(1, "0101", "3", "sweep", "one", 1000, REWARD)
store.record(1, "0101", "3", "sweep", "two", 1001, {"money": 32, "items": []})
totals, rows = analyze(self.catalog, store.snapshot(1), "0101", "3")
item = next(row for row in rows if row["key"] == "item:30005")
self.assertEqual((item["hits"], item["units"], item["samples"], item["rate"], item["average"]), (1, 5, 2, .5, 2.5))
self.assertEqual(totals["money"], 64)
self.assertLessEqual(item["interval"][0], .5)
self.assertGreaterEqual(item["interval"][1], .5)
self.assertIn("×5", reward_text(normalize_reward(self.catalog, REWARD)))
def test_items_per_stamina_uses_known_cost_totals_and_ignores_unknown_samples(self):
store = SweepStatistics(self.catalog)
store.record(1, "0101", "3", "sweep", "one", 1, {"items": [{"typeId": 30005, "num": 5}]}, spent=10)
store.record(1, "0101", "3", "sweep", "two", 2, {"items": [{"typeId": 30005, "num": 2}]}, spent=20)
store.record(1, "0101", "3", "sweep", "unknown", 3, {"items": [{"typeId": 30005, "num": 7}]})
total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3")
row = next(row for row in rows if row["key"] == "item:30005")
self.assertEqual((total["known"], total["spent"], total["n"]), (2, 30, 3))
self.assertEqual((row["units"], row["cost_units"]), (14, 7))
self.assertAlmostEqual(row["per_stamina"], 7 / 30)
self.assertIsNone(next(row for row in analyze(self.catalog, store.snapshot(1), "0102", "1")[1])["per_stamina"])
def test_zero_stamina_and_refunds_do_not_create_infinite_or_net_cost_efficiency(self):
store = SweepStatistics(self.catalog)
store.record(1, "0101", "3", "event", "free", 1, {"items": [{"typeId": 30005, "num": 2}]}, spent=0)
total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3", "event")
self.assertEqual(total["known"], 1)
self.assertTrue(all(row["per_stamina"] is None for row in rows))
store.record(1, "0101", "1", "event", "refund", 2, {"ti": 5, "items": [{"typeId": 30005, "num": 2}]}, spent=5)
total, rows = analyze(self.catalog, store.snapshot(1), "0101", "1", "event")
self.assertEqual((total["spent"], total["ti"]), (5, 5))
self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["per_stamina"], .4)
def test_earlier_database_without_known_cost_columns_keeps_rewards_and_migrates(self):
with workspace_temp() as folder:
path = folder / "old.sqlite3"
db = sqlite3.connect(path)
try:
db.executescript("""CREATE TABLE totals(owner TEXT,stage TEXT,level TEXT,kind TEXT,n INTEGER,money INTEGER,exp INTEGER,ke INTEGER,ti INTEGER,spent INTEGER,PRIMARY KEY(owner,stage,level,kind));
CREATE TABLE drops(owner TEXT,stage TEXT,level TEXT,kind TEXT,key TEXT,typeId TEXT,category TEXT,name TEXT,hits INTEGER,units INTEGER,PRIMARY KEY(owner,stage,level,kind,key));
INSERT INTO totals VALUES('1','0101','3','sweep',1,32,64,0,0,16);
INSERT INTO drops VALUES('1','0101','3','sweep','item:30005','30005','item','sample',1,2);""")
db.commit()
finally:
db.close()
store = SweepStatistics(self.catalog, path)
total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3")
self.assertEqual((total["n"], total["known"], total["spent"]), (1, 0, 0))
self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["units"], 2)
store.record(1, "0101", "3", "sweep", "new", 2, {"items": [{"typeId": 30005, "num": 3}]}, spent=10)
self.assertEqual(next(r for r in analyze(self.catalog, store.snapshot(1), "0101", "3")[1] if r["key"] == "item:30005")["per_stamina"], .3)
def test_role_difficulty_source_and_repeated_response_are_isolated_after_restart(self):
with workspace_temp() as folder:
path = folder / "rewards.sqlite3"
store = SweepStatistics(self.catalog, path)
self.assertTrue(store.record(1, "0101", "3", "sweep", "same", 1, REWARD))
self.assertFalse(store.record(1, "0101", "3", "sweep", "same", 1, REWARD))
store.record(1, "0101", "1", "sweep", "difficulty", 2, REWARD)
store.record(1, "0101", "3", "event", "event", 3, {"items": []})
store.record(2, "0101", "3", "sweep", "same", 4, REWARD)
restored = SweepStatistics(self.catalog, path)
totals, rows = analyze(self.catalog, restored.snapshot(1), "0101", "3", "all")
self.assertEqual(totals["n"], 2)
self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["rate"], .5)
self.assertEqual(analyze(self.catalog, restored.snapshot(2), "0101", "3")[0]["n"], 1)
def test_no_samples_and_unobserved_static_drop_are_distinguished(self):
store = SweepStatistics(self.catalog)
_, rows = analyze(self.catalog, store.snapshot(1), "0101", "3")
self.assertTrue(rows)
self.assertTrue(all(row["rate"] is None for row in rows))
store.record(1, "0101", "3", "sweep", "one", 1, {"items": [{"typeId": 99999999, "num": 1}]})
_, rows = analyze(self.catalog, store.snapshot(1), "0101", "3")
self.assertTrue(all(row["rate"] == 0 for row in rows if row["configured"]))
unknown = next(row for row in rows if row["key"] == "item:99999999")
self.assertFalse(unknown["configured"])
self.assertEqual(unknown["rate"], 1)
def test_malformed_or_missing_reward_does_not_add_a_sample(self):
store = SweepStatistics(self.catalog)
for reward in (None, {"items": [{"typeId": 30005, "num": None}]}, {"items": [{"typeId": 30005, "num": -1}]}):
with self.assertRaises((ValueError, TypeError)):
store.record(1, "0101", "3", "sweep", "bad", 1, reward)
self.assertEqual(store.snapshot(1)["totals"], {})
def test_log_backfill_matches_role_and_deduplicates_live_and_rotated_records(self):
with workspace_temp() as folder:
path = folder / "network_debug.jsonl"
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": 1}}},
{"operation": "battleService/battleEnd", "kind": "request", "request_id": "normal", "body": {"battleData": battle}},
{"operation": "battleService/battleEnd", "kind": "response", "request_id": "normal", "http_status": 200,
"time": "2026-11-08T12:00:00+08:00", "body": {"resCode": 0, "reward": REWARD}},
{"operation": "stageService/stageStart", "kind": "request", "request_id": "event", "body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"operation": "stageService/stageStart", "kind": "response", "request_id": "event", "http_status": 200,
"time": "2026-11-08T12:00:01+08:00", "body": {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": None, "result": {"items": []}}}}]
text = "\n".join(json.dumps(row) for row in entries)
path.write_text(text, encoding="utf-8")
path.with_name("network_debug.previous.jsonl").write_text(text, encoding="utf-8")
store = SweepStatistics(self.catalog, folder / "stats.sqlite3")
store.record(1, "0101", "3", "sweep", "request:normal", 1, REWARD)
store.import_log(1, path)
self.assertEqual(analyze(self.catalog, store.snapshot(1), "0101", "3", "all")[0]["n"], 2)
store.import_log(2, path)
self.assertEqual(store.snapshot(2)["totals"], {})
restored = SweepStatistics(self.catalog, folder / "stats.sqlite3")
restored.import_log(1, path)
self.assertEqual(analyze(self.catalog, restored.snapshot(1), "0101", "3", "all")[0]["n"], 2)
def test_confirmed_reward_is_saved_before_later_record_request_failure(self):
catalog, snapshot = scenario()
runner = SweepRunner(catalog)
client = FakeClient(snapshot)
client.fail = "battleService/recordBattleResult"
stage = runner.next(snapshot, SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}))
with self.assertRaises(TimeoutError):
runner.run(client, snapshot, stage, SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}))
self.assertEqual(runner.statistics.snapshot(snapshot.raw["master"]["id"])["totals"]["0101:3:sweep"]["n"], 1)
self.assertIsNone(runner.state["pending"])
def test_local_statistics_failure_does_not_repeat_or_interrupt_sweep_settlement(self):
catalog, snapshot = scenario()
runner = SweepRunner(catalog)
client = FakeClient(snapshot)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
with patch.object(runner.statistics, "record", side_effect=OSError("synthetic failure")):
runner.run(client, snapshot, runner.next(snapshot, policy), policy)
self.assertIsNone(runner.state["pending"])
self.assertEqual(len(client.calls), 3)
self.assertIn("未写入", runner.statistics_error)
def test_engine_reports_normal_sweep_rewards(self):
catalog, snapshot = scenario()
client = FakeClient(snapshot)
engine = Engine(catalog, client)
engine.policy.enabled = False
engine.sweep_policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
engine.auto = True
_, _, message = engine.poll()
self.assertIn("扫荡完成", message)
self.assertIn("金币 1", message)
class AnalysisGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, predicate):
for _ in range(1000):
self.app.processEvents()
QTest.qWait(2)
if predicate():
return
self.fail("Analysis rendering did not finish")
def test_static_stage_selection_table_chart_and_source_filter(self):
catalog, snapshot = scenario()
store = SweepStatistics(catalog)
store.record(1, "0101", "3", "sweep", "one", 1, REWARD, spent=10)
store.record(1, "0101", "3", "sweep", "two", 2, {"items": []}, spent=10)
store.record(1, "0101", "3", "event", "three", 3,
{"money": 16, "exp": 32, "items": [{"typeId": 99999999, "num": 3}]}, spent=8)
store.record(1, "0101", "3", "event", "event-two", 4,
{"money": 0, "exp": 0, "items": [{"typeId": 99999999, "num": 1}]}, spent=8)
page = StatisticsPage(catalog)
try:
page.set_data(catalog, store.snapshot(1))
self.wait(lambda: not page.row_batch.running)
self.assertEqual(page.current_key, ("0101", "3"))
self.assertEqual(page.source.currentData(), "all")
self.assertEqual(page.source.currentText(), "扫荡+奖励事件")
self.assertIn("合计 4 个已确认样本(扫荡 2 + 奖励事件 2)", page.summary.text())
self.assertIn("累计金币 48、经验 96", page.summary.text())
self.assertIn("已知体力消耗样本 4/4;消耗体力 36", page.summary.text())
self.assertTrue(page.chart_view.chart().series())
row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == catalog.data["item_names"]["30005"])
self.assertEqual([page.table.item(row, column).text() for column in (2, 3, 4, 5, 7)],
["1", "5", "4", "25.00%", "0.138889"])
event_row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == "物品 #99999999")
self.assertEqual([page.table.item(event_row, column).text() for column in (2, 3, 4, 5, 7, 9)],
["2", "4", "4", "50.00%", "0.111111", "实际观测"])
series = page.chart_view.chart().series()[0]
categories = series.attachedAxes()[1].categories()
self.assertEqual(series.barSets()[0].at(categories.index(catalog.data["item_names"]["30005"])), 25)
self.assertEqual(series.barSets()[0].at(categories.index("物品 #99999999")), 50)
page.chart_metric.setCurrentIndex(page.chart_metric.findData("per_stamina"))
self.assertEqual(page.chart_view.chart().title(), "每点体力数量")
page.source.setCurrentIndex(page.source.findData("sweep"))
self.assertIn("普通扫荡:2 个已确认样本", page.summary.text())
row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == catalog.data["item_names"]["30005"])
self.assertEqual([page.table.item(row, column).text() for column in (4, 5, 7)], ["2", "50.00%", "0.25"])
self.assertNotIn("物品 #99999999", [page.table.item(i, 0).text() for i in range(page.table.rowCount())])
page.source.setCurrentIndex(page.source.findData("event"))
self.assertIn("奖励事件:2 个已确认样本", page.summary.text())
self.assertIn("累计金币 16、经验 32", page.summary.text())
event_row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == "物品 #99999999")
self.assertEqual([page.table.item(event_row, column).text() for column in (4, 5, 7)], ["2", "100.00%", "0.25"])
row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == catalog.data["item_names"]["30005"])
self.assertEqual([page.table.item(row, column).text() for column in (4, 5, 7)], ["2", "0.00%", "0"])
page.tree.setCurrentItem(page.level_items["0102", "1"])
self.assertIn("尚无此范围的样本", page.summary.text())
self.assertTrue(all(page.table.item(i, 5).text() == "—" for i in range(page.table.rowCount())))
finally:
page.row_batch.stop()
page.close()
def test_analysis_tab_is_next_to_sweeping_and_refresh_is_local_only(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
self.assertEqual(labels[labels.index("自动扫荡") + 1], "数据分析")
window.tabs.setCurrentWidget(window.analysis_page)
self.wait(lambda: not window.analysis_page.row_batch.running)
with patch.object(window.engine, "poll", side_effect=AssertionError("Analysis must not refresh game state")):
owner = window.engine.snapshot.raw["master"]["id"]
window.engine.sweeper.statistics.record(owner, "0101", "3", "sweep", "local-refresh", 1, REWARD, spent=16)
window.refresh_page(window.analysis_page)
self.wait(lambda: not window.busy)
window.tabs.setCurrentWidget(window.slot_page)
window.tabs.setCurrentWidget(window.analysis_page)
self.assertEqual(window.analysis_page.data["totals"]["0101:3:sweep"]["n"], 1)
self.assertIn("本地", window.log.toPlainText())
finally:
window.close()
def test_paused_large_stage_tree_resumes_when_new_statistics_arrive(self):
catalog = Catalog()
store = SweepStatistics(catalog)
page = StatisticsPage(catalog)
try:
page.set_data(catalog, store.snapshot(1))
page.row_batch.stop()
store.record(1, "0101", "3", "sweep", "one", 1, REWARD, spent=16)
page.set_data(catalog, store.snapshot(1))
self.wait(lambda: not page.row_batch.running)
self.assertEqual(len(page.level_items), sum(len(stage.get("level", {})) for stage in catalog.data["stage_info"].values()))
self.assertEqual(page.current_key, ("0101", "3"))
finally:
page.row_batch.stop()
page.close()