fix(web): finalize quick battle and commission procurement for 2.0.9

This commit is contained in:
AttilaNet
2026-11-13 11:28:14 +08:00
parent cfce3e0bc5
commit 7845751cf6
21 changed files with 2442 additions and 117 deletions
+184
View File
@@ -0,0 +1,184 @@
"""Aggregate contract tests; synthetic rosters and public original task data."""
from copy import deepcopy
import threading
import unittest
from ranch_assistant.battle_quick import MAX_GENERATED, prepare, simulate_quick
from ranch_assistant.battle_simulator import (
DESKTOP_DAMAGE_PROFILE, ExperimentalBattleRuntime, _prepare, combat_tables, simulate,
)
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.tests.test_battle_simulator import battle_of, enemy, monster, request
class QuickBattleTests(unittest.TestCase):
def test_default_worker_matches_aggregate_and_preserves_detailed_entrypoint(self):
req = request()
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result, simulate_quick(req))
self.assertEqual(result["simulation_method"], "aggregate_hp_dps")
self.assertNotEqual(result["model"], simulate(req)["model"])
self.assertTrue(result["approximate"])
self.assertFalse(result["faithful"])
self.assertFalse(result["settlement_eligible"])
def test_original_player_and_authored_enemy_stats_are_preserved(self):
req = request(enemies=[enemy(atk=31, hp=101, dex=7)])
battle_of(req).update(scaleAbility=1.2, scaleHp=1.5)
detailed, _ = _prepare(req, combat_tables())
quick, report = prepare(req)
self.assertEqual([u.stats for u in quick.units], [u.stats for u in detailed.units])
self.assertEqual(report["units"][1]["stats"]["hp"], 151)
def test_unknown_controllers_skills_and_path_data_are_warnings(self):
req = request(players=[monster(species=1001020)], enemies=[enemy(controller=[
{"type": "unmodeled", "para": {}}, {"type": "monSteps", "para": {"points": ["absent"]}}])])
battle_of(req)["controller"] = [{"type": "other_effect", "para": {}}]
battle_of(req).pop("battleField")
report = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(report["supported"], report["reasons"])
self.assertTrue(report["assumptions"])
self.assertIn("unmodeled", report["aggregate_controllers"])
self.assertTrue(any(d["code"] == "aggregate_skill" for d in report["diagnostics"]))
self.assertEqual(simulate_quick(req)["execution_status"], "completed")
def test_missing_growth_or_original_species_still_refuses(self):
req = request()
req["roster"]["monsters"][0].pop("gAtk")
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
req = request(enemies=[enemy(type="unknown")])
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
def test_empty_survival_battle_runs_until_original_clock(self):
req = request(seconds=3, enemies=[])
battle_of(req)["winType"] = ["2"]
result = simulate_quick(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["elapsed_ms"], 3000)
self.assertEqual(result["battle_data"]["leftTime"], 0)
self.assertEqual(result["terminal_reason"], "battle_time_limit")
def test_standalone_maker_has_a_bounded_real_numeric_enemy_budget(self):
req = request(seconds=140, enemies=[])
battle_of(req)["winType"] = ["2"]
battle_of(req)["controller"] = [{"type": "monMaker", "para": {
"monType": 1001010, "team": 2, "hp": 1, "atk": 0, "interval": 1}}]
result = simulate_quick(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["generated_units"], MAX_GENERATED)
self.assertTrue(result["spawn_bound_reached"])
self.assertGreater(result["damage_hp_lost"]["2"], 0)
self.assertEqual(result["elapsed_ms"], 140000)
def test_unknown_generated_species_is_missing_numeric_data(self):
req = request(enemies=[])
battle_of(req)["controller"] = [{"type": "monMaker", "para": {"monType": 999999999}}]
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
def test_zero_capacity_team_can_deploy_uncounted_authored_enemies(self):
req = request(enemies=[enemy(countUnit=False)])
battle_of(req)["teams"][0]["numMax"] = 0
result = simulate_quick(req)
self.assertTrue(result["supported"], result["reasons"])
self.assertIsNotNone(result["units"][1]["joined_ms"])
self.assertEqual(result["execution_status"], "completed")
def test_weak_team_loses_without_assigned_victory(self):
result = simulate_quick(request(players=[monster(level=1)], enemies=[enemy(hp=10000, atk=10000)]))
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["alive_num"], 0)
self.assertFalse(result["battle_data"]["win"])
def test_protect_any_and_protect_all_use_actual_remaining_hp(self):
req = request(seconds=3, players=[monster(level=1)], enemies=[
enemy(mid=11, team=1, protectTarget=True, hp=1, atk=0),
enemy(mid=12, team=1, protectTarget=True, hp=10000, atk=0),
enemy(mid=13, hp=100000, atk=20)])
battle_of(req).update(winType=["2"], loseType=["3", "2"])
result = simulate_quick(req)
self.assertEqual(result["outcome"], "loss")
self.assertLess(result["elapsed_ms"], 3000)
battle_of(req)["loseType"] = ["4", "2"]
result = simulate_quick(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["elapsed_ms"], 3000)
protected = [u for u in result["units"] if u["protect_target"]]
self.assertEqual(sum(u["hp"] > 0 for u in protected), 1)
def test_destroy_any_and_destroy_all_are_distinct(self):
req = request(seconds=3, enemies=[enemy(mid=11, destroyTarget=True, hp=1, atk=0),
enemy(mid=12, destroyTarget=True, hp=100000, atk=0)])
battle_of(req)["winType"] = ["3"]
self.assertEqual(simulate_quick(req)["outcome"], "win")
battle_of(req)["winType"] = ["4"]
result = simulate_quick(req)
self.assertEqual(result["outcome"], "loss")
self.assertGreater(next(u for u in result["units"] if u["source_id"] == "12")["hp"], 0)
def test_task_1002013_public_configuration_runs_without_changing_inputs(self):
req = request(context="task_pass_stage", damage_profile=DESKTOP_DAMAGE_PROFILE,
players=[monster(level=20), monster(102, level=20), monster(103, level=20)])
req["original_data"]["battle"] = ProgressionData().task_battle("1002013", 1)
before = deepcopy(req)
result = simulate_quick(req)
self.assertTrue(result["supported"], result["reasons"])
self.assertIn(result["outcome"], ("win", "loss"))
self.assertEqual(req, before)
boss = next(u for u in result["units"] if u["species"] == 3012010)
nest = next(u for u in result["units"] if u["species"] == 9998002)
if boss["joined_ms"] is not None:
self.assertIsNotNone(nest["died_ms"])
self.assertGreaterEqual(boss["joined_ms"], nest["died_ms"])
def test_task_1001001_blank_default_mids_preserve_original_stats(self):
req = request(context="task_battle")
req["original_data"]["battle"] = ProgressionData().task_battle("1001001", 1)
self.assertTrue(any(m.get("mid") == "" for t in battle_of(req)["teams"] for m in t["mons"] if m))
before = deepcopy(req)
detailed, _ = _prepare(req, combat_tables())
quick, report = prepare(req)
self.assertTrue(report["supported"], report["reasons"])
self.assertEqual([u.stats for u in quick.units], [u.stats for u in detailed.units])
result = simulate_quick(req)
self.assertEqual(result["execution_status"], "completed")
self.assertIn(result["outcome"], ("win", "loss"))
self.assertEqual(req, before)
def test_cap_applies_per_hit_after_expected_skill_gain(self):
req = request(players=[monster(pAtk=10000)], enemies=[enemy(hp=1000000, atk=0)],
seconds=1, damage_profile=DESKTOP_DAMAGE_PROFILE)
result = simulate_quick(req)
attack_ms = result["units"][0]["stats"]["attack_ms"]
self.assertLessEqual(result["team_budgets"]["1"]["peak_expected_dps"], round(50000 * 1000 / attack_ms, 3))
self.assertEqual(result["damage_multiplier"], 10)
self.assertEqual(result["damage_cap"], 50000)
def test_anomaly_records_and_trace_bounds_are_preserved(self):
req = request(players=[monster(mid=100001, feel=201)], trace_limit=0)
report = ExperimentalBattleRuntime().inspect(req)
result = simulate_quick(req)
for anomaly in report["anomalies"]:
self.assertIn(anomaly, result["anomalies"])
self.assertEqual(result["battle_data"]["cheatRecords"], result["anomalies"])
self.assertFalse(result["experimental_settlement_eligible"])
self.assertEqual(result["events"], [])
def test_cancel_and_technical_timeout_have_no_settlement_data(self):
event = threading.Event()
event.set()
for result in (simulate_quick(request(), cancel_event=event), simulate_quick(request(), timeout=0)):
self.assertIn(result["outcome"], ("cancelled", "timeout"))
self.assertFalse(result["terminal"])
self.assertIsNone(result["battle_data"])
def test_local_runtime_evidence_retains_model_and_hp_dps(self):
result = simulate_quick(request())
evidence = BattleOrchestrator.runtime_evidence(result, "experimental")
for name in ("model", "simulation_method", "team_budgets", "generated_units", "spawn_bound_reached"):
self.assertEqual(evidence[name], result[name])
self.assertNotIn(name, result["battle_data"])
if __name__ == "__main__":
unittest.main()
@@ -415,8 +415,9 @@ class SimulatorTests(unittest.TestCase):
req = request(players=[monster(species=1001020)]) # actual skill 10
report = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(report["supported"])
self.assertTrue(any(d["code"] == "unsupported_skill" and "10" in d["message"] for d in report["diagnostics"]))
self.assertTrue(any("Skill 10" in x for x in report["ignored_mechanics"]))
self.assertTrue(any(d["code"] == "aggregate_skill" and "10" in d["message"] for d in report["diagnostics"]))
self.assertTrue(any("bounded expected" in x for x in report["assumptions"]))
self.assertTrue(any(d["code"] == "unsupported_skill" for d in simulate(req)["diagnostics"]))
def test_controllers_triggers_and_non_elimination_are_rejected(self):
for key, value in (("controller", [{"type": "monMaker"}]),
@@ -476,11 +477,13 @@ class WorkerTests(unittest.TestCase):
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["battle_data"]["battlePosition"], req["battle_position"])
def test_fixed_module_subprocess_equals_direct_model(self):
def test_fixed_module_subprocess_uses_quick_model_by_default(self):
from ranch_assistant.battle_quick import simulate_quick
req = request()
with patch("socket.socket", side_effect=AssertionError("No network")):
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result, simulate(req))
self.assertEqual(result, simulate_quick(req))
self.assertEqual(result["simulation_method"], "aggregate_hp_dps")
def test_worker_entrypoint_does_not_import_gui_or_production_engine(self):
completed = subprocess.run([sys.executable, "-c",
@@ -0,0 +1,393 @@
"""Offline task procurement replay: all writes go to the fake below."""
from copy import deepcopy
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
from ranch_assistant.quests import QuestPolicy
from ranch_assistant.tests.test_progression import config, snapshot, step, task
EGG = "1030010"
def requirement(kind="getMonster", count=1, key=EGG):
return step(kind, statusValue={"type": key, "num": count, "mode": 2 if kind == "getMonster" else 0, "remove": True})
def monster(catalog, mid, **changes):
row = catalog.monster(EGG)
return {"id": mid, "typeId": int(EGG), "mode": 2, "process": 3, "level": 1, "roomId": 1,
**{"g" + stat.capitalize(): row[stat + "_grow_min"] for stat in ("atk", "def", "hp", "dex")}, **changes}
class OfflineProcurementClient:
def __init__(self, raw, catalog):
self.raw, self.catalog, self.writes = deepcopy(raw), catalog, []
self.timeout = False
def snapshot(self):
return Snapshot(deepcopy(self.raw))
def call(self, path, payload):
self.writes.append((path, deepcopy(payload)))
if self.timeout:
raise TimeoutError("offline fake lost reply")
if path == "gachaService/gachaGetEggs":
count = payload["num"]
self.raw["master"]["money"] -= self.catalog.data["markets"][payload["id"]]["money"] * count
existing = next((i for i in self.raw["items"] if str(i["typeId"]) == EGG), None)
if existing:
existing["num"] += count
else:
self.raw["items"].append({"id": 500, "typeId": int(EGG), "num": count})
return {"resCode": 0, "eggs": [{"typeId": int(EGG), "num": count}]}
if path == "stackService/stackAddMonster":
for egg in payload["eggs"]:
item = next(i for i in self.raw["items"] if i["id"] == egg["itemId"])
item["num"] -= 1
mid = max([m["id"] for m in self.raw["monsters"]] + [900]) + 1
self.raw["monsters"].append(monster(self.catalog, mid, mode=0, process=2,
timeStart=self.snapshot().now * 1000, roomId=0))
next(s for s in self.raw["stacks"] if s["id"] == egg["stackId"])["monsterId"] = mid
return {"resCode": 0}
if path == "stackService/stackTransferMonster":
for data in payload["datas"]:
for mid in data["monsterId"]:
next(m for m in self.raw["monsters"] if m["id"] == mid).update(process=3, roomId=data["roomId"])
for stack in self.raw["stacks"]:
if stack["monsterId"] == mid:
stack["monsterId"] = 0
return {"resCode": 0}
if path == "taskService/taskLoopReceive":
received = {"id": 51, "typeId": payload["taskTypeId"], "curStep": 1}
self.raw["currentTasks"].append(received)
self.raw["history"]["loopTaskNum"] -= 1
return {"resCode": 0, "task": deepcopy(received)}
if path == "taskService/taskCompleteStep":
for mid in payload.get("removeIds") or []:
self.raw["monsters"] = [m for m in self.raw["monsters"] if m["id"] != mid]
for stack in self.raw["stacks"]:
if stack["monsterId"] == mid:
stack["monsterId"] = 0
next(t for t in self.raw["currentTasks"] if t["id"] == payload["taskId"])["curStep"] += 1
return {"resCode": 0, "taskStepValue": None}
if path == "taskService/taskComplete":
self.raw["currentTasks"] = [t for t in self.raw["currentTasks"] if t["id"] != payload["taskId"]]
return {"resCode": 0, "reward": {"ke": 20}}
raise AssertionError("Unexpected fake write: " + path)
class CommissionProcurementTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
# Keep a real gold market and real growth/protection rules; make the
# offline draw deterministic without asserting real RNG outcomes.
self.catalog.data["markets"]["sc_city1"]["eggs"] = {"2": [int(EGG)]}
self.tasks = {"400": task("400", type=4, reward={"ke": 20}, steps=[requirement()]),
"401": task("401", type=4, reward={"ke": 15})}
self.data = ProgressionData(config(self.tasks))
self.raw = snapshot(currentTasks=[]).raw
self.raw["master"]["money"] = 10000
self.raw["history"].update(loopTaskTime=snapshot().now, loopTaskNum=4, loopTask={"2": ["400"], "1": ["401"]}, unlockCity={"1": True, "2": True})
self.raw["stacks"] = [{"id": i + 1, "position": i % 3, "monsterId": 0} for i in range(10)]
self.quest = QuestPolicy(enabled=True, allow_monsters=True, allow_items=True)
self.ranch = Policy(buy=True, allow_single_draw=True, buy_batch=5)
self.folder = tempfile.TemporaryDirectory()
self.addCleanup(self.folder.cleanup)
def engine(self, *, raw=None, folder=None):
client = OfflineProcurementClient(raw or self.raw, self.catalog)
engine = Engine(self.catalog, client, Path(folder or self.folder.name) / "budget.json", game_data=self.data)
engine.snapshot = client.snapshot()
engine.policy, engine.quest_policy = deepcopy(self.ranch), deepcopy(self.quest)
engine._refresh_progression_cache(force=True)
self.assertEqual(engine._progression_error, "")
return engine, client
def sync(self, engine, client):
engine.snapshot = client.snapshot()
engine._refresh_progression_cache(force=True)
def intent(self, engine):
return next(i for i in engine._progression_intents if not i.block_reason)
def test_cross_city_twenty_buy_hatch_wait_submit_complete_replay(self):
engine, client = self.engine()
buy = self.intent(engine)
self.assertEqual((buy.kind, buy.phase, buy.source_task_type_id), ("progression_procure", "buy", "400"))
self.assertEqual(buy.payload["num"], 1)
offer = next(r for r in engine.commission_offer_diagnostics() if r["task_type_id"] == "400")
self.assertFalse(offer["eligible"])
self.assertTrue(offer["preparable"])
self.assertEqual(offer["resources"][0]["available"], 0)
engine._run_progression_intent(buy)
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
hatch = self.intent(engine)
self.assertEqual(hatch.phase, "hatch")
engine._run_progression_intent(hatch)
self.assertEqual(engine.snapshot.raw["history"]["loopTaskNum"], 4)
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
for _ in range(3):
self.sync(engine, client)
self.assertEqual([p for p, _ in client.writes], ["gachaService/gachaGetEggs", "stackService/stackAddMonster"])
client.raw["monsters"][0].update(mode=2)
self.sync(engine, client)
accept = self.intent(engine)
self.assertEqual((accept.kind, accept.payload["city"]), ("progression_loop_accept", 2))
engine._run_progression_intent(accept)
for _ in range(3):
engine._run_progression_intent(self.intent(engine))
self.assertEqual(engine.commission_history()["summary"]["confirmed_ke"], 20)
self.assertEqual(client.raw["history"]["loopTaskNum"], 3)
def test_one_missing_ten_empty_slots_thousand_eggs_hatches_only_one(self):
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 1000}]
engine, client = self.engine()
intent = self.intent(engine)
self.assertEqual(len(intent.payload["eggs"]), 1)
engine._run_progression_intent(intent)
self.assertEqual(sum(bool(s["monsterId"]) for s in client.raw["stacks"]), 1)
self.assertEqual(client.raw["items"][0]["num"], 999)
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
self.assertFalse(any(a.kind in ("buy", "hatch") for a in engine.plans()))
self.assertEqual(engine.pending_hatches, [])
def test_quota_zero_never_procures_or_accepts(self):
self.raw["history"]["loopTaskNum"] = 0
engine, client = self.engine()
engine._run_progression_intent()
self.assertEqual(client.writes, [])
self.assertTrue(all(r["reason_kind"] == "quota" and not r["preparable"] for r in engine.commission_offer_diagnostics()))
def test_existing_eggs_and_incubator_count_before_buy(self):
self.tasks["400"]["steps"] = [requirement(count=3)]
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 1}]
self.raw["monsters"] = [monster(self.catalog, 901, mode=0, process=2, timeStart=snapshot().now * 1000)]
self.raw["stacks"][0]["monsterId"] = 901
engine, client = self.engine()
engine._run_progression_intent(self.intent(engine)) # reuse the egg
buy = self.intent(engine)
self.assertEqual(buy.phase, "buy")
self.assertEqual(buy.payload["num"], 1)
engine._run_progression_intent(buy)
self.assertEqual(sum(p == "gachaService/gachaGetEggs" for p, _ in client.writes), 1)
def test_shared_eggs_user_reserve_and_multistep_demands_are_not_double_counted(self):
self.tasks["400"]["steps"] = [requirement("getItem", 1), requirement("getItem", 1), requirement(count=1)]
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 5}]
self.ranch.reserved_eggs = {EGG: 2}
engine, client = self.engine()
self.assertEqual(self.intent(engine).phase, "hatch")
engine._run_progression_intent(self.intent(engine))
self.assertEqual(client.raw["items"][0]["num"], 4) # 2 task eggs + 2 user reserve
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
self.assertFalse(any(path == "gachaService/gachaGetEggs" for path, _ in client.writes))
def test_multistep_adult_removals_cannot_reuse_one_monster(self):
self.tasks["400"]["steps"] = [requirement(), requirement()]
self.raw["monsters"] = [monster(self.catalog, 901)]
engine, _ = self.engine()
buy = self.intent(engine)
self.assertEqual(buy.payload["num"], 1)
self.assertEqual(engine.commission_offer_diagnostics()[0]["resources"][0]["needed"], 2)
def test_active_same_species_steps_buy_remaining_deficit_and_advance(self):
self.tasks["400"]["steps"] = [requirement(), requirement()]
for cursor in (1, 2):
with self.subTest(cursor=cursor), tempfile.TemporaryDirectory(dir=self.folder.name) as folder:
raw = deepcopy(self.raw)
raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": cursor}]
engine, client = self.engine(raw=raw, folder=folder)
deficit = 3 - cursor
buy = self.intent(engine)
self.assertEqual((buy.kind, buy.phase, buy.source_task_id), ("progression_procure", "buy", 51))
self.assertEqual(buy.payload["num"], deficit)
engine._run_progression_intent(buy)
self.assertEqual(client.writes, [("gachaService/gachaGetEggs", buy.payload)])
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
for _ in range(deficit):
hatch = self.intent(engine)
self.assertEqual((hatch.kind, hatch.phase), ("progression_procure", "hatch"))
engine._run_progression_intent(hatch)
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
for _ in range(3):
engine._run_progression_intent()
self.assertEqual(len(client.writes), 1 + deficit)
self.assertEqual(client.raw["currentTasks"][0]["curStep"], cursor)
for growing in client.raw["monsters"]:
growing["mode"] = 2
self.sync(engine, client)
submitted = []
for number in range(cursor, 3):
submit = self.intent(engine)
self.assertEqual((submit.kind, submit.step_number), ("progression_step", number))
submitted.extend(submit.payload["removeIds"])
engine._run_progression_intent(submit)
self.assertEqual(client.raw["currentTasks"][0]["curStep"], number + 1)
local = self.intent(engine)
self.assertEqual(local.kind, "progression_local_step")
engine._run_progression_intent(local)
self.assertEqual(len(set(submitted)), deficit)
complete = self.intent(engine)
self.assertEqual(complete.kind, "progression_complete")
engine._run_progression_intent(complete)
purchases = [payload["num"] for path, payload in client.writes if path == "gachaService/gachaGetEggs"]
self.assertEqual(purchases, [deficit])
self.assertEqual(client.raw["currentTasks"], [])
self.assertEqual(client.raw["history"]["loopTaskNum"], 4)
self.assertEqual(engine.commission_history()["summary"]["confirmed_ke"], 20)
def test_active_procurement_keeps_future_handin_money_in_both_checks(self):
handin = 500
self.tasks["400"]["steps"] = [requirement(count=2),
step("getMoney", statusValue={"money": handin, "remove": True})]
self.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
self.quest.max_money = handin
price = self.catalog.data["markets"]["sc_city1"]["money"]
self.raw["master"]["money"] = self.ranch.keep_money + handin + price
engine, client = self.engine()
buy = self.intent(engine)
self.assertEqual((buy.kind, buy.phase, buy.payload["num"]), ("progression_procure", "buy", 1))
engine._run_progression_intent(buy)
self.assertEqual(client.writes, [("gachaService/gachaGetEggs", buy.payload)])
self.assertEqual(client.raw["master"]["money"], self.ranch.keep_money + handin)
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
self.assertEqual(client.raw["currentTasks"][0]["curStep"], 1)
def test_protected_duplicates_are_reported_and_not_submitted(self):
self.raw["monsters"] = [monster(self.catalog, 1, lock=True), monster(self.catalog, 2),
monster(self.catalog, 3), monster(self.catalog, 4)]
self.raw["teams"] = [{"name": "teamA", "monsters": [2]}]
self.ranch.feed_targets = {"3": 1}
engine, client = self.engine()
info = self.data.task("400")
ready, ids, reason = engine.progression_planner.requirement(engine.snapshot, info["steps"][0], {},
engine._intent_policy({"task_type_id": "400"}), engine.policy)
self.assertTrue(ready)
self.assertEqual(ids, [4])
self.assertIn("保护3", reason)
self.assertIn("已锁定", reason)
engine._run_progression_intent(self.intent(engine))
engine._run_progression_intent(self.intent(engine))
self.assertEqual({m["id"] for m in client.raw["monsters"]}, {1, 2, 3})
def test_protected_star_species_cannot_be_procured_by_unprotecting(self):
self.ranch.protect_star = 2
engine, client = self.engine()
row = engine.commission_offer_diagnostics()[0]
self.assertFalse(row["eligible"] or row["preparable"])
self.assertIn("新孵魔物也受", row["reason"])
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
self.assertEqual(client.writes, [])
def test_coin_reserve_daily_budget_and_ten_draw_rule_remain_enforced(self):
for changes in ({"daily_buy_money": 0}, {"keep_money": 10000}, {"allow_single_draw": False}):
with self.subTest(changes=changes):
self.ranch = Policy(buy=True, allow_single_draw=True, **{k: v for k, v in changes.items() if k != "allow_single_draw"})
if "allow_single_draw" in changes:
self.ranch.allow_single_draw = False
engine, client = self.engine()
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
self.assertEqual(client.writes, [])
def test_stop_and_changed_offer_cancel_before_dispatch(self):
for change in (lambda e: e.cancel_progression(), lambda e: e.snapshot.raw["history"].update(loopTaskNum=0),
lambda e: e.snapshot.raw["history"].update(loopTask={}),
lambda e: e.snapshot.raw["currentTasks"].append({"id": 52, "typeId": "401", "curStep": 1})):
with self.subTest(change=change):
engine, client = self.engine()
intent = self.intent(engine)
original = engine._journal_commission
def change_before_dispatch(record, incoming):
original(record, incoming)
change(engine)
with patch.object(engine, "_journal_commission", side_effect=change_before_dispatch):
engine._execute_procurement(intent)
self.assertEqual(client.writes, [])
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
def test_active_task_changed_before_dispatch_is_cancelled(self):
self.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
engine, client = self.engine()
intent = self.intent(engine)
original = engine._journal_commission
def replace_task(record, incoming):
original(record, incoming)
engine.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "400", "curStep": 1}]
with patch.object(engine, "_journal_commission", side_effect=replace_task):
engine._execute_procurement(intent)
self.assertEqual(client.writes, [])
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
def test_hard_prerequisite_is_not_misreported_as_preparable(self):
self.tasks["400"]["steps"][0]["condition"] = {"finishTask": ["999"]}
engine, client = self.engine()
row = engine.commission_offer_diagnostics()[0]
self.assertFalse(row["eligible"] or row["preparable"])
self.assertEqual(row["reason_kind"], "prerequisite")
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
self.assertEqual(client.writes, [])
def test_ten_draw_cost_uses_verified_unit_price_without_fictitious_discount(self):
self.tasks["400"]["steps"] = [requirement(count=10)]
price = self.catalog.data["markets"]["sc_city1"]["money"]
self.ranch.daily_buy_money = price * 10
self.raw["master"]["money"] = self.ranch.keep_money + price * 10
engine, _ = self.engine()
buy = self.intent(engine)
self.assertEqual(buy.payload["num"], 10)
engine._run_progression_intent(buy)
self.assertEqual(engine.purchase_budget.spent(engine.snapshot.now), price * 10)
def test_unknown_buy_survives_restart_and_account_isolation(self):
engine, client = self.engine()
client.timeout = True
with self.assertRaises(TimeoutError):
engine._execute_procurement(self.intent(engine))
self.assertEqual(len(client.writes), 1)
restored, second = self.engine()
restored._run_progression_intent()
self.assertEqual(second.writes, [])
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
other = deepcopy(self.raw)
other["master"]["id"] = 2
isolated, _ = self.engine(raw=other)
self.assertIsNone(isolated.battle_journal.pending(isolated.snapshot))
with self.assertRaises(ValueError):
isolated._execute_procurement(self.intent(engine))
def test_mainline_confirmed_unlock_changes_offer_eligibility(self):
self.tasks["100"] = task("100", steps=[step()])
data = config(self.tasks)
data["game_setting"]["cityInfo"]["2"] = {"name": "测试城", "openTask": "100"}
planner = ProgressionPlanner(self.catalog, data)
raw = deepcopy(self.raw)
raw["history"]["unlockCity"]["2"] = False
raw["currentTasks"] = [{"id": 11, "typeId": "100", "curStep": 2}]
raw["monsters"] = [monster(self.catalog, 901)]
snap = Snapshot(raw)
before = planner.commission_offers(snap, self.quest, self.ranch)[0]
self.assertEqual(before["reason_kind"], "city_locked")
self.assertIn("测试城", before["reason"])
finish = planner.plan(snap, ProgressionPolicy(enabled=True), self.ranch)[0]
planner.acknowledge(snap, finish, {"reward": {}})
self.assertTrue(planner.commission_offers(snap, self.quest, self.ranch)[0]["eligible"])
def test_material_shortage_uses_real_supported_sweep_source(self):
self.tasks["400"]["steps"] = [requirement("getItem", 3, "30054")]
data = config(self.tasks, farming={"items": {"30054": [{"stage_id": "0101", "difficulty": 1}]}})
self.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
planner = ProgressionPlanner(self.catalog, data)
actions = planner.commission_plan(Snapshot(self.raw), self.quest, self.ranch)
self.assertEqual(actions[0].kind, "sweep")
self.assertEqual(actions[0].source_task_type_id, "400")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,194 @@
"""Offline coverage-tool regressions against the packaged original task data."""
from copy import deepcopy
import io
import json
from pathlib import Path
import tempfile
import threading
import time
import sys
import unittest
from unittest.mock import patch
from ranch_assistant.game_data import load_progression_data
from tools import check_progression_support as support
class ProgressionSupportTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = load_progression_data()
cls.cases = support.collect_cases(cls.data)
cls.priority = next(case for case in cls.cases if case.task == "1002013")
def test_every_mainline_and_commission_battle_step_is_resolved(self):
expected = {(str(key), number, step["statusType"])
for key, task in self.data.tasks.items() if task.get("type") in (1, 4)
for number, step in enumerate(task.get("steps") or (), 1)
if step.get("statusType") in ("battle", "passStage")}
self.assertEqual({(case.task, case.step, case.step_type) for case in self.cases}, expected)
self.assertEqual(len(self.cases), len(expected))
self.assertEqual({(case.task_type, case.step_type) for case in self.cases},
{(1, "battle"), (1, "passStage"), (4, "battle"), (4, "passStage")})
self.assertTrue(all(isinstance(case.battle, dict) and case.battle for case in self.cases))
def test_priority_task_uses_original_0216_level_one_configuration(self):
self.assertEqual((self.priority.task_type, self.priority.step, self.priority.step_type), (1, 1, "passStage"))
step = self.data.task("1002013")["steps"][0]
self.assertEqual(step["statusValue"], {"stage": "0216", "level": "1"})
self.assertEqual(self.priority.battle, self.data.stage_battle("0216", "1"))
self.assertEqual(self.priority.battle, self.data.task_battle("1002013", 1))
features = support.mechanics(self.priority.battle)
for reason in ("trigger:monDead", "trigger_effect:unlockWave", "unit_controller:monMaker",
"unit_controller:monSteps", "unit_controller:skill"):
self.assertGreater(features[reason], 0)
def test_structural_hotspots_count_configurations_separately_from_occurrences(self):
report = support.source_scan(self.cases)
self.assertEqual(report["count"], len(self.cases))
self.assertEqual(sum(row["count"] for row in report["counts"]), len(self.cases))
affected = {row["reason"]: row["count"] for row in report["mechanics"]}
occurrences = {row["reason"]: row["count"] for row in report["occurrences"]}
self.assertGreater(affected["unit_controller:hpArea"], 0)
self.assertGreater(occurrences["unit_controller:hpArea"], affected["unit_controller:hpArea"])
# Source mechanics are descriptive; they cannot themselves deny quick input.
self.assertNotIn("support", report)
def test_fixture_and_requests_preserve_original_source_and_roster(self):
roster = support.fixture_roster()
before = deepcopy((roster, self.priority.battle))
request = support.make_request(self.priority, roster)
self.assertEqual(request["context"], "task_pass_stage")
self.assertEqual(request["battle_position"], {"battleType": "task", "taskTypeId": "1002013", "taskStep": 0})
self.assertEqual(request["damage_profile"], "client_v4_x10")
self.assertEqual(support.make_request(self.priority, roster, damage_profile="original_1x")["damage_profile"],
"original_1x")
self.assertEqual(request["trace_limit"], 0)
self.assertIs(request["original_data"]["battle"], self.priority.battle)
self.assertEqual(roster["monsters"][0]["level"], 20)
self.assertEqual((roster, self.priority.battle), before)
def test_bounded_case_selection_includes_actual_protection_and_commission(self):
cases = support.representative_cases(self.cases, support.MAX_RUNS)
self.assertEqual(cases[0], self.priority)
self.assertEqual(len(cases), len({(case.task, case.step) for case in cases}))
self.assertTrue(any("objective:protectTarget" in support.mechanics(case.battle) for case in cases))
self.assertTrue(any(case.task_type == 4 and case.step_type == "battle" for case in cases))
self.assertTrue(any(case.task_type == 4 and case.step_type == "passStage" for case in cases))
self.assertEqual(support.representative_cases(self.cases, 0), [])
with self.assertRaises(ValueError):
support.representative_cases(self.cases, support.MAX_RUNS + 1)
def test_snapshot_loader_drops_identity_envelope_and_sanitizes_failures(self):
raw = support.fixture_roster()
raw.update(token="private-token-canary", account="private-account-canary")
raw["master"].update(id=987654321, nickname="private-nickname-canary")
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "private-path-canary.json"
path.write_text(json.dumps({"raw": raw}), encoding="utf-8")
loaded = support.load_snapshot(path)
self.assertEqual(loaded, support.fixture_roster())
path.write_text('{"token":"private-token-canary",broken', encoding="utf-8")
with self.assertRaisesRegex(ValueError, "^snapshot_load_failed$"):
support.load_snapshot(path)
with self.assertRaisesRegex(ValueError, "^snapshot_load_failed$"):
support.load_snapshot(path.with_suffix(".missing"))
def test_reports_keep_anomaly_counts_separate_from_input_support(self):
private = "private-result-canary"
raw = {"supported": True, "outcome": "loss", "elapsed_ms": 420,
"reasons": [], "units": [{"id": private}], "battle_data": {"monsterIds": [private]},
"anomalies": [{"code": "+15overpoten", "monsterId": private}] * 4,
"token": private, "events": [{"message": private}]}
result = support.result_summary(raw)
self.assertTrue(result["support"])
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["counts"], [{"reason": "anomaly:+15overpoten", "count": 4}])
self.assertNotIn(private, json.dumps(result))
raw.update(supported=False, reasons=[private], outcome=private)
raw["anomalies"] = [{"code": private}]
result = support.result_summary(raw)
self.assertNotIn(private, json.dumps(result))
self.assertEqual(result["reason"], ["input_or_model_failure"])
self.assertEqual(result["outcome"], "error")
def test_inspection_cancellation_and_deadline_do_not_run_the_model(self):
runtime = unittest.mock.Mock()
stop = threading.Event()
stop.set()
cancelled = support.inspect_inputs(self.cases, runtime, cancel_event=stop)
self.assertEqual(cancelled["reason"], ["cancelled"])
expired = support.inspect_inputs(self.cases, runtime, deadline=time.monotonic() - 1)
self.assertEqual(expired["reason"], ["budget_exhausted"])
runtime.inspect.assert_not_called()
runtime.run.assert_not_called()
def test_private_model_output_and_exceptions_are_not_logged(self):
private = "private-runtime-canary"
runtime = unittest.mock.Mock()
def run(request, **kwargs):
print(private)
print(private, file=sys.stderr)
raise ValueError(private)
runtime.run.side_effect = run
stdout, stderr = io.StringIO(), io.StringIO()
with patch.object(sys, "stdout", stdout), patch.object(sys, "stderr", stderr):
rows = support.replay_cases([self.priority], runtime, support.fixture_roster())
self.assertEqual((stdout.getvalue(), stderr.getvalue()), ("", ""))
self.assertNotIn(private, json.dumps(rows))
self.assertEqual(rows[0]["outcome"], "error")
self.assertEqual(rows[0]["reason"], ["model_execution_failed"])
def test_replay_uses_web_profile_and_wire_step_without_changing_a_loss(self):
runtime = unittest.mock.Mock()
runtime.run.return_value = {"supported": True, "outcome": "loss", "elapsed_ms": 1000,
"reasons": [], "anomalies": []}
rows = support.replay_cases([self.priority], runtime, support.fixture_roster())
self.assertEqual(rows[0]["outcome"], "loss")
request = runtime.run.call_args.args[0]
self.assertEqual(request["damage_profile"], "client_v4_x10")
self.assertEqual(request["battle_position"]["taskStep"], 0)
self.assertLessEqual(runtime.run.call_args.kwargs["timeout"], 1)
def test_structure_only_cli_never_imports_or_runs_a_model(self):
stdout = io.StringIO()
with patch.object(support, "collect_cases", return_value=self.cases), \
patch.object(sys, "stdout", stdout), \
patch.object(support.importlib, "import_module", side_effect=AssertionError("model import")):
self.assertEqual(support.main(["--structure-only"]), 0)
report = json.loads(stdout.getvalue())
self.assertEqual(report["source"]["count"], len(self.cases))
self.assertLessEqual(len(report["source"]["mechanics"]), support.TOP)
def test_quick_input_counts_follow_current_model_over_the_original_corpus(self):
from ranch_assistant import battle_simulator
runtime = support.quick_runtime()
with patch.object(battle_simulator, "simulate", side_effect=AssertionError("detailed model")):
report = support.inspect_inputs(self.cases, runtime)
self.assertEqual(report["reason"], [])
self.assertEqual(report["count"], len(self.cases))
self.assertEqual(sum(row["count"] for row in report["counts"]), len(self.cases))
self.assertTrue(report["priority"][0]["support"])
# Numeric inputs can remain unsupported. Never freeze an all-supported total.
blocked = [row for row in report["rows"] if not row["support"]]
self.assertTrue(all(row["reason"] for row in blocked))
self.assertEqual(len(blocked), sum(row["count"] for row in report["counts"] if not row["support"]))
def test_original_priority_and_protection_cases_have_fast_natural_results(self):
from ranch_assistant import battle_simulator
protection = next(case for case in self.cases if case.task == "1002002" and case.step == 2)
roster = support.fixture_roster()
before = deepcopy((roster, self.priority.battle, protection.battle))
with patch.object(battle_simulator, "simulate", side_effect=AssertionError("detailed model")):
rows = support.replay_cases([self.priority, protection], support.quick_runtime(), roster)
self.assertEqual([row["outcome"] for row in rows], ["loss", "win"])
self.assertTrue(all(row["support"] for row in rows))
self.assertTrue(all(0 < row["wall_ms"] < 1000 for row in rows))
self.assertTrue(all(row["elapsed_ms"] > 0 for row in rows))
self.assertEqual((roster, self.priority.battle, protection.battle), before)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,73 @@
"""Offline cultivation-bound checks using public tables and synthetic monsters."""
from copy import deepcopy
from types import SimpleNamespace
import unittest
from ranch_assistant.battle_simulator import _snapshot_anomalies, combat_tables
class SnapshotPotentialAnomalyTests(unittest.TestCase):
def snapshot(self, *, species=5208010, **changes):
tables = combat_tables()
row = tables["monster_info"][str(species)]
mon = {"id": 100001, "typeId": species, "level": 1, "potentialLevel": 3,
"tpLevel": 0, "feel": 0, "upStar": 0,
"pAtk": 0, "pDef": 0, "pHp": 0, "pDex": 0}
mon.update(changes)
unit = SimpleNamespace(key="player-1", species=species,
stats=SimpleNamespace(atk=row["atk"], defense=row["def"],
hp=row["hp"], dex=row["dex"]))
return mon, unit, tables
def test_cultivated_potential_at_zero_tp_is_valid(self):
# PotentialPanel.as:102,245: job=1, star=5, potentialLevel=3
# permits atk=64, def=58, hp=510, dex=22, independently of tpLevel.
mon, unit, tables = self.snapshot(pAtk=38, pDef=44, pHp=300, pDex=22)
before = deepcopy((mon, unit))
self.assertEqual(_snapshot_anomalies(mon, unit, tables), [])
self.assertEqual((mon, unit), before)
def test_all_four_excesses_keep_blocking_records(self):
# Preserve the existing strict > 1.5 * cultivation-cap check.
mon, unit, tables = self.snapshot(pAtk=97, pDef=88, pHp=766, pDex=34)
before = deepcopy((mon, unit))
records = _snapshot_anomalies(mon, unit, tables)
self.assertEqual([r["code"] for r in records], ["+15overpoten"] * 4)
self.assertEqual({r["stat"]: (r["value"], r["source_maximum"]) for r in records},
{"atk": (97, 96), "def": (88, 87),
"hp": (766, 765), "dex": (34, 33)})
self.assertTrue(all(r["source_cheat_points"] == 30 for r in records))
self.assertEqual((mon, unit), before)
def test_tp_and_display_star_cannot_hide_uncultivated_excess(self):
for tp in (0, 4, 8):
with self.subTest(tp=tp):
mon, unit, tables = self.snapshot(potentialLevel=1, tpLevel=tp,
upStar=2, pAtk=19)
records = _snapshot_anomalies(mon, unit, tables)
self.assertEqual(len(records), 1)
self.assertEqual(records[0]["code"], "+15overpoten")
self.assertEqual(records[0]["source_maximum"], 18)
def test_existing_tolerance_boundary_is_preserved(self):
mon, unit, tables = self.snapshot(pAtk=96, pDef=87, pHp=765, pDex=33)
self.assertEqual(_snapshot_anomalies(mon, unit, tables), [])
mon["pDex"] = 33.25
records = _snapshot_anomalies(mon, unit, tables)
self.assertEqual(len(records), 1)
self.assertEqual(records[0]["value"], 33.25)
def test_other_source_anomalies_and_temporary_id_exemption_remain(self):
mon, unit, tables = self.snapshot(level=31, feel=201, pAtk=1000000)
unit.stats.atk = 1000000
before = deepcopy((mon, unit))
records = _snapshot_anomalies(mon, unit, tables)
self.assertEqual({r["code"] for r in records},
{"+15overfeel", "+15overgrow", "+15overpoten", "+50overlv"})
self.assertEqual((mon, unit), before)
mon["id"] = 99998
self.assertEqual(_snapshot_anomalies(mon, unit, tables), [])
if __name__ == "__main__":
unittest.main()