import os os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") from dataclasses import asdict from types import SimpleNamespace import copy import json import threading import time import unittest from unittest.mock import Mock, patch from PySide6 import QtCore as C, QtWidgets as W from PySide6.QtTest import QTest from ranch_assistant import gui from ranch_assistant.policy_io import import_config, portable_config from ranch_assistant.progression import ProgressionPolicy from ranch_assistant.progression_gui import CachedTable, prepare_progression_views from ranch_assistant.tests.test_core import workspace_temp def configured_policy(): policy = ProgressionPolicy(enabled=True, mainline=True, sidequests=True, commissions=True, accept=False, auto_dialogue=False, team="teamC", reserve_ti=24, allow_sweep=False, max_money=42, allow_items=True, allow_monsters=True, item_reserves={"30001": 17}, stop_after_loss=3, repair_chain=False, battle_mode="experimental") if hasattr(policy, "auto_farm"): policy.auto_farm = False return policy TASKS = [ {"task_type_id": "1001", "name": "主线测试", "category": "mainline", "state": "active", "step_number": 2, "total_steps": 4, "position": "地图0101", "requirement": "与NPC对话", "next_action": "dialogue", "battle_kind": "task_battle", "dialogue": "测试对话内容", "supported": True, "status": "等待对话"}, {"task_type_id": "1002", "name": "支线测试", "category": "sidequest", "state": "blocked", "step_number": 1, "total_steps": 2, "position": "地图0102", "requirement": "战斗", "next_action": "", "battle_kind": "task_battle", "supported": False, "blocked_reason": "战斗运行时尚未支持"}, {"task_type_id": "1003", "name": "委托测试", "category": "commission", "state": "available", "step_number": 0, "total_steps": 1, "position": "村庄", "requirement": "物品", "next_action": "accept", "battle_kind": ""}, {"task_type_id": "1004", "name": "未知测试", "category": "new_category", "state": 999, "step_number": None, "total_steps": None, "position": None, "requirement": None, "next_action": None, "battle_kind": None}, ] RECORDS = [ {"timestamp": 1700000000, "battle_kind": "task_battle", "task_type_id": "1001", "team": "teamC", "outcome": "unsupported", "reason": "未支持"}, {"timestamp": 1700000001, "battle_kind": "sweep", "stage_id": "0101", "outcome": "completed", "message": "扫荡记录"}, {"timestamp": 1700000002, "battle_kind": "map_reward_event", "stage_id": "0102", "outcome": "event", "message": "奖励事件"}, ] class ProgressionPolicyIOTests(unittest.TestCase): def test_round_trip_preserves_choices_without_session_or_runtime_state(self): policy = configured_policy() source = {"progression_policy": asdict(policy), "token": "test-secret", "account": "private-account", "progression_records": RECORDS, "progression_rows": TASKS, "runtime_path": "private-runtime"} exported = portable_config(source) self.assertEqual(exported["assistantVersion"], "1.2.0.dev1") self.assertEqual(import_config(exported)["progression_policy"], asdict(policy)) text = json.dumps(exported) for secret in ("test-secret", "private-account", "private-runtime", "progression_records", "progression_rows"): self.assertNotIn(secret, text) self.assertEqual(policy, configured_policy()) def test_defaults_and_older_bundles_do_not_enable_or_replace_progression(self): exported = portable_config({}) self.assertFalse(exported["progression_policy"]["enabled"]) self.assertEqual(exported["progression_policy"]["battle_mode"], "original") if hasattr(ProgressionPolicy(), "auto_farm"): self.assertEqual(exported["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm) del exported["progression_policy"]["auto_farm"] self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm) del exported["progression_policy"]["battle_mode"] self.assertEqual(import_config(exported)["progression_policy"]["battle_mode"], "original") del exported["progression_policy"] self.assertNotIn("progression_policy", import_config(exported)) def test_invalid_progression_rejected_atomically(self): exported = portable_config({"progression_policy": asdict(configured_policy())}) for field, invalid in (("enabled", 1), ("mainline", "true"), ("reserve_ti", -1), ("reserve_ti", True), ("max_money", -1), ("max_money", 1_000_000_001), ("stop_after_loss", 0), ("stop_after_loss", 1000), ("team", ""), ("team", None), ("team", True), ("battle_mode", "automatic"), ("battle_mode", True), ("battle_mode", ["experimental"]), ("item_reserves", {"30001": -1}), ("item_reserves", {"30001": True}), ("item_reserves", {"invalid": 1}), ("item_reserves", {"0": 1}), ("allow_items", "yes"), ("auto_farm", "true"), ("auto_farm", 1), ("auto_farm", None)): with self.subTest(field=field, invalid=invalid): value = copy.deepcopy(exported) value["progression_policy"][field] = invalid with self.assertRaises((ValueError, TypeError)): import_config(value) for invalid in (None, [], {"unknown_field": True}): with self.assertRaises((ValueError, TypeError)): import_config(exported | {"progression_policy": invalid}) class ProgressionGuiTests(unittest.TestCase): @classmethod def setUpClass(cls): cls.app = W.QApplication.instance() or W.QApplication([]) def wait(self, window, predicate=lambda: True): deadline = time.monotonic() + 6 while time.monotonic() < deadline: self.app.processEvents() QTest.qWait(5) if (not window.busy and not window.progression_table.row_batch.running and not window.battle_records_table.row_batch.running and predicate()): return self.fail("Offline Qt job did not complete: " + window.log.toPlainText()) def mock_readers(self, window): threads = [] def tasks(): threads.append(C.QThread.currentThread()) return copy.deepcopy(TASKS) def records(): threads.append(C.QThread.currentThread()) return copy.deepcopy(RECORDS) task_mock = Mock(side_effect=tasks) record_mock = Mock(side_effect=records) window.engine.progression_rows = task_mock window.engine.progression_records = record_mock return threads, task_mock, record_mock def login_fixture(self, window, events): from ranch_assistant.api import Session session = Session("http://127.0.0.1/fixture/", "fixture-token", account_id="fixture-account", server_id=1, role_id=101) client = SimpleNamespace(session=session, trace=None, persist_session=Mock(), close=Mock(side_effect=lambda: events.append("client_closed"))) window.engine.client = client window.engine.demo = False window.engine.last_heartbeat = time.monotonic() window.engine.master_sync_due = Mock(return_value=False) window.engine.growth_sync_due = Mock(return_value=False) window.engine.heartbeat_enabled = True window.monitoring = True window.set_strategy_checked(True) window.next_poll = 0 window.account.setText("fixture-account") window.password.setText("fixture-password") window.credentials.save("fixture-account", "fixture-password", True) window.session_store.save(session, "fixture account") window.reload_saved_sessions() return client def test_logout_nested_confirmation_cannot_report_clear_before_client_release(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() release = threading.Event() events = [] try: self.wait(window) client = self.login_fixture(window, events) def held_poll(**kwargs): if not release.wait(4): raise TimeoutError("logout fixture was not released") return window.engine.snapshot, [], "fixture poll finished" window.engine.poll = Mock(side_effect=held_poll) save = window.credentials.save def record_save(account, password, remember): if not remember and not account and not password: events.append("credentials_cleared") return save(account, password, remember) def confirm(*args): window.schedule() # The real modal runs this nested event loop. self.app.processEvents() return W.QMessageBox.StandardButton.Yes with patch.object(gui.W.QMessageBox, "question", side_effect=confirm), patch.object(window.credentials, "save", side_effect=record_save): window.logout_and_clear() if "credentials_cleared" in events: self.assertIn("client_closed", events, "credentials were cleared while the original client was active") self.assertLess(events.index("client_closed"), events.index("credentials_cleared")) release.set() self.wait(window, lambda: window.engine.demo) client.close.assert_called_once_with() self.assertEqual(window.credentials.load(), (False, "", "")) self.assertEqual(window.session_store.entries(), []) self.assertFalse(window.monitoring) self.assertFalse(window.engine.auto) self.assertFalse(window.strategy_toggle.isChecked()) finally: release.set() self.wait(window) window.close() def test_logout_cancel_freezes_scheduler_but_preserves_credentials_and_stopped_intent(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() events, observed = [], [] try: self.wait(window) client = self.login_fixture(window, events) engine = window.engine window.ranch_enabled.setChecked(False) window.progression_enabled.setChecked(True) engine.auto = True engine.poll = Mock(return_value=(engine.snapshot, [], "fixture refresh")) def cancel(*args): observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled)) window.schedule() window.start_workflow() # A previously queued start must also stay frozen. self.app.processEvents() observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled)) return W.QMessageBox.StandardButton.No with patch.object(gui.W.QMessageBox, "question", side_effect=cancel): window.logout_and_clear() self.wait(window) self.assertEqual(observed, [(False, False, False, False)] * 2) engine.poll.assert_not_called() self.assertIs(window.engine, engine) client.close.assert_not_called() self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password")) self.assertEqual(len(window.session_store.entries()), 1) self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(engine.auto) finally: window.close() def test_confirmed_busy_logout_waits_for_worker_before_clear(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() release = threading.Event() events = [] try: self.wait(window) client = self.login_fixture(window, events) engine = window.engine def held_poll(): if not release.wait(4): raise TimeoutError("logout fixture was not released") return engine.snapshot, [], "fixture poll finished" window.submit("poll", held_poll) with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes) as question: window.logout_and_clear() question.assert_called_once() self.assertTrue(window.busy) client.close.assert_not_called() self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password")) self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText()) release.set() self.wait(window, lambda: window.engine.demo) client.close.assert_called_once_with() self.assertEqual(window.credentials.load(), (False, "", "")) self.assertFalse(window.engine.auto) self.assertFalse(engine.auto) self.assertFalse(engine.heartbeat_enabled) finally: release.set() self.wait(window) window.close() def test_failed_client_release_does_not_clear_credentials_or_report_success(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) client = self.login_fixture(window, []) client.close.side_effect = RuntimeError("fixture close failed") with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes): window.logout_and_clear() self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password")) self.assertEqual(len(window.session_store.entries()), 1) self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText()) self.assertIn("fixture close failed", window.log.toPlainText()) self.assertFalse(window.engine.auto) self.assertFalse(window.engine.heartbeat_enabled) self.assertFalse(window.monitoring) client.close.side_effect = None finally: window.close() def test_confirmed_logout_still_clears_sessions_if_window_closes_while_waiting(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() release = threading.Event() try: self.wait(window) client = self.login_fixture(window, []) window.submit("logout_fixture", lambda: release.wait(4)) with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes): window.logout_and_clear() window.close() release.set() for _ in range(600): self.app.processEvents() QTest.qWait(5) if not window.busy and client.close.called: break self.assertEqual(window.session_store.entries(), []) self.assertEqual(window.credentials.load(), (False, "", "")) client.close.assert_called_once_with() finally: release.set() self.wait(window) window.close() def test_tabs_stopped_defaults_and_progression_only_global_start(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) labels = [window.tabs.tabText(i) for i in range(window.tabs.count())] self.assertEqual(labels[labels.index("自动孵蛋") + 1], "自动主线") self.assertIn("战斗记录", labels) self.assertEqual(labels[-1], "收益资料") self.assertEqual(window.styleSheet(), "") self.assertFalse(window.progression_enabled.isChecked()) self.assertTrue(window.progression_mainline.isChecked()) self.assertFalse(window.progression_sidequests.isChecked()) self.assertFalse(window.progression_commissions.isChecked()) if hasattr(ProgressionPolicy(), "auto_farm"): self.assertEqual(window.progression_auto_farm.isChecked(), ProgressionPolicy().auto_farm) else: self.assertFalse(hasattr(window, "progression_auto_farm")) self.assertEqual(window.progression_battle_mode.currentData(), "experimental") self.assertEqual(window.engine.progression_policy.battle_mode, "experimental") self.assertTrue(window.progression_battle_mode.isHidden()) settings = window.progression_tabs.widget(1).widget() self.assertEqual(settings.layout().indexOf(window.progression_battle_mode), -1) self.assertFalse(any("战斗模式" in label.text() for label in settings.findChildren(W.QLabel))) for text in ("原始属性", "实验模拟", "战斗时长后提交", "近似", "实际记录"): self.assertIn(text, window.progression_status.text()) self.assertFalse(window.strategy_toggle.isChecked()) for widget in (window.ranch_enabled, window.quest_enabled, window.daily_enabled, window.map_enabled, window.gift_enabled): widget.setChecked(False) window.progression_enabled.setChecked(True) window.engine.cancel_progression = Mock() with patch.object(window, "refresh"): window.start_workflow() self.assertTrue(window.strategy_toggle.isChecked()) self.assertIn("主线推进", window.workflow_status.text()) window.stop_workflow() window.engine.cancel_progression.assert_called_once_with() self.assertFalse(window.strategy_toggle.isChecked()) buttons = [b.text() for b in window.findChildren(W.QPushButton)] self.assertEqual(buttons.count("开启"), 1) self.assertNotIn("开始监控", buttons) finally: window.close() def test_per_account_autosave_and_restart_round_trip(self): with workspace_temp() as folder: expected = asdict(configured_policy()) window = gui.Window(folder / "one") window.timer.stop() try: self.wait(window) window.load_progression_policy(configured_policy()) window.progression_max_money.setValue(43) expected["max_money"] = 43 QTest.qWait(350) self.wait(window) self.assertEqual(json.loads((folder / "one" / "settings.json").read_text(encoding="utf-8"))["progression_policy"], expected) self.assertEqual(asdict(window.engine.progression_policy), expected) self.assertFalse(window.engine.auto) finally: window.close() first = gui.Window(folder / "one") second = gui.Window(folder / "two") first.timer.stop() second.timer.stop() try: self.wait(first) self.wait(second) self.assertEqual(asdict(first.read_progression_policy()), expected) self.assertEqual(asdict(second.read_progression_policy()), asdict(ProgressionPolicy()) | {"battle_mode": "experimental"}) self.assertFalse(first.strategy_toggle.isChecked()) self.assertFalse(second.strategy_toggle.isChecked()) finally: first.close() second.close() def test_unified_import_keeps_choices_and_execution_stopped(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) source = window.config_value() | {"progression_policy": asdict(configured_policy())} path = folder / "policies.json" path.write_text(json.dumps(portable_config(source)), encoding="utf-8") window.set_strategy_checked(True) window.engine.auto = True window.engine.run_progression_once = Mock() with patch.object(gui.W.QFileDialog, "getOpenFileName", return_value=(str(path), "")): window.import_policies() self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy())) self.assertEqual(asdict(window.engine.progression_policy), asdict(configured_policy())) self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(window.engine.auto) window.engine.run_progression_once.assert_not_called() with patch.object(gui.W.QFileDialog, "getSaveFileName", return_value=(str(path), "")): window.export_policies() self.assertEqual(import_config(json.loads(path.read_text(encoding="utf-8")))["progression_policy"], asdict(configured_policy())) finally: window.close() def test_legacy_original_mode_normalizes_for_autosave_and_worker_policy(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) window.engine.run_progression_once = Mock() legacy = asdict(configured_policy()) | {"battle_mode": "original"} window.load_config(window.config_value() | {"progression_policy": legacy}) self.assertEqual(window.progression_battle_mode.currentData(), "experimental") self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy())) self.assertEqual(legacy["battle_mode"], "original") # Older GUI glue can write the hidden field again after load_config. window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("original")) self.assertEqual(window.read_progression_policy().battle_mode, "experimental") QTest.qWait(350) self.wait(window) saved = json.loads((folder / "settings.json").read_text(encoding="utf-8")) self.assertEqual(saved["progression_policy"]["battle_mode"], "experimental") self.assertEqual(window.engine.progression_policy.battle_mode, "experimental") self.assertIn("实验模拟", window.progression_status.text()) self.assertIn("近似", window.progression_status.text()) self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(window.engine.auto) window.engine.run_progression_once.assert_not_called() observations = [] def preview(): observations.append((window.engine.progression_policy.battle_mode, C.QThread.currentThread())) return window.engine.snapshot, [], "已预览模拟战斗策略" window.engine.refresh_progression = Mock(side_effect=preview) window.refresh_progression() self.wait(window) self.assertEqual(observations[0][0], "experimental") self.assertNotEqual(observations[0][1], self.app.thread()) self.assertFalse(window.engine.auto) finally: window.close() def test_saved_original_and_missing_modes_load_as_experimental_without_starting(self): for mode in ("original", None): with self.subTest(mode=mode), workspace_temp() as folder: legacy = asdict(configured_policy()) if mode is None: del legacy["battle_mode"] else: legacy["battle_mode"] = mode path = folder / "settings.json" path.write_text(json.dumps({"progression_policy": legacy}), encoding="utf-8") window = gui.Window(folder) window.timer.stop() try: window.engine.run_progression_once = Mock() self.wait(window) self.assertEqual(window.progression_battle_mode.currentData(), "experimental") self.assertTrue(window.progression_battle_mode.isHidden()) self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy())) self.assertEqual(asdict(window.engine.progression_policy), asdict(configured_policy())) window.persist_settings() self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["progression_policy"], asdict(configured_policy())) self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(window.engine.auto) window.engine.run_progression_once.assert_not_called() finally: window.close() def test_additional_and_unavailable_teams_round_trip_visibly_without_starting(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) policy = configured_policy() policy.team = "Raid42" exported = portable_config(window.config_value() | {"progression_policy": asdict(policy)}) value = import_config(exported) self.assertEqual(value["progression_policy"]["team"], "Raid42") window.load_config(window.config_value() | value) self.assertEqual(window.progression_team.currentData(), "Raid42") self.assertIn("当前账号未找到", window.progression_team.currentText()) window.engine.snapshot.raw["teams"] = [{"teamType": "battleTeam", "teamName": "Raid42", "monsters": [900]}, {"teamType": "battleTeam", "teamName": "teamD", "monsters": [900]}] window.refresh_progression_teams(window.engine.snapshot) self.assertEqual(window.progression_team.currentText(), "Raid42") self.assertGreaterEqual(window.progression_team.findData("teamD"), 0) self.assertEqual(window.read_progression_policy().team, "Raid42") self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(window.engine.auto) finally: window.close() @unittest.skipUnless(hasattr(ProgressionPolicy(), "auto_farm"), "Planner has not exposed ProgressionPolicy.auto_farm yet") def test_auto_farm_autosaves_without_starting_or_duplicate_controls(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) checks = [check for check in window.findChildren(W.QCheckBox) if check.text() == "自动收集任务材料 / 击杀目标"] self.assertEqual(checks, [window.progression_auto_farm]) window.engine.run_progression_once = Mock() selected = not ProgressionPolicy().auto_farm window.progression_auto_farm.setChecked(selected) QTest.qWait(350) self.wait(window) saved = json.loads((folder / "settings.json").read_text(encoding="utf-8")) self.assertEqual(saved["progression_policy"]["auto_farm"], selected) self.assertEqual(window.engine.progression_policy.auto_farm, selected) exported = portable_config(window.config_value()) self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], selected) self.assertFalse(window.strategy_toggle.isChecked()) self.assertFalse(window.engine.auto) window.engine.run_progression_once.assert_not_called() finally: window.close() def test_hidden_page_and_account_skip_task_getters_and_cached_view_is_lazy(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) threads, tasks, records = self.mock_readers(window) window.refresh() self.wait(window) tasks.assert_not_called() records.assert_not_called() window.set_presentation_active(False) window.tabs.setCurrentWidget(window.progression_page) window.refresh() self.wait(window) tasks.assert_not_called() records.assert_not_called() window.set_presentation_active(True) self.wait(window, lambda: window.progression_table.rowCount() == 4) self.assertTrue(all(thread != self.app.thread() for thread in threads)) self.assertEqual(tasks.call_count, 1) window.render_progression() window.render_current_page() self.assertEqual(tasks.call_count, 1) records.assert_not_called() window.tabs.setCurrentWidget(window.battle_records_page) self.wait(window, lambda: window.battle_records_table.rowCount() == 3) self.assertEqual(records.call_count, 1) tasks.reset_mock() window.refresh() self.wait(window) tasks.assert_not_called() self.assertEqual(TASKS[0]["state"], "active") finally: window.close() def test_account_views_share_static_data_without_mutating_it_or_loading_battles(self): with workspace_temp() as folder: first, second = gui.Window(folder / "one"), gui.Window(folder / "two") first.timer.stop() second.timer.stop() try: self.wait(first) self.wait(second) with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("task UI must not load battle archives")): first.refresh_progression() self.wait(first) second.refresh_progression() self.wait(second) data = first.engine.game_data self.assertIsNotNone(data) self.assertIs(data, second.engine.game_data) original = repr(data.tasks) self.assertIsNot(first.progression_views, second.progression_views) self.assertIsNot(first.progression_views.tasks, second.progression_views.tasks) if first.progression_views.tasks: first.progression_views.tasks[0]["values"][2] = "account-one-only" self.assertEqual(repr(data.tasks), original) self.assertFalse(second.progression_views.tasks and second.progression_views.tasks[0]["values"][2] == "account-one-only") finally: first.close() second.close() def test_leaving_task_page_drops_its_queued_local_view(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() release = threading.Event() try: self.wait(window) _, tasks, records = self.mock_readers(window) window.run_job("held_request", lambda: release.wait(4)) window.tabs.setCurrentWidget(window.progression_page) self.assertTrue(window.pending_progression_view) window.tabs.setCurrentWidget(window.automation_page) self.assertFalse(window.pending_progression_view) release.set() self.wait(window) tasks.assert_not_called() records.assert_not_called() finally: release.set() self.wait(window) window.close() def test_filters_details_unknown_support_and_records_contexts(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) self.mock_readers(window) window.tabs.setCurrentWidget(window.progression_page) self.wait(window, lambda: window.progression_table.rowCount() == 4) for kind, expected in (("mainline", "主线测试"), ("sidequest", "支线测试"), ("commission", "委托测试"), ("unknown", "未知测试")): window.progression_filter.setCurrentIndex(window.progression_filter.findData(kind)) self.wait(window, lambda: window.progression_table.rowCount() == 1) self.assertEqual(window.progression_table.item(0, 2).text(), expected) window.progression_table.selectRow(0) if kind == "mainline": detail = window.progression_detail.toPlainText() for text in ("测试对话内容", "2 / 4", "地图0101", "等待对话"): self.assertIn(text, detail) elif kind == "sidequest": self.assertIn("战斗运行时尚未支持", window.progression_detail.toPlainText()) elif kind == "unknown": self.assertIn("支持状态未确认", window.progression_table.item(0, 9).text()) window.tabs.setCurrentWidget(window.battle_records_page) self.wait(window, lambda: window.battle_records_table.rowCount() == 3) for kind, label in (("sweep", "扫荡"), ("map_reward_event", "地图奖励事件"), ("task_battle", "任务战斗")): window.battle_records_filter.setCurrentIndex(window.battle_records_filter.findData(kind)) self.wait(window, lambda: window.battle_records_table.rowCount() == 1) self.assertEqual(window.battle_records_table.item(0, 1).text(), label) finally: window.close() def test_refresh_and_step_use_worker_prepare_and_result_paths(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) threads, tasks, _ = self.mock_readers(window) def refresh(): threads.append(C.QThread.currentThread()) return window.engine.snapshot, [], "离线任务刷新完成" window.engine.refresh_progression = Mock(side_effect=refresh) window.engine.run_progression_once = Mock(side_effect=refresh) with patch.object(window, "run_job", wraps=window.run_job) as run_job: window.refresh_progression() self.wait(window) self.assertEqual(run_job.call_args[0][0], "progression_refresh") self.assertIsNotNone(window.progression_views) self.assertEqual(tasks.call_count, 1) self.assertIn("离线任务刷新完成", window.log.toPlainText()) window.run_progression_once() window.engine.run_progression_once.assert_not_called() window.progression_enabled.setChecked(True) window.monitoring = True window.set_strategy_checked(True) window.run_progression_once() self.wait(window) self.assertEqual(run_job.call_args[0][0], "progression_run") self.assertEqual(window.engine.run_progression_once.call_count, 1) self.assertTrue(all(thread != self.app.thread() for thread in threads)) finally: window.close() def test_policy_changes_wait_for_serial_request_but_stop_cancels_immediately(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() release = threading.Event() entered = threading.Event() try: self.wait(window) policy = window.engine.progression_policy def held_request(): entered.set() if not release.wait(4): raise TimeoutError("test worker was not released") window.engine.cancel_progression = Mock() window.run_job("held_request", held_request) self.assertTrue(entered.wait(1)) window.progression_enabled.setChecked(True) window.progression_reserve_ti.setValue(77) window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental")) window.persist_settings() self.assertIs(window.engine.progression_policy, policy) self.assertIsNotNone(window.pending_policy) window.stop_workflow() window.engine.cancel_progression.assert_called_once_with() self.assertTrue(window.busy) release.set() self.wait(window) self.assertEqual(window.engine.progression_policy.reserve_ti, 77) self.assertEqual(window.engine.progression_policy.battle_mode, "experimental") self.assertFalse(window.engine.auto) finally: release.set() self.wait(window) window.close() def test_stop_before_queued_step_starts_prevents_engine_entry(self): with workspace_temp() as folder: window = gui.Window(folder) window.timer.stop() try: self.wait(window) window.progression_enabled.setChecked(True) window.monitoring = True window.set_strategy_checked(True) window.engine.run_progression_once = Mock() queued = [] with patch.object(window.pool, "start", side_effect=queued.append): window.run_progression_once() self.assertEqual(len(queued), 1) self.assertTrue(window.busy) window.stop_workflow() window.pool.start(queued[0]) self.wait(window) window.engine.run_progression_once.assert_not_called() self.assertIn("未开始执行", window.log.toPlainText()) self.assertFalse(window.engine.auto) finally: window.close() def test_bad_task_contract_errors_are_reported(self): engine = Mock() engine.progression_rows.return_value = [{"task_type_id": "ok"}, None] engine.progression_records.return_value = [] with self.assertRaisesRegex(TypeError, r"progression_rows\(\)"): prepare_progression_views(engine) def test_journal_timestamps_use_beijing_and_preserve_original_records(self): source = [ {"kind": "battle", "task_id": 12, "battle_kind": "passStage", "started_at": 1700000000, "finished_at": 1700000010}, {"kind": "battle", "battle_kind": "ordinary_stage", "started_at": 1700000000, "outcome": "event"}, {"kind": "sweep", "battle_kind": "normal", "started_at": 1700000000}, ] original = copy.deepcopy(source) engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: TASKS, progression_records=lambda: source) views = prepare_progression_views(engine) self.assertEqual(views.records[0]["values"][0], "2023-11-15 06:13:30") self.assertEqual(views.records[1]["values"][0], "2023-11-15 06:13:20") self.assertEqual([row["category"] for row in views.records], ["task_pass_stage", "map_reward_event", "sweep"]) self.assertEqual(source, original) def test_experimental_record_outcomes_keep_their_approximate_label(self): records = [ {"battle_mode": "experimental", "faithful": False, "approximate": True, "outcome": "win"}, {"battle_mode": "experimental", "outcome": "loss"}, {"execution_mode": "experimental", "outcome": "unsupported", "reason": "能力检查未通过"}, {"battle_mode": "original", "outcome": "win"}, {"outcome": "win"}, ] original = copy.deepcopy(records) engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records) rows = prepare_progression_views(engine).records for row, outcome in zip(rows, ("胜利", "战败", "暂不支持")): self.assertEqual(row["values"][4], outcome + "(实验近似)") self.assertIn("近似,未完整验证", row["detail"]) self.assertIn("能力检查未通过", rows[2]["detail"]) self.assertEqual(rows[3]["values"][4], "胜利") self.assertIn("原版运行时", rows[3]["detail"]) self.assertIn("记录未标明", rows[4]["detail"]) self.assertEqual(records, original) def test_repeated_sorted_table_updates_do_not_reinsert_owned_items(self): table = CachedTable(["编号", "名称"]) messages = [] previous = C.qInstallMessageHandler(lambda level, context, message: messages.append(message)) try: for count in (80, 4, 35, 80): rows = [{"key": str(i), "values": [str(i), "name " + str(i)], "detail": str(i)} for i in range(count)] table.set_rows(rows) deadline = time.monotonic() + 2 while table.row_batch.running and time.monotonic() < deadline: self.app.processEvents() QTest.qWait(2) self.assertFalse(table.row_batch.running) table.sortItems(0, C.Qt.SortOrder.DescendingOrder) self.assertEqual(table.rowCount(), count) self.assertEqual(table.item(0, 0).text(), str(count - 1)) self.assertFalse(any("already owned" in message.lower() or "cannot insert" in message.lower() for message in messages), messages) finally: C.qInstallMessageHandler(previous) table.row_batch.stop() table.deleteLater() if __name__ == "__main__": unittest.main()