Add v1.2 development quest progression and experimental battle runtime

This commit is contained in:
AttilaNet
2026-11-08 19:29:28 +08:00
parent 79b7672471
commit 0d3e231cde
71 changed files with 14349 additions and 172 deletions
@@ -0,0 +1,749 @@
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(), "original")
self.assertIn("近似", window.progression_battle_mode.toolTip())
self.assertIn("委托", window.progression_battle_mode.toolTip())
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()))
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_battle_mode_autosaves_without_starting_and_reaches_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()
self.assertEqual(window.progression_battle_mode.currentData(), "original")
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("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_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": "original", "outcome": "win"},
{"outcome": "win"},
]
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records)
rows = prepare_progression_views(engine).records
self.assertIn("实验近似", rows[0]["values"][4])
self.assertIn("近似,未完整验证", rows[0]["detail"])
self.assertEqual(rows[1]["values"][4], "胜利")
self.assertIn("原版运行时", rows[1]["detail"])
self.assertIn("记录未标明", rows[2]["detail"])
self.assertEqual(records[0]["outcome"], "win")
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()