fix(web): finalize quick battle and commission procurement for 2.0.9
This commit is contained in:
@@ -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()
|
||||
Reference in New Issue
Block a user