Add Web 2 workspace and controlled deployment updates

This commit is contained in:
AttilaNet
2026-11-10 16:33:14 +08:00
parent 7fe4c0ffdf
commit dbb31707ea
58 changed files with 11283 additions and 0 deletions
+179
View File
@@ -0,0 +1,179 @@
"""Focused pure-policy tests; no desktop imports or private account files."""
from copy import deepcopy
from pathlib import Path
import tempfile
import unittest
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.policy_io import portable_policy
from ranch_web.policies import apply_config, default_config, export_config, import_config, validate_config
class WebPolicyTests(unittest.TestCase):
def test_defaults_are_independent_and_match_current_desktop(self):
first, second = default_config(), default_config()
first["policy"]["gift_targets"]["900"] = 3
self.assertEqual(second["policy"]["gift_targets"], {})
self.assertTrue(second["policy"]["manual_eggs"])
self.assertEqual(second["progression_policy"]["battle_mode"], "experimental")
def test_validate_original_mode_before_normalizing_for_linux(self):
for source in ("original", "experimental"):
with self.subTest(source=source):
value = validate_config({"progression_policy": {"battle_mode": source}})
self.assertEqual(value["progression_policy"]["battle_mode"], "experimental")
with self.assertRaises(ValueError):
validate_config({"progression_policy": {"battle_mode": "unknown"}})
def test_validate_legacy_egg_mode_before_enforcing_current_desktop(self):
for flag in (False, True):
with self.subTest(flag=flag):
source = {"policy": {"manual_eggs": flag}}
value = validate_config(source)
self.assertTrue(value["policy"]["manual_eggs"])
self.assertIs(source["policy"]["manual_eggs"], flag)
for flag in (0, 1, "false", "true", None, [], {}):
with self.subTest(flag=flag), self.assertRaises(ValueError):
validate_config({"policy": {"manual_eggs": flag}})
def test_apply_legacy_mode_never_plans_unchecked_eggs(self):
with tempfile.TemporaryDirectory() as folder:
engine = Engine(Catalog(), budget_path=Path(folder) / "budget.json")
engine.snapshot = demo_snapshot(engine.catalog)
config = default_config()
config["policy"]["manual_eggs"] = False
applied = apply_config(engine, config)
self.assertTrue(applied["policy"]["manual_eggs"])
self.assertTrue(engine.policy.manual_eggs)
self.assertEqual(engine.planner.available_eggs(engine.snapshot, engine.policy), [])
self.assertEqual(engine.planner.hatch_actions(engine.snapshot, engine.policy), [])
egg = engine.snapshot.eggs(engine.catalog)[0]
config["policy"]["egg_rules"] = {str(egg["typeId"]): {"enabled": True}}
apply_config(engine, config)
eligible = engine.planner.available_eggs(engine.snapshot, engine.policy)
self.assertEqual([str(row["typeId"]) for row, _ in eligible], [str(egg["typeId"])])
actions = engine.planner.hatch_actions(engine.snapshot, engine.policy)
self.assertTrue(actions)
self.assertTrue(all(action.payload["eggs"][0]["itemId"] == egg["id"] for action in actions))
self.assertFalse(engine.auto)
def test_old_portable_both_schemas_enforce_selected_eggs_without_starting(self):
legacy = portable_policy(Policy(manual_eggs=False))
bundle = export_config(default_config())
bundle["policy"]["manual_eggs"] = False
for document in (legacy, bundle):
with self.subTest(schema=document["schema"]):
imported = import_config(document)
self.assertTrue(imported["policy"]["manual_eggs"])
self.assertTrue(export_config(imported)["policy"]["manual_eggs"])
for document in (legacy, bundle):
malformed = deepcopy(document)
malformed["policy"]["manual_eggs"] = "false"
with self.subTest(schema=document["schema"]), self.assertRaises(ValueError):
import_config(malformed)
def test_reject_unknown_secret_and_invalid_dynamic_paths(self):
bad = [
{"password": "synthetic"}, {"policy": {"token": "synthetic"}},
{"policy": {"gift_items": {"30001": {"enabled": True, "password": "synthetic"}}}},
{"policy": {"egg_rules": {"1001010": {"enabled": 1}}}},
{"policy": {"feed_targets": {"900": True}}},
{"policy": {"gift_targets": {"../../settings": 1}}},
{"policy": {"reserved_types": [True]}}, {"policy": {"protect_star": 0}},
{"policy": {"gift_items": {"30001": {"reserve": -1}}}},
{"policy": {"egg_rules": {"1001010": {"keep_count": 1001}}}},
{"policy": {"egg_rules": {"1001010": {"refill_below": 11, "refill_target": 10}}}},
{"sweep_policy": {"rules": {"0101": {"enabled": True, "limit": -1}}}},
{"sweep_policy": {"rules": {"0101": {"level": "4"}}}},
{"explore_policy": {"teams": {"1": {"monsters": [1, 2]}}}},
{"explore_policy": {"teams": {"1": {"monsters": [1, 2, 2]}}}},
{"explore_policy": {"teams": {"1": {"monsters": [True, 2, 3]}}}},
{"daily_policy": {"selected": ["all"]}}, {"interval": True},
{"overrides": {"1001010": {"sell_money": float("nan")}}},
{"overrides": {"1001010": {"time_total": -1}}},
{"overrides": {"1001010": {"path": "private"}}},
{"log_sizes": [0, 0]}, {"yield_stars": [True]},
]
for value in bad:
with self.subTest(value=value), self.assertRaises(ValueError):
validate_config(value)
def test_nested_defaults_and_fractional_thresholds_are_preserved(self):
value = validate_config({"policy": {"min_gold_per_hour": .5, "coins_per_exp": 2.75,
"egg_rules": {"1001010": {"keep_count": 7}}}})
self.assertEqual(value["policy"]["min_gold_per_hour"], .5)
self.assertEqual(value["policy"]["egg_rules"]["1001010"]["keep_count"], 7)
self.assertEqual(value["policy"]["egg_rules"]["1001010"]["action"], "sell")
def test_apply_is_atomic_and_never_starts_automation(self):
with tempfile.TemporaryDirectory() as folder:
engine = Engine(Catalog(), budget_path=Path(folder) / "budget.json")
original = engine.policy
with self.assertRaises(ValueError):
apply_config(engine, {"policy": {"protect_star": 6}, "quest_policy": {"enabled": "yes"}})
self.assertIs(engine.policy, original)
cfg = default_config()
cfg["progression_policy"]["battle_mode"] = "original"
cfg["policy"]["gift_targets"] = {"900": 2}
cfg["overrides"] = {"1001010": {"sell_money": 12.5}}
apply_config(engine, cfg)
self.assertFalse(engine.auto)
self.assertEqual(engine.progression_policy.battle_mode, "experimental")
self.assertEqual(engine.policy.gift_targets, {"900": 2})
self.assertEqual(engine.catalog.monster(1001010)["sell_money"], 12.5)
def test_portable_schema_two_remaps_species_and_normalizes_legacy_mode(self):
snapshot = demo_snapshot(Catalog())
config = default_config()
config["policy"].update(feed_targets={"900": 1}, gift_targets={"900": 2}, breakthrough_targets={"900": 3}, room_id=123456789)
config["sweep_policy"]["rules"] = {"0101": {"enabled": True, "level": "3", "limit": 4}}
exported = export_config(config, snapshot)
self.assertNotIn("feed_targets", exported["policy"])
self.assertNotIn("gift_targets", exported["policy"])
self.assertEqual(exported["policy"]["room_id"], 0)
self.assertNotIn("log_sizes", exported)
exported["progression_policy"]["battle_mode"] = "original"
exported["sweep_policy"]["rules"]["0101"]["level"] = 3
snapshot.monsters[900]["id"] = 999
imported = import_config(exported, snapshot)
for field, priority in (("feed_targets", 1), ("gift_targets", 2), ("breakthrough_targets", 3)):
self.assertEqual(imported["policy"][field], {"999": priority})
self.assertEqual(imported["progression_policy"]["battle_mode"], "experimental")
self.assertEqual(imported["sweep_policy"]["rules"]["0101"]["level"], "3")
self.assertEqual(import_config(exported)["policy"]["feed_targets"], {})
def test_schema_one_and_explore_import_never_copy_instance_ids(self):
snapshot = demo_snapshot(Catalog())
legacy = portable_policy(Policy(feed_targets={"900": 3}, protect_quality=6), snapshot)
snapshot.monsters[900]["id"] = 999
imported = import_config(legacy, snapshot)
self.assertEqual(imported["policy"]["feed_targets"], {"999": 3})
self.assertFalse(imported["policy"]["enabled"])
snapshot = demo_snapshot(Catalog())
for mid in (101, 102):
snapshot.monsters[mid].update(process=3, typeId=snapshot.monsters[900]["typeId"])
snapshot.raw["exploreTeams"] = [{"id": 800, "status": 0}]
config = default_config()
config["explore_policy"] = {"enabled": True, "reserve_ti": 9,
"teams": {"800": {"enabled": True, "area": "1", "monsters": [900, 101, 102]}}}
exported = export_config(config, snapshot)
snapshot.raw["exploreTeams"][0]["id"] = 50
for mon in snapshot.raw["monsters"]:
mon["id"] += 1000
imported = import_config(exported, snapshot)
self.assertNotIn("800", imported["explore_policy"]["teams"])
self.assertEqual(imported["explore_policy"]["teams"]["50"]["monsters"], [1101, 1102, 1900])
self.assertFalse(imported["explore_policy"]["enabled"])
def test_import_rejects_unknown_fields_instead_of_silently_dropping_them(self):
exported = export_config(default_config())
for value in (exported | {"token": "synthetic"},
exported | {"targetSpecies": {"feed": [{"typeId": "1001010", "priority": 2, "password": "synthetic"}]}},
exported | {"policy": exported["policy"] | {"feed_targets": {"900": True}}}):
with self.subTest(value=value), self.assertRaises(ValueError):
import_config(value)
if __name__ == "__main__":
unittest.main()