420 lines
23 KiB
Python
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()
|