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