Improve task filters, exploration rewards and V4 battle simulation

This commit is contained in:
AttilaNet
2026-11-10 14:09:53 +08:00
parent 5082c2df5c
commit 6d74730735
20 changed files with 1129 additions and 42 deletions
@@ -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()
+105
View File
@@ -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()