797 lines
43 KiB
Python
797 lines
43 KiB
Python
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)
|
|
window.progression_filter.setCurrentIndex(window.progression_filter.findData(""))
|
|
window.progression_state_filter.setCurrentIndex(window.progression_state_filter.findData(""))
|
|
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)
|
|
window.progression_filter.setCurrentIndex(window.progression_filter.findData(""))
|
|
window.progression_state_filter.setCurrentIndex(window.progression_state_filter.findData(""))
|
|
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()
|