Record sweep rewards and add local drop and stamina analysis
This commit is contained in:
@@ -93,11 +93,12 @@ class RemovalTests(unittest.TestCase):
|
||||
(folder / "sessions" / "old.json").write_text("synthetic", encoding="utf-8")
|
||||
(folder / "roles" / "role").mkdir(parents=True)
|
||||
(folder / "roles" / "role" / "maps.json").write_text("{}", encoding="utf-8")
|
||||
(folder / "sweep_rewards.sqlite3").write_text("synthetic statistics", encoding="utf-8")
|
||||
shared = folder / "shared-note.txt"
|
||||
shared.write_text("keep", encoding="utf-8")
|
||||
try:
|
||||
self.remove(hub, "default")
|
||||
for name in ("credentials.json", "sessions", "roles", "settings.json"):
|
||||
for name in ("credentials.json", "sessions", "roles", "settings.json", "sweep_rewards.sqlite3"):
|
||||
self.assertFalse((folder / name).exists())
|
||||
self.assertTrue(sentinel.exists())
|
||||
self.assertTrue(shared.exists())
|
||||
|
||||
@@ -0,0 +1,256 @@
|
||||
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, {"items": []})
|
||||
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.assertIn("2 个已确认样本", 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, 5).text(), "50.00%")
|
||||
self.assertEqual(page.table.item(row, 7).text(), "0.25")
|
||||
page.chart_metric.setCurrentIndex(page.chart_metric.findData("per_stamina"))
|
||||
self.assertEqual(page.chart_view.chart().title(), "每点体力数量")
|
||||
page.source.setCurrentIndex(page.source.findData("event"))
|
||||
self.assertIn("1 个已确认样本", page.summary.text())
|
||||
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()
|
||||
Reference in New Issue
Block a user