Improve task filters, exploration rewards and V4 battle simulation
This commit is contained in:
@@ -0,0 +1,194 @@
|
||||
import os
|
||||
import unittest
|
||||
from dataclasses import replace
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||||
|
||||
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
|
||||
from PySide6.QtTest import QTest
|
||||
|
||||
from ranch_assistant.engine import Engine, demo_snapshot
|
||||
from ranch_assistant.gui import Window
|
||||
from ranch_assistant.maps import stages
|
||||
from ranch_assistant.native_widgets import IntegerInput
|
||||
from ranch_assistant.presentation import monster_rows
|
||||
from ranch_assistant.tests.test_activities import scenario
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
|
||||
|
||||
LONG_DROP = "金币、绿色史莱姆蛋、" + "、".join(f"离线材料{i:02d}" for i in range(30)) + "、末尾稀有掉落"
|
||||
|
||||
|
||||
class ActivityDropElisionTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.app = W.QApplication.instance() or W.QApplication([])
|
||||
|
||||
def finish_maps(self, window):
|
||||
for _ in range(200):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(2)
|
||||
if not window.map_render_timer.running:
|
||||
return
|
||||
self.fail("Offline map rendering did not finish")
|
||||
|
||||
def fixture(self, window):
|
||||
catalog, snapshot = scenario()
|
||||
rows = [replace(row, drops=LONG_DROP)
|
||||
if row.stage_id == "0101" and row.level == "3" else row
|
||||
for row in stages(catalog, snapshot)]
|
||||
catalog.data["stage_info"]["m101"] = {
|
||||
"cost": {"ti": 8, "items": [{"typeId": "90001", "num": 2}, {"typeId": "90002", "num": 1}]}
|
||||
}
|
||||
catalog.data["item_names"].update({"90001": "矿镐", "90002": "门票"})
|
||||
rows.append(replace(rows[0], stage_id="m101", level="1", name="矿洞", category="mine",
|
||||
sweep=False, battle_available=True))
|
||||
window.engine = Engine(catalog)
|
||||
window.engine.snapshot = snapshot
|
||||
window.engine.stage_cache.get = Mock(return_value=rows)
|
||||
window.tabs.setCurrentWidget(window.map_page)
|
||||
window.resize(1600, 800)
|
||||
window.show()
|
||||
window.maps_tree.setColumnWidth(7, 90)
|
||||
window.render_maps()
|
||||
self.finish_maps(window)
|
||||
window.maps_tree.expandAll()
|
||||
self.app.processEvents()
|
||||
return window._map_items["0101"], window._map_items["m101"]
|
||||
|
||||
def test_long_drop_elides_without_losing_text_search_or_adjacent_controls(self):
|
||||
with workspace_temp() as folder:
|
||||
window = Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
item, resource_item = self.fixture(window)
|
||||
tree = window.maps_tree
|
||||
self.assertEqual(tree.columnWidth(7), 90)
|
||||
self.assertEqual(item.text(7), LONG_DROP)
|
||||
self.assertEqual(item.toolTip(7), LONG_DROP)
|
||||
self.assertEqual(item.data(7, C.Qt.ItemDataRole.DisplayRole), LONG_DROP)
|
||||
|
||||
index = tree.indexFromItem(item, 7)
|
||||
option = W.QStyleOptionViewItem()
|
||||
tree.initViewItemOption(option)
|
||||
option.rect = tree.visualRect(index)
|
||||
delegate = tree.itemDelegateForColumn(7) or tree.itemDelegate()
|
||||
delegate.initStyleOption(option, index)
|
||||
self.assertEqual(option.text, LONG_DROP)
|
||||
self.assertEqual(option.rect.width(), tree.columnWidth(7))
|
||||
self.assertEqual(option.textElideMode, C.Qt.TextElideMode.ElideRight)
|
||||
elided = option.fontMetrics.elidedText(LONG_DROP, option.textElideMode, option.rect.width())
|
||||
self.assertNotEqual(elided, LONG_DROP)
|
||||
self.assertTrue(elided.endswith("…"))
|
||||
|
||||
cost_index = tree.indexFromItem(resource_item, 6)
|
||||
cost_option = W.QStyleOptionViewItem()
|
||||
tree.initViewItemOption(cost_option)
|
||||
cost_option.rect = tree.visualRect(cost_index)
|
||||
(tree.itemDelegateForColumn(6) or tree.itemDelegate()).initStyleOption(cost_option, cost_index)
|
||||
self.assertIn("\n", resource_item.text(6))
|
||||
self.assertEqual(cost_option.text.replace("\u2028", "\n"), resource_item.text(6))
|
||||
self.assertEqual(cost_option.textElideMode, C.Qt.TextElideMode.ElideNone)
|
||||
|
||||
tree.scrollTo(index, W.QAbstractItemView.ScrollHint.EnsureVisible)
|
||||
self.app.processEvents()
|
||||
viewport_point = tree.visualRect(index).center()
|
||||
event = G.QHelpEvent(C.QEvent.Type.ToolTip, viewport_point,
|
||||
tree.viewport().mapToGlobal(viewport_point))
|
||||
self.app.sendEvent(tree.viewport(), event)
|
||||
self.assertTrue(W.QToolTip.isVisible())
|
||||
self.assertEqual(W.QToolTip.text(), LONG_DROP)
|
||||
W.QToolTip.hideText()
|
||||
|
||||
limit = tree.itemWidget(item, 8)
|
||||
self.assertIsInstance(limit, IntegerInput)
|
||||
self.assertTrue(limit.isVisible())
|
||||
self.assertIs(limit.style(), window.style())
|
||||
self.assertEqual(limit.styleSheet(), "")
|
||||
QTest.mouseClick(limit, C.Qt.MouseButton.LeftButton)
|
||||
limit.selectAll()
|
||||
QTest.keyClicks(limit, "12")
|
||||
self.assertEqual(limit.value(), 12)
|
||||
self.assertEqual(window.map_rules["0101"]["limit"], 12)
|
||||
|
||||
window.map_search.setFocus()
|
||||
window.map_search.setText("末尾稀有掉落")
|
||||
self.finish_maps(window)
|
||||
self.assertIn("0101", window._map_items)
|
||||
self.assertEqual(window._map_items["0101"].text(7), LONG_DROP)
|
||||
window.map_search.setText("不在任何掉落中的词")
|
||||
self.finish_maps(window)
|
||||
self.assertNotIn("0101", window._map_items)
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_breakthrough_button_reveals_columns_without_changing_selection_or_rules(self):
|
||||
with workspace_temp() as folder:
|
||||
window = Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
window.tabs.setCurrentWidget(window.monster_page)
|
||||
tree = window.monsters
|
||||
snapshot = demo_snapshot(tree.catalog)
|
||||
window.feed_targets = {"900": 2}
|
||||
window.gift_targets = {"900": 3}
|
||||
window.breakthrough_targets = {"900": 7}
|
||||
tree.set_view(True)
|
||||
tree.set_data(snapshot, monster_rows(tree.catalog, snapshot, set()),
|
||||
window.feed_targets, window.gift_targets, window.breakthrough_targets)
|
||||
self.finish_ranch(tree)
|
||||
tree.setFixedWidth(320)
|
||||
window.show()
|
||||
self.app.processEvents()
|
||||
selected = tree.monster_items[900]
|
||||
tree.setCurrentItem(selected)
|
||||
self.assertEqual(tree.selected_monster_ids(), [900])
|
||||
self.assertIn("补满四项潜能", window.breakthrough_settings.toolTip())
|
||||
self.assertIn("不是同种喂养突破", window.breakthrough_settings.toolTip())
|
||||
original_rules = (dict(window.feed_targets), dict(window.gift_targets), dict(window.breakthrough_targets))
|
||||
original_controls = {mid: (tree.itemWidget(item, 19).isChecked(), tree.itemWidget(item, 20).value())
|
||||
for mid, item in tree.monster_items.items()}
|
||||
changes = []
|
||||
tree.breakthrough_changed.connect(lambda *args: changes.append(args))
|
||||
|
||||
with patch.object(window, "submit") as submit, patch.object(window, "refresh") as refresh:
|
||||
tree.collapseAll()
|
||||
tree.horizontalScrollBar().setValue(0)
|
||||
QTest.mouseClick(window.breakthrough_settings, C.Qt.MouseButton.LeftButton)
|
||||
self.app.processEvents()
|
||||
self.assertTrue(selected.parent().isExpanded())
|
||||
target_rect = tree.visualRect(tree.indexFromItem(selected, 20))
|
||||
self.assertTrue(tree.viewport().rect().contains(target_rect))
|
||||
self.assertGreater(tree.horizontalScrollBar().value(), 0)
|
||||
self.assertEqual(tree.selected_monster_ids(), [900])
|
||||
|
||||
tree.clearSelection()
|
||||
first = next(iter(tree.monster_items.values()))
|
||||
tree.collapseAll()
|
||||
tree.horizontalScrollBar().setValue(0)
|
||||
QTest.mouseClick(window.breakthrough_settings, C.Qt.MouseButton.LeftButton)
|
||||
self.app.processEvents()
|
||||
self.assertTrue(first.parent().isExpanded())
|
||||
self.assertTrue(tree.viewport().rect().contains(tree.visualRect(tree.indexFromItem(first, 20))))
|
||||
self.assertEqual(tree.selectedItems(), [])
|
||||
submit.assert_not_called()
|
||||
refresh.assert_not_called()
|
||||
|
||||
self.assertEqual((window.feed_targets, window.gift_targets, window.breakthrough_targets), original_rules)
|
||||
self.assertEqual({mid: (tree.itemWidget(item, 19).isChecked(), tree.itemWidget(item, 20).value())
|
||||
for mid, item in tree.monster_items.items()}, original_controls)
|
||||
self.assertEqual(changes, [])
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def finish_ranch(self, tree):
|
||||
for _ in range(200):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(2)
|
||||
if not tree.row_batch.running:
|
||||
return
|
||||
self.fail("Offline ranch rendering did not finish")
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -133,6 +133,62 @@ class AutomationSchedulingTests(unittest.TestCase):
|
||||
|
||||
self.assertEqual([call[1] for call in engine.calls], ["explore", "breakthrough"])
|
||||
|
||||
def test_finished_team_dispatches_claim_without_restart_opt_in(self):
|
||||
engine = self.install_engine("explore_finish")
|
||||
self.window.explore_enabled.setChecked(False)
|
||||
self.window.arm_extended_automation()
|
||||
self.assertLess(self.window.next_explore, float("inf"))
|
||||
self.window.next_explore = time.monotonic() - 1
|
||||
|
||||
self.window.run_extended_automation()
|
||||
self.wait(lambda: bool(engine.calls))
|
||||
|
||||
self.assertEqual(engine.calls, [("poll_automation", "explore")])
|
||||
|
||||
def test_idle_team_does_not_arm_when_restart_is_disabled(self):
|
||||
self.install_engine()
|
||||
self.window.explore_enabled.setChecked(False)
|
||||
self.window.next_explore = float("inf")
|
||||
self.window.arm_extended_automation()
|
||||
self.assertEqual(self.window.next_explore, float("inf"))
|
||||
|
||||
def test_global_stop_blocks_claim_dispatch_and_disarms_timer(self):
|
||||
engine = self.install_engine("explore_finish")
|
||||
self.window.explore_enabled.setChecked(False)
|
||||
self.window.arm_extended_automation()
|
||||
self.assertLess(self.window.next_explore, float("inf"))
|
||||
self.window.stop_workflow()
|
||||
self.assertEqual(self.window.next_explore, float("inf"))
|
||||
self.window.run_extended_automation()
|
||||
self.wait()
|
||||
self.assertEqual(engine.calls, [])
|
||||
|
||||
def test_pending_reconciliation_defers_claim_timer_and_active_countdown(self):
|
||||
for pending in ("exploration", "battle"):
|
||||
with self.subTest(pending=pending):
|
||||
self.setUp()
|
||||
engine = self.install_engine("explore_finish")
|
||||
self.window.explore_enabled.setChecked(False)
|
||||
if pending == "exploration":
|
||||
engine.explore_planner.pending = Mock(return_value={"uncertain": True})
|
||||
else:
|
||||
engine._progression_pending = Mock(return_value=True)
|
||||
self.assertEqual(self.window.latest_render[1][-1].kind, "explore_finish")
|
||||
self.window.next_explore = float("inf")
|
||||
self.window.arm_extended_automation()
|
||||
self.assertEqual(self.window.next_explore, float("inf"))
|
||||
self.window.arm_extended_automation()
|
||||
self.assertEqual(self.window.next_explore, float("inf"))
|
||||
|
||||
engine.pending_recovery_due = Mock(return_value=True)
|
||||
engine.demo = False
|
||||
self.window.monitoring = True
|
||||
self.window.set_strategy_checked(True)
|
||||
self.window.next_breakthrough = float("inf")
|
||||
self.window.schedule()
|
||||
self.wait(lambda: bool(engine.calls))
|
||||
self.assertEqual(engine.calls, [("poll", {"hatch_only": False, "defer_hatch": True})])
|
||||
|
||||
def test_fast_hatch_and_gift_dispatch_only_their_own_kind(self):
|
||||
for kind in ("hatch", "gift"):
|
||||
with self.subTest(kind=kind):
|
||||
|
||||
@@ -0,0 +1,184 @@
|
||||
"""V4 final-damage profile boundaries; all fixtures are offline."""
|
||||
from copy import deepcopy
|
||||
from dataclasses import replace
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from ranch_assistant.battle_simulator import (
|
||||
DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE, ExperimentalBattleRuntime,
|
||||
_Battle, _prepare, combat_tables,
|
||||
)
|
||||
from ranch_assistant.battles import BattleOrchestrator
|
||||
from ranch_assistant.engine import Engine
|
||||
from ranch_assistant.game_data import ProgressionData
|
||||
from ranch_assistant.tests.test_battle_simulator import enemy, monster, request
|
||||
|
||||
|
||||
def prepared(req):
|
||||
scenario, report = _prepare(req, combat_tables())
|
||||
battle = _Battle(scenario, report, combat_tables())
|
||||
battle.deploy()
|
||||
return battle
|
||||
|
||||
|
||||
class DamageProfileTests(unittest.TestCase):
|
||||
def test_default_offline_profile_and_explicit_v4_metadata(self):
|
||||
original = request()
|
||||
self.assertEqual(ExperimentalBattleRuntime().inspect(original)["damage_profile"], DEFAULT_DAMAGE_PROFILE)
|
||||
original["damage_profile"] = DESKTOP_DAMAGE_PROFILE
|
||||
report = ExperimentalBattleRuntime().inspect(original)
|
||||
self.assertEqual(report["damage_profile"], "client_v4_x10")
|
||||
self.assertEqual((report["damage_multiplier"], report["damage_cap"]), (10, 50000))
|
||||
self.assertTrue(report["damage_profile_digest"])
|
||||
self.assertTrue(report["approximate"] and report["faithful"] is False)
|
||||
self.assertIn("Unknown damage profile", ExperimentalBattleRuntime().inspect(
|
||||
request(damage_profile="unknown"))["reasons"])
|
||||
self.assertFalse(ExperimentalBattleRuntime().inspect(request(damage_profile="unknown"))["supported"])
|
||||
|
||||
def test_v4_applies_once_with_cap_and_does_not_mutate_stats_or_request(self):
|
||||
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
|
||||
before = deepcopy(req)
|
||||
battle = prepared(req)
|
||||
player, target = battle.by_key["player-1"], battle.by_key["configured-1-1"]
|
||||
stats = replace(target.unit.stats)
|
||||
hp = target.hp
|
||||
self.assertEqual(battle.hurt(target, 100, player, "fixture"), 1000)
|
||||
self.assertEqual(target.hp, hp - 1000)
|
||||
self.assertEqual(battle.events[-1]["damage"], 1000)
|
||||
self.assertEqual(battle.events[-1]["damage_profile"], DESKTOP_DAMAGE_PROFILE)
|
||||
self.assertEqual(battle.events[-1]["damage_cap"], 50000)
|
||||
self.assertEqual(battle.hurt(target, 5001, player, "fixture"), 50000)
|
||||
self.assertEqual(target.unit.stats, stats)
|
||||
self.assertEqual(req, before)
|
||||
|
||||
def test_enemy_environment_friendly_non_team2_and_zero_are_unchanged(self):
|
||||
req = request(enemies=[enemy(hp=200000), enemy(team=3, hp=200000)],
|
||||
damage_profile=DESKTOP_DAMAGE_PROFILE)
|
||||
battle = prepared(req)
|
||||
player = battle.by_key["player-1"]
|
||||
target = battle.by_key["configured-1-1"]
|
||||
other_team = battle.by_key["configured-1-2"]
|
||||
self.assertEqual(battle.hurt(player, 100, target, "enemy"), 100)
|
||||
self.assertEqual(battle.hurt(target, 100, None, "environment"), 100)
|
||||
self.assertEqual(battle.hurt(other_team, 100, player, "other_team"), 100)
|
||||
self.assertEqual(battle.hurt(target, 0, player, "zero"), 0)
|
||||
|
||||
def test_real_attack_uses_the_same_final_hp_order(self):
|
||||
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
|
||||
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
|
||||
self.assertEqual(battle.hurt(target, 10, player, "real", real_attack=True), 100)
|
||||
self.assertEqual(battle.hurt(target, 6000, player, "real", real_attack=True), 50000)
|
||||
self.assertEqual(battle.hurt(player, 100, target, "real", real_attack=True), 100)
|
||||
|
||||
def test_reduction_precedes_v4_cap_in_both_hp_branches(self):
|
||||
for real_attack in (False, True):
|
||||
with self.subTest(real_attack=real_attack):
|
||||
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
|
||||
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
|
||||
target.unit = replace(target.unit, stats=replace(target.unit.stats, damage_reduction=.5))
|
||||
self.assertEqual(battle.hurt(target, 100, player, "reduced", real_attack=real_attack), 500)
|
||||
self.assertEqual(battle.hurt(target, 11000, player, "reduced_cap", real_attack=real_attack), 50000)
|
||||
|
||||
def test_mining_fixed_hurt_precedes_multiplier_for_player_and_npc(self):
|
||||
def fixture():
|
||||
return prepared({"context": "ordinary_stage", "roster": {"master": {"level": 43},
|
||||
"monsters": [monster()], "teams": [{"teamName": "teamA", "monsters": [101]}],
|
||||
"monsterAttributes": []}, "team": "teamA", "damage_profile": DESKTOP_DAMAGE_PROFILE,
|
||||
"original_data": {"battle": ProgressionData().stage_battle("m101")}})
|
||||
battle = fixture()
|
||||
player, ore = battle.by_key["player-1"], battle.by_source_id["10001"]
|
||||
player.unit = replace(player.unit, stats=replace(player.unit.stats, element=3))
|
||||
ore.unit = replace(ore.unit, hurt_types={**ore.unit.hurt_types, "3": 1})
|
||||
self.assertEqual(battle.hurt(ore, 100, player, "fixed_hurt"), 2000)
|
||||
battle = fixture()
|
||||
self.assertEqual(battle.hurt(battle.by_source_id["10001"], 100,
|
||||
battle.by_source_id["20001"], "fixed_hurt"), 5000)
|
||||
|
||||
def test_worker_transports_profile_and_battle_evidence_discloses_it(self):
|
||||
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
|
||||
result = ExperimentalBattleRuntime().run(req)
|
||||
self.assertEqual(result["damage_profile"], DESKTOP_DAMAGE_PROFILE)
|
||||
self.assertEqual(result["damage_cap"], 50000)
|
||||
self.assertEqual(next(e for e in result["events"] if e["type"] == "damage")["damage_profile"],
|
||||
DESKTOP_DAMAGE_PROFILE)
|
||||
evidence = BattleOrchestrator.runtime_evidence(result, "experimental")
|
||||
self.assertEqual(evidence["damage_profile"], DESKTOP_DAMAGE_PROFILE)
|
||||
self.assertEqual((evidence["damage_multiplier"], evidence["damage_cap"]), (10, 50000))
|
||||
self.assertEqual(evidence["damage_profile_digest"], result["damage_profile_digest"])
|
||||
|
||||
|
||||
class DesktopProfileTests(unittest.TestCase):
|
||||
@staticmethod
|
||||
def engine():
|
||||
engine = object.__new__(Engine)
|
||||
engine._ensure_progression = lambda: None
|
||||
engine._select_battle_runtime = lambda mode: None
|
||||
engine._battle_snapshot_source = None
|
||||
engine._battle_snapshot_digest = ""
|
||||
engine._battle_roster_digest = None
|
||||
engine._battle_roster = None
|
||||
engine.game_data = SimpleNamespace(
|
||||
stage_battle=lambda stage, difficulty: {"stage": stage, "difficulty": difficulty},
|
||||
task_battle=lambda task, step: {"task": task, "step": step}, manifest={})
|
||||
from ranch_assistant.battle_runtime import BattleRuntime
|
||||
engine.battles = SimpleNamespace(runtime=BattleRuntime())
|
||||
return engine
|
||||
|
||||
def test_all_desktop_contexts_and_original_subrequest_carry_v4(self):
|
||||
snapshot = SimpleNamespace(raw={"master": {"level": 43}, "monsters": [], "teams": []})
|
||||
cases = (
|
||||
({"battle_kind": "ordinary_stage", "stage_id": "0101", "difficulty": 1}, "ordinary_stage"),
|
||||
({"battle_kind": "task", "task_type_id": 100, "step_number": 1}, "task_battle"),
|
||||
({"battle_kind": "task", "task_type_id": 200, "step_number": 1}, "task_battle"),
|
||||
({"battle_kind": "resource_stage", "stage_id": "m101", "difficulty": 1,
|
||||
"stage_category": "mine"}, "ordinary_stage"),
|
||||
)
|
||||
for intent, context in cases:
|
||||
for mode in ("experimental", "original"):
|
||||
engine = self.engine()
|
||||
with self.subTest(intent=intent, mode=mode):
|
||||
req = Engine._battle_request(engine, snapshot, intent,
|
||||
SimpleNamespace(battle_mode=mode), {"damage_profile": DEFAULT_DAMAGE_PROFILE,
|
||||
**{key: intent.get(key) for key in ("stage_id", "difficulty", "task_type_id", "step_number")}})
|
||||
self.assertEqual(req["context"], context)
|
||||
self.assertEqual(req["damage_profile"],
|
||||
DESKTOP_DAMAGE_PROFILE if mode == "experimental" else DEFAULT_DAMAGE_PROFILE)
|
||||
if mode == "original":
|
||||
self.assertNotIn("damage_profile", req["runtime_request"])
|
||||
|
||||
def test_map_failure_signature_is_scoped_to_v4(self):
|
||||
engine = self.engine()
|
||||
snapshot = SimpleNamespace(raw={"master": {"level": 43},
|
||||
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
|
||||
"monsters": [monster()], "monsterAttributes": []})
|
||||
first = engine._map_roster_signature(snapshot, "teamA")
|
||||
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamB"))
|
||||
with patch("ranch_assistant.battle_simulator.DESKTOP_DAMAGE_PROFILE", DEFAULT_DAMAGE_PROFILE):
|
||||
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamA"))
|
||||
|
||||
def test_capability_cache_is_scoped_to_actual_mode_profile(self):
|
||||
engine = self.engine()
|
||||
engine.quest_policy = SimpleNamespace(battle_tasks=True)
|
||||
engine._is_commission = lambda intent: False
|
||||
engine._is_farm = lambda intent: False
|
||||
engine._intent_policy = lambda intent: policy
|
||||
engine.progression_policy = SimpleNamespace(battle_mode="experimental")
|
||||
engine.snapshot = SimpleNamespace()
|
||||
engine.policy = SimpleNamespace()
|
||||
engine._battle_snapshot_digest = "fixture"
|
||||
engine._capability_cache = {}
|
||||
policy = SimpleNamespace(battle_mode="experimental", team="teamA")
|
||||
engine.battles = SimpleNamespace(runtime=object(), request=lambda *args: {},
|
||||
resource_reason=lambda *args: "", inspect=lambda req: (True, ""))
|
||||
with patch("ranch_assistant.engine.digest", side_effect=lambda value: value["damage_profile"]):
|
||||
self.assertEqual(engine._battle_capability({}), (True, ""))
|
||||
self.assertEqual(engine._battle_capability({}), (True, ""))
|
||||
self.assertEqual(len(engine._capability_cache), 1)
|
||||
policy.battle_mode = "original"
|
||||
self.assertEqual(engine._battle_capability({}), (True, ""))
|
||||
self.assertEqual(set(engine._capability_cache), {DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -8,8 +8,10 @@ import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from ranch_assistant.exploration import ExplorePlanner, ExplorePolicy, ExploreTeamRule, load_exploration_areas
|
||||
from ranch_assistant.engine import Engine
|
||||
from ranch_assistant.model import Catalog, Policy, Snapshot
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
from ranch_assistant.tests.test_ranch_automation_integration import FakeClient, raw
|
||||
|
||||
|
||||
NOW = 1_700_000_000
|
||||
@@ -147,6 +149,109 @@ class ExplorationTests(unittest.TestCase):
|
||||
self.assertEqual(row["state"], "可领取")
|
||||
self.assertIn("仍会自动领取奖励", row["reason"])
|
||||
|
||||
def test_finished_team_rewards_while_automatic_restart_is_disabled(self):
|
||||
team = self.snapshot.raw["exploreTeams"][0]
|
||||
self.start_confirmed(team, end=NOW - 1)
|
||||
disabled = ExplorePolicy(False)
|
||||
actions = self.planner.plan(self.snapshot, disabled, self.ranch)
|
||||
self.assertEqual([(action.kind, action.path, action.payload) for action in actions],
|
||||
[("explore_finish", "exploreService/finish", {"exploreTeamId": 1})])
|
||||
team.update(status=0, area=None, monsters=None, endTime=None)
|
||||
self.assertIsNone(self.planner.pending(self.snapshot))
|
||||
self.assertEqual(self.planner.plan(self.snapshot, disabled, self.ranch), [])
|
||||
|
||||
def test_locked_idle_team_is_quiet_while_automatic_restart_is_disabled(self):
|
||||
self.snapshot.raw["history"]["passTask"] = {}
|
||||
self.assertEqual(self.planner.plan(self.snapshot, ExplorePolicy(False), self.ranch), [])
|
||||
enabled = self.planner.plan(self.snapshot, ExplorePolicy(True), self.ranch)
|
||||
self.assertEqual([(action.kind, action.path) for action in enabled], [("explore_blocked", "")])
|
||||
|
||||
def test_disabled_restart_claim_reconciles_before_next_poll_and_global_stop_blocks(self):
|
||||
with workspace_temp() as folder:
|
||||
value = raw(self.catalog)
|
||||
team = value["exploreTeams"][0]
|
||||
team.update(status=1, area="15", monsters="900,901,902", endTime=(NOW - 1) * 1000)
|
||||
client = FakeClient(value)
|
||||
engine = Engine(self.catalog, client, folder / "budget.json")
|
||||
engine.master_sync.settle = lambda *args: None
|
||||
engine.explore_policy = ExplorePolicy(False)
|
||||
|
||||
def finish(path, payload):
|
||||
client.calls.append((path, payload))
|
||||
team.update(status=0, area=None, monsters=None, endTime=None)
|
||||
return {"resCode": 0, "rewardResult": {}, "monExp": []}
|
||||
|
||||
client.call = finish
|
||||
engine.auto = False
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual(client.calls, [])
|
||||
|
||||
engine.auto = True
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual(client.calls, [("exploreService/finish", {"exploreTeamId": 77})])
|
||||
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
|
||||
self.assertEqual(engine.plans(), [])
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual(len(client.calls), 1)
|
||||
|
||||
def test_unknown_finish_is_never_repeated_even_with_restart_disabled(self):
|
||||
team = self.snapshot.raw["exploreTeams"][0]
|
||||
self.start_confirmed(team, end=NOW - 1)
|
||||
disabled = ExplorePolicy(False)
|
||||
with workspace_temp() as folder:
|
||||
path = folder / "state.json"
|
||||
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
||||
action = planner.plan(self.snapshot, disabled, self.ranch)[0]
|
||||
planner.mark_started(self.snapshot, action)
|
||||
planner.mark_uncertain(self.snapshot, action, "synthetic lost finish reply")
|
||||
for _ in range(2):
|
||||
actions = planner.plan(self.snapshot, disabled, self.ranch)
|
||||
self.assertEqual([(item.kind, item.path) for item in actions], [("explore_blocked", "")])
|
||||
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
||||
self.assertTrue(restored.pending(self.snapshot)["uncertain"])
|
||||
self.assertEqual([(item.kind, item.path) for item in restored.plan(self.snapshot, disabled, self.ranch)],
|
||||
[("explore_blocked", "")])
|
||||
team.update(status=0, monsters="", endTime=0)
|
||||
self.assertTrue(restored.reconcile(self.snapshot))
|
||||
self.assertEqual(restored.plan(self.snapshot, disabled, self.ranch), [])
|
||||
|
||||
def test_confirmed_claim_allows_only_opted_in_team_to_restart(self):
|
||||
with workspace_temp() as folder:
|
||||
value = raw(self.catalog)
|
||||
team = value["exploreTeams"][0]
|
||||
team.update(status=1, area="15", monsters="900,901,902", endTime=(NOW - 1) * 1000)
|
||||
value["monsters"][0]["level"] = 60
|
||||
client = FakeClient(value)
|
||||
engine = Engine(self.catalog, client, folder / "budget.json")
|
||||
engine.master_sync.settle = lambda *args: None
|
||||
engine.explore_policy = ExplorePolicy(True,
|
||||
{"77": {"enabled": True, "area": "1", "monsters": []}})
|
||||
area = engine.explore_planner.areas["1"]
|
||||
value["history"]["passStage"] = {area["passStage"]: {"1": True}}
|
||||
|
||||
def call(path, payload):
|
||||
client.calls.append((path, payload))
|
||||
if path == "exploreService/finish":
|
||||
team.update(status=0, area=None, monsters=None, endTime=None)
|
||||
else:
|
||||
team.update(status=1, area=payload["area"], monsters=payload["monsters"],
|
||||
endTime=(NOW + 3600) * 1000)
|
||||
return {"resCode": 0, "rewardResult": {}, "monExp": []}
|
||||
|
||||
client.call = call
|
||||
engine.auto = True
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual(client.calls, [("exploreService/finish", {"exploreTeamId": 77})])
|
||||
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual([path for path, _ in client.calls],
|
||||
["exploreService/finish", "exploreService/start"])
|
||||
self.assertEqual(client.calls[1][1]["exploreTeamId"], 77)
|
||||
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
|
||||
self.assertEqual(engine.snapshot.raw["exploreTeams"][0]["status"], 1)
|
||||
engine.poll_automation("explore")
|
||||
self.assertEqual(len(client.calls), 2)
|
||||
|
||||
def test_active_zero_or_missing_deadline_is_unknown_and_never_finished(self):
|
||||
for value in (None, 0, "", "not-a-time"):
|
||||
with self.subTest(value=value):
|
||||
|
||||
@@ -111,6 +111,27 @@ class ExplorationGuiTests(unittest.TestCase):
|
||||
window.arm_extended_automation()
|
||||
self.assertAlmostEqual(window.next_explore, now + 61, places=2)
|
||||
|
||||
def test_active_snapshot_arms_claim_timer_when_restart_is_disabled(self):
|
||||
window = self.window
|
||||
snapshot = window.engine.snapshot
|
||||
snapshot.raw["exploreTeams"][0].update(
|
||||
status=1, area="1", monsters="1,2,3", endTime=(NOW + 60) * 1000)
|
||||
window.latest_render = (snapshot, [])
|
||||
window.monitoring = True
|
||||
window.set_strategy_checked(True)
|
||||
window.explore_enabled.setChecked(False)
|
||||
window.next_explore = float("inf")
|
||||
now = time.monotonic()
|
||||
with patch.object(gui.time, "monotonic", return_value=now):
|
||||
window.arm_extended_automation()
|
||||
self.assertAlmostEqual(window.next_explore, now + 61, places=2)
|
||||
|
||||
def test_explore_opt_in_labels_restart_and_top_stop_owns_claims(self):
|
||||
self.assertEqual(self.window.explore_enabled.text(), "自动安排再次探险(完成后自动领奖)")
|
||||
self.assertIn("顶部", self.window.explore_enabled.toolTip())
|
||||
self.assertIn("停止", self.window.explore_enabled.toolTip())
|
||||
self.assertIn("领奖", self.window.explore_enabled.toolTip())
|
||||
|
||||
def test_real_window_three_selections_and_busy_policy_queue(self):
|
||||
window = self.window
|
||||
window.refresh_exploration()
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
import unittest
|
||||
|
||||
from ranch_assistant.gifts import GiftPlanner
|
||||
from ranch_assistant.model import Catalog, Policy
|
||||
from ranch_assistant.tests.test_gift_timing import gift_snapshot
|
||||
|
||||
|
||||
class GiftTargetSelectionTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.catalog = Catalog()
|
||||
self.snapshot = gift_snapshot(self.catalog)
|
||||
self.planner = GiftPlanner(self.catalog)
|
||||
self.representative = next(iter(self.planner.cultivation.select(self.snapshot).values()))
|
||||
self.manual_target = next(mon for mon in self.snapshot.raw["monsters"]
|
||||
if int(mon["id"]) != int(self.representative["id"]))
|
||||
|
||||
def policy(self, auto=False):
|
||||
return Policy(gift_enabled=True, gift_auto_representative=auto,
|
||||
gift_targets={} if auto else {str(self.manual_target["id"]): 1},
|
||||
gift_liked_only=False, gift_items={"30005": {"enabled": True, "reserve": 0}})
|
||||
|
||||
def test_auto_representative_is_the_effective_target_without_manual_targets(self):
|
||||
policy = self.policy(auto=True)
|
||||
|
||||
self.assertEqual([mon["id"] for mon in self.planner.candidates(self.snapshot, policy)],
|
||||
[self.representative["id"]])
|
||||
self.assertEqual([action.payload["monsterId"] for action in self.planner.plan(self.snapshot, policy)],
|
||||
[self.representative["id"]])
|
||||
|
||||
def test_manual_mode_uses_gift_targets_instead_of_representative(self):
|
||||
policy = self.policy()
|
||||
|
||||
self.assertEqual([mon["id"] for mon in self.planner.candidates(self.snapshot, policy)],
|
||||
[self.manual_target["id"]])
|
||||
self.assertEqual([action.payload["monsterId"] for action in self.planner.plan(self.snapshot, policy)],
|
||||
[self.manual_target["id"]])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -535,6 +535,8 @@ class ProgressionGuiTests(unittest.TestCase):
|
||||
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)
|
||||
@@ -610,6 +612,8 @@ class ProgressionGuiTests(unittest.TestCase):
|
||||
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))
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
import os
|
||||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||||
|
||||
import copy
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
from unittest.mock import Mock
|
||||
|
||||
from PySide6 import QtWidgets as W
|
||||
from PySide6.QtTest import QTest
|
||||
|
||||
from ranch_assistant import gui
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
|
||||
|
||||
TASKS = [
|
||||
{"task_type_id": "1101", "name": "主线进行中", "category": "mainline", "state": "received"},
|
||||
{"task_type_id": "1102", "name": "主线待接取", "category": "mainline", "state": "unlocked"},
|
||||
{"task_type_id": "1103", "name": "主线待领奖", "category": "mainline", "state": "ready_to_reward"},
|
||||
{"task_type_id": "1104", "name": "主线已完成", "category": "mainline", "state": "finished"},
|
||||
{"task_type_id": "1105", "name": "主线未解锁", "category": "mainline", "state": "locked"},
|
||||
{"task_type_id": "1106", "name": "支线进行中", "category": "sidequest", "state": "received"},
|
||||
{"task_type_id": "1107", "name": "主线受阻", "category": "mainline", "state": "received", "block_reason": "等级不足"},
|
||||
]
|
||||
|
||||
|
||||
class TaskStatusFilterTests(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 load_tasks(self, window, rows=TASKS):
|
||||
reader = Mock(return_value=copy.deepcopy(rows))
|
||||
records = Mock(return_value=[])
|
||||
window.engine.progression_rows = reader
|
||||
window.engine.progression_records = records
|
||||
window.tabs.setCurrentWidget(window.progression_page)
|
||||
self.wait(window, lambda: window.progression_views is not None
|
||||
and not window.progression_table.row_batch.running)
|
||||
return reader, records
|
||||
|
||||
def names(self, window):
|
||||
return sorted(window.progression_table.item(row, 2).text() for row in range(window.progression_table.rowCount()))
|
||||
|
||||
def select(self, window, widget, value, *, wait=True):
|
||||
index = widget.findData(value)
|
||||
self.assertGreaterEqual(index, 0, value)
|
||||
widget.setCurrentIndex(index)
|
||||
if wait:
|
||||
self.wait(window)
|
||||
else:
|
||||
self.app.processEvents()
|
||||
|
||||
def test_default_shows_only_current_mainline_and_reports_count(self):
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
self.load_tasks(window)
|
||||
self.assertEqual(window.progression_filter.currentData(), "mainline")
|
||||
self.assertEqual(window.progression_state_filter.currentData(), "current")
|
||||
self.assertEqual(self.names(window), sorted(["主线进行中", "主线待接取", "主线待领奖", "主线受阻"]))
|
||||
self.assertIn("显示 4 / 7", window.progression_task_status.text())
|
||||
self.select(window, window.progression_state_filter, "locked")
|
||||
self.assertEqual(self.names(window), ["主线未解锁"])
|
||||
self.select(window, window.progression_state_filter, "finished")
|
||||
self.assertEqual(self.names(window), ["主线已完成"])
|
||||
self.select(window, window.progression_state_filter, "ready_to_reward")
|
||||
self.assertEqual(self.names(window), ["主线待领奖"])
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_aliases_and_blocked_received_are_filtered_by_lifecycle(self):
|
||||
rows = TASKS + [
|
||||
{"task_type_id": "1201", "name": "旧进行中", "category": "mainline", "state": "active"},
|
||||
{"task_type_id": "1202", "name": "旧进行中别名", "category": "mainline", "state": "in_progress"},
|
||||
{"task_type_id": "1203", "name": "旧待接取", "category": "mainline", "state": "available"},
|
||||
{"task_type_id": "1204", "name": "旧未接取", "category": "mainline", "state": "unaccepted"},
|
||||
{"task_type_id": "1205", "name": "旧待领奖", "category": "mainline", "state": "ready"},
|
||||
{"task_type_id": "1206", "name": "旧已完成", "category": "mainline", "state": "completed"},
|
||||
{"task_type_id": "1207", "name": "旧完成别名", "category": "mainline", "state": "complete"},
|
||||
{"task_type_id": "1208", "name": "旧已领奖", "category": "mainline", "state": "claimed"},
|
||||
{"task_type_id": "1209", "name": "委托已提供", "category": "commission", "state": "offered"},
|
||||
]
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
self.load_tasks(window, rows)
|
||||
self.assertIn("主线受阻", self.names(window))
|
||||
self.select(window, window.progression_state_filter, "received")
|
||||
self.assertEqual(self.names(window), sorted(["主线进行中", "主线受阻", "旧进行中", "旧进行中别名"]))
|
||||
self.select(window, window.progression_state_filter, "unlocked")
|
||||
self.assertEqual(self.names(window), sorted(["主线待接取", "旧待接取", "旧未接取"]))
|
||||
self.select(window, window.progression_state_filter, "ready_to_reward")
|
||||
self.assertEqual(self.names(window), sorted(["主线待领奖", "旧待领奖"]))
|
||||
self.select(window, window.progression_state_filter, "finished")
|
||||
self.assertEqual(self.names(window), sorted(["主线已完成", "旧已完成", "旧完成别名", "旧已领奖"]))
|
||||
self.select(window, window.progression_filter, "commission")
|
||||
self.select(window, window.progression_state_filter, "unlocked")
|
||||
self.assertEqual(self.names(window), ["委托已提供"])
|
||||
self.assertEqual(window.progression_table.item(0, 3).text(), "待接取")
|
||||
prepared = window.progression_views.tasks
|
||||
offered = next(row for row in prepared if row["values"][0] == "1209")
|
||||
self.assertEqual(offered["state"], "offered")
|
||||
self.assertEqual(offered["lifecycle_state"], "unlocked")
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_status_category_search_combine_and_empty_state_is_clear(self):
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
reader, _ = self.load_tasks(window)
|
||||
self.select(window, window.progression_state_filter, "received")
|
||||
self.select(window, window.progression_filter, "sidequest")
|
||||
self.assertEqual(self.names(window), ["支线进行中"])
|
||||
window.progression_search.setText("没有匹配")
|
||||
self.wait(window)
|
||||
self.assertEqual(self.names(window), [])
|
||||
self.assertIn("没有符合", window.progression_task_status.text())
|
||||
self.assertIn("共 7 条", window.progression_task_status.text())
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
window.progression_search.clear()
|
||||
self.wait(window)
|
||||
self.select(window, window.progression_filter, "", wait=False)
|
||||
self.select(window, window.progression_state_filter, "", wait=False)
|
||||
self.assertEqual(len(self.names(window)), 7)
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_refresh_retains_filters_and_filter_changes_never_request(self):
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
reader, _ = self.load_tasks(window)
|
||||
self.select(window, window.progression_filter, "sidequest")
|
||||
self.select(window, window.progression_state_filter, "received")
|
||||
window.progression_search.setText("支线")
|
||||
self.wait(window)
|
||||
reader.reset_mock()
|
||||
window.engine.refresh_progression = Mock(
|
||||
return_value=(window.engine.snapshot, [], "离线刷新"))
|
||||
window.refresh_progression()
|
||||
self.wait(window)
|
||||
self.assertEqual(window.progression_filter.currentData(), "sidequest")
|
||||
self.assertEqual(window.progression_state_filter.currentData(), "received")
|
||||
self.assertEqual(window.progression_search.text(), "支线")
|
||||
self.assertEqual(self.names(window), ["支线进行中"])
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
reader.reset_mock()
|
||||
self.select(window, window.progression_filter, "mainline")
|
||||
self.select(window, window.progression_state_filter, "ready_to_reward")
|
||||
self.select(window, window.progression_state_filter, "current")
|
||||
self.assertEqual(reader.call_count, 0)
|
||||
self.assertEqual(window.engine.refresh_progression.call_count, 1)
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_task_state_filter_does_not_affect_battle_records(self):
|
||||
records = [
|
||||
{"timestamp": 1700000000, "battle_kind": "task_battle", "name": "记录甲", "outcome": "win"},
|
||||
{"timestamp": 1700000001, "battle_kind": "sweep", "name": "记录乙", "outcome": "completed"},
|
||||
]
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
reader, record_reader = self.load_tasks(window)
|
||||
record_reader.return_value = copy.deepcopy(records)
|
||||
self.select(window, window.progression_state_filter, "locked")
|
||||
window.tabs.setCurrentWidget(window.battle_records_page)
|
||||
self.wait(window, lambda: window.battle_records_table.rowCount() == 2)
|
||||
self.assertEqual(window.battle_records_filter.currentData(), "")
|
||||
self.assertEqual(window.progression_state_filter.currentData(), "locked")
|
||||
self.select(window, window.battle_records_filter, "sweep")
|
||||
self.assertEqual(window.battle_records_table.rowCount(), 1)
|
||||
self.assertEqual(window.battle_records_table.item(0, 2).text(), "记录乙")
|
||||
self.assertEqual(record_reader.call_count, 1)
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_two_windows_have_independent_filters(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)
|
||||
self.load_tasks(first)
|
||||
self.load_tasks(second)
|
||||
self.assertEqual(first.progression_filter.currentData(), "mainline")
|
||||
self.assertEqual(second.progression_filter.currentData(), "mainline")
|
||||
self.assertEqual(first.progression_state_filter.currentData(), "current")
|
||||
self.assertEqual(second.progression_state_filter.currentData(), "current")
|
||||
self.select(first, first.progression_filter, "sidequest")
|
||||
self.select(first, first.progression_state_filter, "received")
|
||||
self.assertEqual(self.names(first), ["支线进行中"])
|
||||
self.assertEqual(second.progression_filter.currentData(), "mainline")
|
||||
self.assertEqual(second.progression_state_filter.currentData(), "current")
|
||||
self.assertEqual(self.names(second), sorted(["主线进行中", "主线待接取", "主线待领奖", "主线受阻"]))
|
||||
finally:
|
||||
first.close()
|
||||
second.close()
|
||||
|
||||
def test_filter_changes_during_held_read_reuse_the_inflight_tasks(self):
|
||||
with workspace_temp() as folder:
|
||||
window = gui.Window(folder)
|
||||
window.timer.stop()
|
||||
entered = threading.Event()
|
||||
release = threading.Event()
|
||||
try:
|
||||
self.wait(window)
|
||||
def held_tasks():
|
||||
entered.set()
|
||||
if not release.wait(4):
|
||||
raise TimeoutError("task fixture was not released")
|
||||
return copy.deepcopy(TASKS)
|
||||
reader = Mock(side_effect=held_tasks)
|
||||
window.engine.progression_rows = reader
|
||||
window.tabs.setCurrentWidget(window.progression_page)
|
||||
self.assertTrue(entered.wait(2))
|
||||
self.assertTrue(window.busy)
|
||||
self.select(window, window.progression_filter, "", wait=False)
|
||||
self.select(window, window.progression_state_filter, "", wait=False)
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
self.assertFalse(window.pending_progression_view)
|
||||
release.set()
|
||||
self.wait(window, lambda: window.progression_table.rowCount() == 7)
|
||||
self.assertEqual(reader.call_count, 1)
|
||||
self.assertEqual(self.names(window), sorted(task["name"] for task in TASKS))
|
||||
finally:
|
||||
release.set()
|
||||
self.wait(window)
|
||||
window.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user