Files

420 lines
23 KiB
Python

import copy
import json
import os
import unittest
from unittest.mock import patch
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from ranch_assistant.daily import DailyLedger, DailyPolicy, entries
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.maps import reward_summary, stages
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.quests import condition_ok
from ranch_assistant.sweeping import SweepPolicy, SweepRunner
from ranch_assistant.tests.test_core import workspace_temp
def scenario():
catalog = Catalog()
# One ordinary stage, one not fully passed, one special activity.
catalog.data["stage_info"] = {k: catalog.data["stage_info"][k] for k in ("0101", "0102", "bd00")}
snapshot = demo_snapshot(catalog)
for mon in snapshot.raw["monsters"]:
if mon.get("process") == 2:
mon["mode"] = snapshot.expected_growth_mode(mon, catalog)
snapshot.raw["history"].update(unlockStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]},
passStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]})
snapshot.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900, 0]}]
yesterday = snapshot.now - 86400
snapshot.raw["activityHistory"] = {"dailyCheck": {"checkDay": 2, "checkTime": yesterday * 1000},
"dailyGift": {"dailyGiftCheckTime": yesterday * 1000, "dailyGiftLevel": 2, "dailyGiftCount": 2, "dailyRewardGetTime": None}, "vipInfo": None}
snapshot.raw["mails"] = [{"id": 12, "title": "测试邮件", "createTime": snapshot.now * 1000,
"isGetReward": 0, "reward": json.dumps({"money": 500, "items": [{"type": "30005", "num": 2}]})}]
return catalog, snapshot
class FakeClient:
def __init__(self, snapshot):
self.value = copy.deepcopy(snapshot.raw)
self.calls = []
self.trigger = False
self.fail = ""
def snapshot(self):
return Snapshot(copy.deepcopy(self.value))
def call(self, path, payload=None):
self.calls.append((path, payload))
if path == self.fail:
raise TimeoutError("test timeout")
if path == "stageService/stageStart":
return {"resCode": 0, "triggerEvent": self.trigger}
return {"resCode": 0, "reward": {"money": 1}}
class ActivityTests(unittest.TestCase):
def setUp(self):
self.catalog, self.snapshot = scenario()
def stage(self, key="0101", level="3"):
return next(s for s in stages(self.catalog, self.snapshot) if s.stage_id == key and s.level == level)
def test_wire_progress_star_difficulty_gates_and_drops(self):
first = self.stage()
self.assertTrue(first.unlocked and first.passed and first.sweep)
self.assertEqual((first.number, first.city_name, first.stars), ("1-1", "莉莉托斯", 3))
self.assertIn("金币", first.drops)
self.assertIn("绿色史莱姆蛋", self.stage(level="2").drops)
self.assertTrue(condition_ok({"passStage": ["0101"]}, self.snapshot))
self.assertFalse(self.stage("0102", "2").unlocked)
self.assertFalse(self.stage("0102", "1").sweep)
self.assertFalse(self.stage("bd00").sweep)
self.catalog.data["game_setting"]["cityInfo"]["1"]["openExtraModeStage"] = "locked_gate"
self.assertFalse(self.stage().unlocked)
def test_reward_text_does_not_treat_zero_rolls_as_drops(self):
reward = {"rewards": [{"num": 0, "monsters": [{"name": "1001010"}], "items": [{"name": "30005,1,2"}], "item_num": 0}]}
self.assertEqual(reward_summary(self.catalog, reward), "")
self.assertEqual(reward_summary(self.catalog, "bad json"), "附件格式未知")
def test_sweep_official_sequence_and_per_role_daily_limits(self):
with workspace_temp() as folder:
runner = SweepRunner(self.catalog, folder / "runs.json")
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 1}})
client = FakeClient(self.snapshot)
runner.run(client, self.snapshot, self.stage(), policy)
self.assertEqual([p for p, _ in client.calls], ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
data = client.calls[1][1]["battleData"]
self.assertEqual(data["battleMonIds"], [900])
self.assertEqual(data["battlePosition"]["stageLevel"], "3")
self.assertIsNone(runner.state["pending"])
restored = SweepRunner(self.catalog, folder / "runs.json")
self.assertIsNone(restored.next(self.snapshot, policy))
with self.assertRaises(ValueError):
restored.run(client, self.snapshot, self.stage(), policy)
self.snapshot.raw["master"]["id"] = 2
self.assertIsNotNone(restored.next(self.snapshot, policy))
def test_sweep_stops_on_events_and_unknown_or_failed_start(self):
for trigger in (True, None):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
client = FakeClient(self.snapshot)
client.trigger = trigger
with self.assertRaises(ValueError):
runner.run(client, self.snapshot, self.stage(), policy)
self.assertEqual(len(client.calls), 1)
self.assertTrue(runner.state["pending"])
with workspace_temp() as folder:
runner = SweepRunner(self.catalog, folder / "runs.json")
client.fail = "stageService/stageStart"
with self.assertRaises(TimeoutError):
runner.run(client, self.snapshot, self.stage(), policy)
self.assertTrue(SweepRunner(self.catalog, folder / "runs.json").state["pending"])
def test_reward_event_is_already_settled_and_does_not_block_next_sweep(self):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
client = FakeClient(self.snapshot)
response = {"resCode": 0, "triggerEvent": True, "stageEvent": {"resCode": 0,
"typeId": "300007", "hideStageId": None, "costTi": 16,
"result": {"money": 32, "exp": 64, "items": [], "monsters": [], "ti": 0, "ke": 0}}}
def call(path, payload=None):
client.calls.append((path, payload))
if path == "stageService/stageStart":
return response
raise AssertionError("Reward events do not submit a battle result")
client.call = call
result = runner.run(client, self.snapshot, self.stage(), policy)
self.assertIs(result, response)
self.assertIsNone(runner.state["pending"])
self.assertIsNotNone(runner.next(self.snapshot, policy))
self.assertEqual(len(client.calls), 1)
def test_legacy_event_block_recovers_only_from_role_matched_successful_reward_reply(self):
with workspace_temp() as folder:
trace = folder / "network_debug.jsonl"
for role, hidden, http_status, recovered in ((123456, None, 200, False),
(self.snapshot.raw["master"]["id"], "hidden", 200, False),
(self.snapshot.raw["master"]["id"], None, 500, False),
(self.snapshot.raw["master"]["id"], None, 200, True)):
runner = SweepRunner(self.catalog)
runner.state["pending"] = {"stage": "0101", "level": "3", "phase": "遇到事件或响应缺少事件状态,请在游戏内处理"}
records = [{"kind": "response", "operation": "读取角色", "body": {"master": {"id": role}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "test-1",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "test-1", "http_status": http_status,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": hidden, "result": {"money": 32}}}}]
trace.write_text("\n".join(json.dumps(row) for row in records), encoding="utf-8")
self.assertEqual(runner.recover_reward_event(self.snapshot, trace), recovered)
self.assertEqual(runner.state["pending"] is None, recovered)
def test_hidden_stage_event_waits_for_real_battle_without_submitting_a_result(self):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
client = FakeClient(self.snapshot)
client.call = unittest.mock.Mock(return_value={"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "hidden", "result": {"money": 1}}})
with self.assertRaisesRegex(ValueError, "隐藏关卡"):
runner.run(client, self.snapshot, self.stage(), policy)
client.call.assert_called_once_with("stageService/stageStart", {"stageTypeId": "0101", "stageLevel": "3"})
self.assertIsNone(runner.next(self.snapshot, policy))
def test_sweep_checks_team_stamina_and_active_story_before_writes(self):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}, keep_stamina=999)
self.assertIn("体力", runner.reason(self.snapshot, self.stage(), policy))
policy.keep_stamina = 0
policy.team = "teamC"
self.assertIn("战队", runner.reason(self.snapshot, self.stage(), policy))
policy.team = "teamA"
self.catalog.data["stage_task_positions"]["test"] = ["city1_wild_stage0101_level3"]
self.snapshot.raw["currentTasks"] = [{"typeId": "test", "curStep": 1}]
self.assertIn("剧情", runner.reason(self.snapshot, self.stage(), policy))
def test_daily_claim_eligibility_mail_json_and_null_vip(self):
rows = {r.key: r for r in entries(self.catalog, self.snapshot)}
self.assertTrue(rows["gift"].action and rows["check"].action and rows["mail:12"].action)
self.assertIsNone(rows["vip"].action)
self.assertIsNone(rows["loop"].action)
self.assertIn("500", rows["mail:12"].reward)
self.snapshot.raw["activityHistory"]["dailyCheck"].update(checkDay=7, checkTime=None)
self.snapshot.raw["mails"][0]["isGetReward"] = 1
rows = {r.key: r for r in entries(self.catalog, self.snapshot)}
self.assertIsNone(rows["check"].action)
self.assertIsNone(rows["mail:12"].action)
def test_daily_time_units_and_midnight_reset(self):
with workspace_temp() as folder:
ledger = DailyLedger(folder / "claims.json")
ledger.record(self.snapshot, "gift")
self.assertTrue(ledger.seen(self.snapshot, "gift"))
self.assertIsNone(next(r for r in entries(self.catalog, self.snapshot, ledger) if r.key == "gift").action)
self.snapshot.server_offset += 86400
self.assertFalse(DailyLedger(folder / "claims.json").seen(self.snapshot, "gift"))
self.snapshot.raw["activityHistory"]["dailyGift"]["dailyGiftCheckTime"] = self.snapshot.now
self.assertIsNone(next(r for r in entries(self.catalog, self.snapshot) if r.key == "gift").action)
def test_refresh_does_not_claim_and_manual_claims_do_not_repeat_stale_data(self):
client = FakeClient(self.snapshot)
engine = Engine(self.catalog, client)
engine.policy.enabled = False
engine.daily_policy = DailyPolicy(True, ["gift", "mail"])
engine.poll()
self.assertEqual(client.calls, [])
_, _, message = engine.claim_daily()
self.assertIn("2", message)
self.assertEqual([p for p, _ in client.calls], ["dailyGiftService/dailyGiftSign", "mailService/mailGetReward"])
engine.claim_daily()
self.assertEqual(len(client.calls), 2)
def test_auto_daily_is_one_action_and_no_purchase_or_vip_activation(self):
client = FakeClient(self.snapshot)
engine = Engine(self.catalog, client)
engine.policy.enabled = False
engine.daily_policy = DailyPolicy(True, ["gift", "check", "vip", "mail"])
engine.auto = True
engine.poll()
self.assertEqual(len(client.calls), 1)
self.assertEqual(client.calls[0][0], "dailyGiftService/dailyGiftSign")
def test_failed_daily_request_is_not_repeated_after_restart(self):
with workspace_temp() as folder:
client = FakeClient(self.snapshot)
client.fail = "dailyGiftService/dailyGiftSign"
engine = Engine(self.catalog, client, folder / "purchase.json")
engine.policy.enabled = False
engine.daily_policy = DailyPolicy(True, ["gift"])
with self.assertRaises(TimeoutError):
engine.claim_daily()
engine = Engine(self.catalog, client, folder / "purchase.json")
engine.policy.enabled = False
engine.daily_policy = DailyPolicy(True, ["gift"])
engine.claim_daily()
self.assertEqual(len(client.calls), 1)
def test_auto_sweep_and_end_timeout_never_retry_settlement(self):
with workspace_temp() as folder:
client = FakeClient(self.snapshot)
client.fail = "battleService/battleEnd"
engine = Engine(self.catalog, client, folder / "purchase.json")
engine.policy.enabled = False
engine.sweep_policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
engine.auto = True
with self.assertRaises(TimeoutError):
engine.poll()
self.assertEqual(len(client.calls), 2)
restored = Engine(self.catalog, client, folder / "purchase.json")
restored.policy.enabled = False
restored.sweep_policy = engine.sweep_policy
restored.auto = True
restored.poll()
self.assertEqual(len(client.calls), 2)
class ActivityGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from PySide6.QtWidgets import QApplication
cls.app = QApplication.instance() or QApplication([])
def wait(self, predicate):
from PySide6.QtTest import QTest
for _ in range(700):
self.app.processEvents()
QTest.qWait(2)
if predicate():
return
self.fail("Qt worker or autosave did not finish")
def test_challenge_checkbox_autosave_import_restore_and_legacy_default(self):
from ranch_assistant.gui import Window
from ranch_assistant.policy_io import portable_config
with workspace_temp() as folder:
window = Window(state_root=folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
self.assertTrue(window.map_allow_challenge.isChecked())
self.assertEqual(window.map_allow_challenge.text(), "未满星时自动挑战")
self.assertEqual(window.tabs.tabText(window.tabs.indexOf(window.map_page)), "自动扫荡")
window.map_enabled.setChecked(True)
window.map_keep_ti.setValue(17)
window.map_team.setCurrentIndex(window.map_team.findData("teamB"))
window.map_rules = {"0102": {"enabled": True, "level": "2", "limit": 12}}
window.map_allow_challenge.click()
self.assertTrue(window.auto_save_timer.isActive())
self.wait(lambda: not window.auto_save_timer.isActive())
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))["sweep_policy"]
self.assertFalse(saved["allow_challenge"])
self.assertFalse(window.engine.sweep_policy.allow_challenge)
self.assertEqual((saved["keep_stamina"], saved["team"], saved["rules"]["0102"]["limit"]), (17, "teamB", 12))
exported = portable_config(window.config_value(), window.engine.snapshot)
self.assertFalse(exported["sweep_policy"]["allow_challenge"])
path = folder / "import.json"
for allowed in (True, False):
with self.subTest(imported_challenge=allowed):
exported["sweep_policy"]["allow_challenge"] = allowed
path.write_text(json.dumps(exported), encoding="utf-8")
with patch("ranch_assistant.gui.W.QFileDialog.getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertEqual(window.map_allow_challenge.isChecked(), allowed)
self.assertEqual(window.read_sweep_policy().allow_challenge, allowed)
self.assertEqual(window.engine.sweep_policy.allow_challenge, allowed)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertEqual(window.map_rules["0102"], {"enabled": True, "level": "2", "limit": 12})
finally:
window.close()
restored = Window(state_root=folder)
restored.timer.stop()
try:
self.wait(lambda: not restored.busy and restored.engine.snapshot is not None)
self.assertFalse(restored.map_allow_challenge.isChecked())
self.assertFalse(restored.read_sweep_policy().allow_challenge)
legacy = restored.config_value()
del legacy["sweep_policy"]["allow_challenge"]
restored.load_config(legacy)
self.assertTrue(restored.map_allow_challenge.isChecked())
self.assertTrue(restored.read_sweep_policy().allow_challenge)
self.assertFalse(restored.auto_save_timer.isActive())
finally:
restored.close()
def test_map_stop_cancels_only_pending_map_battles(self):
from ranch_assistant.gui import Window
with workspace_temp() as folder:
window = Window(state_root=folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
window.busy = True
for kind in (None, "progression_battle", "map_battle"):
for control, field in ((window.map_allow_challenge, "allow_challenge"), (window.map_enabled, "enabled")):
window.map_enabled.setChecked(True)
window.map_allow_challenge.setChecked(True)
window.engine.sweep_policy = window.read_sweep_policy()
window.update_policy()
pending = {"kind": kind} if kind else None
with self.subTest(pending=kind, stopped=field), \
patch.object(window.engine.battle_journal, "pending", return_value=pending), \
patch.object(window.engine, "cancel_progression", wraps=window.engine.cancel_progression) as cancel:
window.engine.auto = True
control.setChecked(False)
self.assertFalse(getattr(window.engine.sweep_policy, field))
self.assertFalse(getattr(window.pending_policy["sweep_policy"], field))
if kind == "map_battle":
self.assertFalse(window.engine.auto)
cancel.assert_called_once_with()
else:
self.assertTrue(window.engine.auto)
cancel.assert_not_called()
self.assertTrue(window.auto_save_timer.isActive())
with patch.object(window.engine, "cancel_progression") as cancel:
window.map_keep_ti.setValue(10)
cancel.assert_not_called()
finally:
window.busy = False
window.close()
def test_tree_rules_daily_page_and_scroll_layout(self):
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
with workspace_temp() as folder:
window = Window(state_root=folder)
window.timer.stop()
try:
for _ in range(150):
self.app.processEvents()
QTest.qWait(5)
if not window.busy:
break
catalog, snapshot = scenario()
window.catalog = catalog
window.engine = Engine(catalog)
window.engine.snapshot = snapshot
window.render_maps()
for _ in range(200):
if not window.map_render_timer.running:
break
QTest.qWait(5)
self.assertFalse(window.map_render_timer.running)
window.render_daily()
self.assertEqual(window.maps_tree.topLevelItem(0).text(0), "莉莉托斯")
region = window.maps_tree.topLevelItem(0)
first = region.child(0)
first.setCheckState(0, C.Qt.CheckState.Checked)
self.assertTrue(window.map_rules["0101"]["enabled"])
difficulty = window.maps_tree.itemWidget(region.child(1), 3)
self.assertFalse(difficulty.model().item(1).isEnabled())
window.maps_tree.itemWidget(first, 8).setText("12")
self.assertEqual(window.map_rules["0101"]["limit"], 12)
self.assertGreater(window.daily_table.rowCount(), 4)
window.save_config(quiet=True)
settings = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(settings["sweep_policy"]["rules"]["0101"]["limit"], 12)
window.resize(1100, 650)
window.show()
window.tabs.setCurrentWidget(window.automation_page)
window.automation_tabs.setCurrentWidget(window.policy_scroll)
window.log_splitter.setSizes([180, 450])
self.app.processEvents()
self.assertGreater(window.policy_scroll.verticalScrollBar().maximum(), 0)
self.assertEqual(window.styleSheet(), "")
finally:
window.close()
restored = Window(state_root=folder)
restored.timer.stop()
try:
for _ in range(150):
self.app.processEvents()
QTest.qWait(5)
if not restored.busy:
break
self.assertEqual(restored.map_rules["0101"]["limit"], 12)
self.assertFalse(restored.strategy_toggle.isChecked())
self.assertFalse(restored.monitoring)
finally:
restored.close()