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