244 lines
13 KiB
Python
244 lines
13 KiB
Python
"""Offline exploration policy, pending-send, snapshot and data tests."""
|
|
from copy import deepcopy
|
|
from dataclasses import asdict
|
|
import json
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
|
|
from ranch_assistant.exploration import ExplorePlanner, ExplorePolicy, ExploreTeamRule, load_exploration_areas
|
|
from ranch_assistant.model import Catalog, Policy, Snapshot
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
|
|
|
|
NOW = 1_700_000_000
|
|
AREAS = {
|
|
"1": {"id": "1", "name": "测试矿洞", "passStage": "0101", "costTi": 20,
|
|
"costTime": 3600, "level": [5, 1, 1], "team": "normal"},
|
|
"2": {"id": "2", "name": "测试森林", "passStage": "0102", "costTi": 30,
|
|
"costTime": 7200, "level": [10, 2, 2], "team": "normal"},
|
|
}
|
|
|
|
|
|
def monster(mid, level, **changes):
|
|
return {"id": mid, "typeId": "1001010", "level": level, "process": 3,
|
|
"mode": 2, "lock": False, **changes}
|
|
|
|
|
|
def make_snapshot(**changes):
|
|
value = {"master": {"id": 11, "ti": 100}, "serverId": 7, "areaId": 1,
|
|
"items": [], "stacks": [], "rooms": [], "teams": [],
|
|
"monsters": [monster(mid, level) for mid, level in ((1, 20), (2, 15), (3, 10), (4, 8), (5, 7), (6, 6), (7, 5))],
|
|
"history": {"passTask": {"1001008": True},
|
|
"passStage": {"0101": {"1": True}, "0102": {"1": True}}},
|
|
"exploreTeams": [{"id": 1, "status": 0, "area": "", "monsters": ""}], **changes}
|
|
snapshot = Snapshot(value, received_at=NOW)
|
|
return patch("time.time", return_value=NOW), snapshot
|
|
|
|
|
|
def policy(**team):
|
|
values = {"enabled": True, "area": "1", "monsters": []} | team
|
|
return ExplorePolicy(True, {"1": ExploreTeamRule(**values)})
|
|
|
|
|
|
class ExplorationTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.catalog = Catalog()
|
|
|
|
def setUp(self):
|
|
self.clock, self.snapshot = make_snapshot()
|
|
self.clock.start()
|
|
self.addCleanup(self.clock.stop)
|
|
self.ranch = Policy(protect_star=6, protect_quality=5, keep_better_quality=False)
|
|
self.planner = ExplorePlanner(self.catalog, areas=AREAS)
|
|
|
|
def action(self, snapshot=None, planner=None, explore_policy=None):
|
|
return (planner or self.planner).plan(snapshot or self.snapshot, explore_policy or policy(), self.ranch)[0]
|
|
|
|
def start_confirmed(self, team, end=NOW + 3600):
|
|
team.update(status=1, area="1", monsters="1,2,3", endTime=end * 1000)
|
|
|
|
def test_static_data_and_source_extractor(self):
|
|
areas = load_exploration_areas()
|
|
self.assertEqual(len(areas), 22)
|
|
self.assertEqual(areas["1"]["name"], "废弃矿洞")
|
|
self.assertEqual(areas["1"]["level"], [4, 1, 1])
|
|
self.assertEqual(areas["1"]["passStage"], "0109")
|
|
self.assertTrue(all(row["team"] == "normal" and len(row["level"]) == 3 for row in areas.values()))
|
|
|
|
def test_policy_roundtrip_and_strict_validation(self):
|
|
configured = policy(monsters=[1, 2, 3])
|
|
self.assertEqual(ExplorePolicy.from_dict(json.loads(json.dumps(configured.to_dict()))), configured)
|
|
for value in ({"enabled": 1}, {"reserve_ti": -1}, {"reserve_ti": True},
|
|
{"teams": {"0": {"enabled": True, "area": "1", "monsters": []}}},
|
|
{"teams": {"1": {"enabled": True, "area": "bad", "monsters": []}}},
|
|
{"teams": {"1": {"enabled": True, "area": "1", "monsters": [1]}}},
|
|
{"teams": {"1": {"enabled": True, "area": "1", "monsters": [1, 1, 2]}}},
|
|
{"teams": {"1": {"enabled": True, "area": "1", "unknown": 1}}}):
|
|
with self.subTest(value=value), self.assertRaises(ValueError):
|
|
ExplorePolicy(**(asdict(ExplorePolicy()) | value))
|
|
|
|
def test_original_monster_eligibility_does_not_protect_lock_star_or_equipment(self):
|
|
selected = policy(monsters=[1, 2, 3])
|
|
for mid in (1, 2, 3):
|
|
self.snapshot.raw["monsters"][mid - 1].update(lock=True, sysLock=True, equip1=7)
|
|
action = self.action(explore_policy=selected)
|
|
self.assertEqual(action.payload["monsters"], [1, 2, 3])
|
|
self.assertEqual(self.planner.rows(self.snapshot, selected, self.ranch)[0]["state"], "可出发")
|
|
options = self.planner.member_options(self.snapshot, 1, selected, self.ranch)
|
|
self.assertTrue(all(option["automatic"] for option in options))
|
|
|
|
def test_automatic_excludes_battle_feed_gift_and_breakthrough_targets(self):
|
|
self.snapshot.raw["teams"] = [{"teamType": "battleTeam", "teamName": "teamA", "monsters": [1]}]
|
|
self.ranch.feed_targets = {"2": 1}
|
|
self.ranch.gift_targets = {"3": 1}
|
|
self.ranch.breakthrough_targets = {"4": 1}
|
|
action = self.action()
|
|
self.assertEqual(action.payload["monsters"], [5, 6, 7])
|
|
|
|
def test_manual_remains_available_when_automatic_targets_exhausted(self):
|
|
self.snapshot.raw["teams"] = [{"teamType": "battleTeam", "monsters": [1]}]
|
|
self.ranch.feed_targets = {str(mid): 1 for mid in (2, 3, 4, 5, 6, 7)}
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
|
|
row = self.planner.rows(self.snapshot, policy(), self.ranch)[0]
|
|
self.assertIn("手动", row["reason"])
|
|
manual = policy(monsters=[1, 2, 3])
|
|
self.assertEqual(self.action(explore_policy=manual).payload["monsters"], [1, 2, 3])
|
|
options = self.planner.member_options(self.snapshot, 1, manual, self.ranch)
|
|
self.assertEqual(len(options), 7)
|
|
self.assertTrue(all(not option["automatic"] for option in options))
|
|
|
|
def test_manual_missing_leader_and_other_team_members_do_not_raise(self):
|
|
for ids in ([99, 2, 3], [1, 2, 2]):
|
|
if len(set(ids)) == 3:
|
|
selected = policy(monsters=ids)
|
|
self.assertEqual(self.planner.plan(self.snapshot, selected, self.ranch), [])
|
|
row = self.planner.rows(self.snapshot, selected, self.ranch)[0]
|
|
self.assertIn("不存在", row["reason"])
|
|
self.snapshot.raw["exploreTeams"].append({"id": 2, "status": 1, "area": "2", "monsters": "2", "endTime": (NOW + 30) * 1000})
|
|
selected = policy(monsters=[1, 2, 3])
|
|
self.assertIn("其他探险队", self.planner.rows(self.snapshot, selected, self.ranch)[0]["reason"])
|
|
|
|
def test_raw_string_members_unlock_stamina_and_finish_priority(self):
|
|
self.assertFalse(self.planner.area_unlocked(self.snapshot, AREAS["1"] | {"passStage": "0103"}))
|
|
self.snapshot.raw["history"]["passStage"]["0101"] = {"2": True}
|
|
self.assertFalse(self.planner.area_unlocked(self.snapshot, AREAS["1"]))
|
|
self.snapshot.raw["history"]["passStage"]["0101"]["1"] = True
|
|
self.snapshot.raw["master"]["ti"] = 19
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
|
|
self.snapshot.raw["master"]["ti"] = 100
|
|
self.snapshot.raw["exploreTeams"].append({"id": 2, "status": 1, "area": "1", "endTime": (NOW + 60) * 1000})
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
|
|
self.snapshot.raw["exploreTeams"].pop()
|
|
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", monsters="1,2,3", endTime=(NOW - 1) * 1000)
|
|
self.assertEqual(self.action().kind, "explore_finish")
|
|
self.assertEqual(self.planner.rows(self.snapshot, policy(), self.ranch)[0]["monster_ids"], [1, 2, 3])
|
|
|
|
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):
|
|
self.snapshot.raw["exploreTeams"][0].update(status=1, endTime=value, monsters="1,2,3")
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
|
|
self.assertEqual(self.planner.rows(self.snapshot, policy(), self.ranch)[0]["state"], "状态待同步")
|
|
|
|
def test_success_with_stale_snapshot_never_repeats_start_even_after_restart(self):
|
|
with workspace_temp() as folder:
|
|
path = folder / "exploration-state.json"
|
|
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
|
action = self.action(planner=planner)
|
|
response = planner.execute(self.snapshot, action, Mock(return_value={"resCode": 0}))
|
|
self.assertEqual(response, {"resCode": 0})
|
|
for _ in range(3):
|
|
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
|
|
self.assertFalse(planner.reconcile(self.snapshot))
|
|
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
|
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
|
|
self.assertTrue(restored.pending(self.snapshot)["confirmed"])
|
|
self.start_confirmed(self.snapshot.raw["exploreTeams"][0])
|
|
self.assertTrue(restored.reconcile(self.snapshot))
|
|
self.assertIsNone(restored.pending(self.snapshot))
|
|
|
|
def test_success_with_stale_snapshot_never_repeats_finish_even_after_restart(self):
|
|
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", monsters="1,2,3", endTime=(NOW - 1) * 1000)
|
|
with workspace_temp() as folder:
|
|
path = folder / "state.json"
|
|
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
|
action = self.action(planner=planner)
|
|
planner.execute(self.snapshot, action, Mock(return_value={"resCode": 0}))
|
|
for _ in range(3):
|
|
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
|
|
self.assertFalse(planner.reconcile(self.snapshot))
|
|
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
|
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
|
|
self.snapshot.raw["exploreTeams"][0].update(status=0, monsters="", endTime=0)
|
|
self.assertTrue(restored.reconcile(self.snapshot))
|
|
self.assertEqual(self.action(planner=restored).kind, "explore_start")
|
|
|
|
def test_unknown_write_requires_authoritative_matching_snapshot(self):
|
|
with workspace_temp() as folder:
|
|
planner = ExplorePlanner(self.catalog, areas=AREAS, path=folder / "state.json")
|
|
action = self.action(planner=planner)
|
|
planner.mark_started(self.snapshot, action)
|
|
planner.mark_uncertain(self.snapshot, action)
|
|
restored = ExplorePlanner(self.catalog, areas=AREAS, path=folder / "state.json")
|
|
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
|
|
self.start_confirmed(self.snapshot.raw["exploreTeams"][0])
|
|
self.assertTrue(restored.reconcile(self.snapshot))
|
|
self.assertFalse(restored.reconcile(self.snapshot))
|
|
|
|
def test_unknown_action_cannot_be_forged_or_confirmed(self):
|
|
from ranch_assistant.model import Action
|
|
action = self.action()
|
|
forged = Action("explore_start", "forged", "exploreService/start", deepcopy(action.payload))
|
|
with self.assertRaises(ValueError):
|
|
self.planner.mark_started(self.snapshot, forged)
|
|
self.planner.mark_started(self.snapshot, action)
|
|
with self.assertRaises(ValueError):
|
|
self.planner.mark_started(self.snapshot, action)
|
|
self.assertTrue(self.planner.pending(self.snapshot))
|
|
self.planner._accounts.clear()
|
|
with self.assertRaises(ValueError):
|
|
self.planner.mark_started(self.snapshot, forged)
|
|
|
|
def test_pending_persistence_hashed_role_and_has_no_credentials(self):
|
|
with workspace_temp() as folder:
|
|
path = folder / "state.json"
|
|
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path, account_key="profile-only")
|
|
action = self.action(planner=planner)
|
|
planner.mark_started(self.snapshot, action)
|
|
text = path.read_text(encoding="utf-8")
|
|
state = json.loads(text)
|
|
key = next(iter(state["accounts"]))
|
|
self.assertRegex(key, r"^[0-9a-f]{64}$")
|
|
self.assertNotIn("11", key)
|
|
for secret in ("password", "token", "sdkToken", "account_name", "session_token"):
|
|
self.assertNotIn(secret, text)
|
|
other_clock, other = make_snapshot(master={"id": 12, "ti": 100})
|
|
with other_clock:
|
|
self.assertIsNone(planner.pending(other))
|
|
self.assertEqual(planner.plan(other, policy(), self.ranch)[0].kind, "explore_start")
|
|
|
|
def test_corrupt_state_blocks_instead_of_replaying(self):
|
|
with workspace_temp() as folder:
|
|
path = folder / "state.json"
|
|
path.write_text("{broken", encoding="utf-8")
|
|
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
|
|
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
|
|
|
|
def test_worker_rows_are_compact_plain_data(self):
|
|
from ranch_assistant.exploration_gui import prepare_exploration_rows, prepare_exploration_members
|
|
from types import SimpleNamespace
|
|
engine = SimpleNamespace(snapshot=self.snapshot, explore_planner=self.planner, explore_policy=policy(), policy=self.ranch)
|
|
rows = prepare_exploration_rows(engine)
|
|
self.assertEqual(rows[0]["monster_labels"], ["#1 绿色史莱姆 Lv.20", "#2 绿色史莱姆 Lv.15", "#3 绿色史莱姆 Lv.10"])
|
|
self.assertEqual(rows[0]["remaining_text"], "—")
|
|
json.dumps(rows)
|
|
options = prepare_exploration_members(engine, 1)
|
|
self.assertLess(len(json.dumps(options)), 4000)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|