fix: recover interrupted Web battles in 2.0.10
This commit is contained in:
@@ -0,0 +1,139 @@
|
||||
"""Offline presentation regressions: input support never predicts a victory."""
|
||||
from copy import deepcopy
|
||||
import unittest
|
||||
from unittest.mock import Mock, 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 ProgressionPolicy
|
||||
from ranch_web.policies import default_config
|
||||
from ranch_web.views import build_view
|
||||
|
||||
|
||||
class BattleCapabilityPresentationTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.runtime = Mock()
|
||||
self.runtime.inspect.return_value = {"supported": True, "settlement_eligible": True,
|
||||
"faithful": True, "approximate": False}
|
||||
self.runtime.run.side_effect = AssertionError("presentation must not simulate")
|
||||
self.client = Mock()
|
||||
self.client.call.side_effect = AssertionError("offline: no game calls")
|
||||
self.client.snapshot.side_effect = AssertionError("offline: no snapshot requests")
|
||||
self.step = {"statusType": "passStage", "statusValue": {"stage": "0216", "level": "1"},
|
||||
"position": "city1_wild_stage0216_level1", "story": "before", "afterStory": "after"}
|
||||
self.data = ProgressionData({"task_info": {"1002013": {"type": 1, "name": "offline mainline",
|
||||
"steps": [self.step]}}, "scripts": {"before": {"supported": True}, "after": {"supported": True}},
|
||||
"game_setting": {"cityInfo": {"1": {"name": "offline city"}}},
|
||||
"stage_info": {"0216": {"city": 1, "cost": {"ti": 6},
|
||||
"level": {"1": {"cost": 0, "battle": {"fixture": True}}}}}})
|
||||
self.engine = Engine(Catalog(), self.client, game_data=self.data, battle_runtime=self.runtime)
|
||||
self.engine.progression_policy = ProgressionPolicy(enabled=True)
|
||||
self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
|
||||
self.engine.snapshot = Snapshot({"master": {"id": 1, "level": 20, "ti": 100, "money": 1000},
|
||||
"currentTasks": [{"id": 11, "typeId": "1002013", "curStep": 1, "stepValue": 0}],
|
||||
"monsters": [{"id": 101, "typeId": 1001010, "mode": 2, "process": 3, "level": 20}],
|
||||
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
|
||||
"items": [], "stacks": [], "rooms": [],
|
||||
"history": {"unlockCity": {"1": True}, "unlockStage": {"0216": [1]}}})
|
||||
self.addCleanup(self.assert_read_only)
|
||||
|
||||
def assert_read_only(self):
|
||||
self.client.call.assert_not_called()
|
||||
self.client.snapshot.assert_not_called()
|
||||
self.runtime.run.assert_not_called()
|
||||
|
||||
def refresh(self):
|
||||
self.engine._refresh_progression_cache(force=True)
|
||||
self.assertEqual(self.engine._progression_error, "")
|
||||
return next(row for row in self.engine.progression_rows() if row["task_type_id"] == "1002013")
|
||||
|
||||
def mainline_view(self):
|
||||
# Rendering consumes prepared DTOs; it must never inspect or plan.
|
||||
with patch.object(self.engine, "_battle_capability", side_effect=AssertionError("view inspection")), \
|
||||
patch.object(self.engine, "_refresh_progression_cache", side_effect=AssertionError("view planning")):
|
||||
return build_view(self.engine, "mainline", default_config())
|
||||
|
||||
def test_navigation_and_before_story_reuse_positive_preflight_without_a_false_block(self):
|
||||
row = self.refresh()
|
||||
self.assertEqual(self.engine._progression_intents[0].kind, "progression_navigate")
|
||||
self.assertTrue(row["supported"])
|
||||
self.assertEqual((row["block_reason"], row["blocked_reason"], row["reason_kind"]), ("", "", "ready"))
|
||||
self.assertIn("前往任务位置", row["next_action"])
|
||||
self.refresh()
|
||||
self.runtime.inspect.assert_called_once()
|
||||
self.assertEqual(self.mainline_view()["rows"][0]["support"], "已支持")
|
||||
_, account = self.engine.progression_planner._account(self.engine.snapshot)
|
||||
account["position"] = self.step["position"]
|
||||
row = self.refresh()
|
||||
action = self.engine._progression_intents[0]
|
||||
self.assertEqual((action.kind, action.phase), ("progression_dialogue", "before"))
|
||||
self.assertIs(row["supported"], True)
|
||||
self.assertEqual(row["blocked_reason"], "")
|
||||
self.runtime.inspect.assert_called_once()
|
||||
|
||||
def test_disabled_mainline_is_neutral_without_execution_intents(self):
|
||||
self.engine.progression_policy.enabled = False
|
||||
row = self.refresh()
|
||||
self.assertEqual(self.engine._progression_intents, [])
|
||||
self.assertIsNone(row["supported"])
|
||||
self.assertEqual((row["blocked_reason"], row["reason_kind"]), ("", "unchecked"))
|
||||
self.assertEqual(row["status"], "自动主线策略未启用")
|
||||
self.assertIn("前往任务位置", row["next_action"])
|
||||
view = self.mainline_view()
|
||||
self.assertEqual(view["rows"][0]["support"], "支持状态未确认")
|
||||
self.assertNotIn("模型尚未支持", str(view))
|
||||
self.engine.progression_policy.enabled = True
|
||||
self.assertIs(self.refresh()["supported"], True)
|
||||
self.runtime.inspect.assert_called_once()
|
||||
|
||||
def test_real_unsupported_inputs_keep_their_reason_even_while_paused(self):
|
||||
reason = "Unsupported monster controller: fixture"
|
||||
self.runtime.inspect.return_value.update(supported=False, reasons=[reason])
|
||||
for enabled in (True, False):
|
||||
with self.subTest(enabled=enabled):
|
||||
self.engine.progression_policy.enabled = enabled
|
||||
row = self.refresh()
|
||||
self.assertIs(row["supported"], False)
|
||||
self.assertEqual((row["blocked_reason"], row["reason_kind"]), (reason, "model_unsupported"))
|
||||
self.runtime.inspect.assert_called_once()
|
||||
|
||||
def test_resource_policy_and_unchecked_rows_keep_truthful_reasons_without_inspections(self):
|
||||
for field, invalid, word in (("teams", [], "队"), ("ti", 0, "体力")):
|
||||
with self.subTest(field=field):
|
||||
target = self.engine.snapshot.raw if field == "teams" else self.engine.snapshot.raw["master"]
|
||||
original = target[field]
|
||||
target[field] = invalid
|
||||
row = self.refresh()
|
||||
self.assertIs(row["supported"], False)
|
||||
self.assertIn(word, row["blocked_reason"])
|
||||
self.assertNotEqual(row["reason_kind"], "model_unsupported")
|
||||
target[field] = original
|
||||
source = [{"task_type_id": str(i), "battle_kind": "passStage", "supported": supported,
|
||||
"block_reason": reason} for i, (supported, reason) in enumerate((
|
||||
(False, ""), (True, "自动对话未启用"), (False, "前置任务尚未完成")))]
|
||||
rows, _ = self.engine._overlay_battle_capabilities(deepcopy(source), [])
|
||||
self.assertTrue(all(row["supported"] is False for row in rows))
|
||||
self.assertEqual([row["blocked_reason"] for row in rows], [row["block_reason"] for row in source])
|
||||
rows = [{"task_type_id": str(i), "state": state, "category": "mainline", "battle_kind": "passStage",
|
||||
"supported": state == "received"} for i, state in enumerate(["finished", "locked", "received"] * 400)]
|
||||
rows, _ = self.engine._overlay_battle_capabilities(rows, [])
|
||||
self.assertTrue(all(row["block_reason"] == "" and row["reason_kind"] != "model_unsupported" for row in rows))
|
||||
self.assertTrue(all(row["supported"] is None and row["reason_kind"] == "unchecked"
|
||||
for row in rows if row["state"] == "received"))
|
||||
self.runtime.inspect.assert_not_called()
|
||||
|
||||
def test_inspect_support_does_not_relabel_a_recorded_loss_as_unsupported_or_win(self):
|
||||
row = self.refresh()
|
||||
self.assertIs(row["supported"], True)
|
||||
self.engine._progression_records = [{"task_type_id": "1002013", "task_id": 11,
|
||||
"battle_kind": "passStage", "battle_mode": "experimental", "outcome": "loss"}]
|
||||
before = deepcopy(self.engine._progression_records)
|
||||
view = build_view(self.engine, "battles", default_config())
|
||||
self.assertEqual(view["rows"][0]["outcome"], "loss")
|
||||
self.assertIn("打不过", view["rows"][0]["outcome_label"])
|
||||
self.assertEqual(self.engine._progression_records, before)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,492 @@
|
||||
"""Interrupted combat recovery; all server calls and worker results are offline fakes."""
|
||||
from copy import deepcopy
|
||||
import json
|
||||
import threading
|
||||
import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from ranch_assistant.battles import BattleJournal, BattleOrchestrator
|
||||
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime, fixture, intent, policy
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
|
||||
|
||||
class BattleRecoveryTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.folder = self.enterContext(workspace_temp())
|
||||
self.path = self.folder / "journal.json"
|
||||
self.catalog, self.snapshot = fixture()
|
||||
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "1002013", "curStep": 1}]
|
||||
self.runtime = ExperimentalRuntime()
|
||||
self.client = Mock()
|
||||
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": False, "reward": {}}
|
||||
self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime)
|
||||
self.action = intent(kind="stage_battle", source_task_id=51, source_task_type_id="1002013", source_step_number=1)
|
||||
self.policy = policy(battle_mode="experimental")
|
||||
|
||||
def paths(self):
|
||||
return [call.args[0] for call in self.client.call.call_args_list]
|
||||
|
||||
def restart(self):
|
||||
self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime)
|
||||
|
||||
def test_generation_cancel_inside_worker_retries_saved_combat_without_second_entry(self):
|
||||
cancel = threading.Event()
|
||||
original = self.runtime._run
|
||||
captured = []
|
||||
def interrupted(request, *, cancel_event):
|
||||
captured.append(deepcopy(request))
|
||||
cancel_event.set()
|
||||
return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled",
|
||||
"faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"}
|
||||
self.runtime.run.side_effect = interrupted
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertEqual(self.runner.recovery_status(record)["state"], "retry_local_runtime")
|
||||
self.snapshot.raw["monsters"][0]["level"] = 999
|
||||
retried = []
|
||||
def complete(request, *, cancel_event):
|
||||
retried.append(deepcopy(request))
|
||||
return original(request, cancel_event=cancel_event)
|
||||
self.runtime.run.side_effect = complete
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(retried[0], record["combat_request"])
|
||||
self.assertNotIn("level", retried[0]["roster"]["monsters"][0])
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
self.assertIsNone(self.runner.pending(self.snapshot))
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(len(self.paths()), 3)
|
||||
|
||||
def test_cancel_at_completed_result_preserves_it_without_resimulation(self):
|
||||
cancel = threading.Event()
|
||||
def complete(request, *, cancel_event):
|
||||
result = self.runtime._run(request, cancel_event=cancel_event)
|
||||
cancel_event.set()
|
||||
return result
|
||||
self.runtime.run.side_effect = complete
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel)
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertTrue(record["battle_data"]["win"])
|
||||
self.assertTrue(self.runner.resumable_task_clock(record))
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.runtime.run.call_count, 1)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
|
||||
def test_cancel_during_wait_resumes_saved_stage_battle_without_new_worker(self):
|
||||
self.runner.clock = lambda: 0
|
||||
cancel = threading.Event()
|
||||
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
|
||||
self.runtime.run.side_effect = lambda request, cancel_event: self.runtime._run(request, cancel_event=cancel_event) | {
|
||||
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel)
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result")
|
||||
self.runner.journal.update(record, record["phase"], battle_ready_at=1)
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.runtime.run.call_count, 1)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
|
||||
def test_save_combat_request_normalizes_comma_lineup_without_losing_slots_or_inputs(self):
|
||||
from ranch_assistant.battle_quick import simulate_quick
|
||||
from ranch_assistant.tests.test_battle_simulator import monster, request
|
||||
for members in ([100001, 0, 100002], "100001,0,100002"):
|
||||
with self.subTest(members=members):
|
||||
combat = request(players=[monster(mid=100001), monster(mid=100002)], master_level=62,
|
||||
battle_mode="experimental")
|
||||
combat["roster"]["teams"][0]["monsters"] = members
|
||||
combat["roster"]["master"]["sessionKey"] = "credential-canary"
|
||||
combat["roster"]["monsters"][0]["nicName"] = "nickname-canary"
|
||||
combat["roster"]["monsters"][0]["token"] = "credential-canary"
|
||||
before = deepcopy(combat)
|
||||
saved = self.runner.save_combat_request({}, combat)["combat_request"]
|
||||
self.assertEqual(saved["roster"]["teams"][0]["monsters"], [100001, 0, 100002])
|
||||
self.assertEqual([row["id"] for row in saved["roster"]["monsters"]], [100001, 100002])
|
||||
normalized = deepcopy(before)
|
||||
normalized["roster"]["teams"][0]["monsters"] = [100001, 0, 100002]
|
||||
self.assertEqual(simulate_quick(saved), simulate_quick(normalized))
|
||||
self.assertNotIn("canary", json.dumps(saved))
|
||||
self.assertEqual(combat, before)
|
||||
|
||||
def test_combat_input_is_durable_before_start_and_original_profile_survives_timeout(self):
|
||||
self.runner.request_builder = lambda snapshot, action, chosen, request: request | {"damage_profile": "client_v4_x10"}
|
||||
original = self.client.call.side_effect
|
||||
def call(path, payload):
|
||||
if path.endswith("stageStart"):
|
||||
pending = BattleJournal(self.path).pending(self.snapshot)
|
||||
self.assertEqual(pending["combat_request"]["damage_profile"], "client_v4_x10")
|
||||
self.assertFalse(pending["settlement_dispatched"])
|
||||
return original(path, payload)
|
||||
self.client.call.side_effect = call
|
||||
self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental",
|
||||
"execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit",
|
||||
"faithful": False, "approximate": True, "damage_profile": None}
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy)
|
||||
self.restart()
|
||||
self.assertEqual(self.runner.pending(self.snapshot)["combat_request"]["damage_profile"], "client_v4_x10")
|
||||
self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "retry_local_runtime")
|
||||
|
||||
def test_settlement_lost_reply_is_never_replayed_even_with_saved_inputs(self):
|
||||
def call(path, payload):
|
||||
if path.endswith("battleEnd"):
|
||||
raise TimeoutError()
|
||||
return {"resCode": 0, "triggerEvent": False}
|
||||
self.client.call.side_effect = call
|
||||
with self.assertRaises(TimeoutError):
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy)
|
||||
self.restart()
|
||||
self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "blocked")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"])
|
||||
|
||||
def test_cancel_before_settlement_dispatch_remains_resumable(self):
|
||||
cancel = threading.Event()
|
||||
update = self.runner.journal.update
|
||||
def stop(record, phase, **fields):
|
||||
update(record, phase, **fields)
|
||||
if phase == "settlement_pending":
|
||||
cancel.set()
|
||||
self.runner.journal.update = stop
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel)
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertFalse(record["settlement_dispatched"])
|
||||
self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
|
||||
def test_preaccept_retry_requires_current_offer_day_and_never_reopens_entry(self):
|
||||
self.action.update(source_task_id=0, source_task_type_id="4001004", source_step_number=0)
|
||||
self.snapshot.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.snapshot.now)
|
||||
self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental",
|
||||
"execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit",
|
||||
"faithful": False, "approximate": True}
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy)
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "retry_local_runtime")
|
||||
self.snapshot.raw["history"]["loopTaskTime"] -= 86400
|
||||
self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "abandon_stage")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.runtime.run.call_count, 1)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"])
|
||||
self.assertEqual(self.client.call.call_args.args[1]["result"], 0)
|
||||
|
||||
def test_local_retry_is_bounded_then_uses_failure_exit_without_another_worker(self):
|
||||
self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental",
|
||||
"execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit",
|
||||
"faithful": False, "approximate": True}
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy)
|
||||
self.restart()
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.restart()
|
||||
self.assertEqual(self.runner.pending(self.snapshot)["runtime_recovery_attempts"], 1)
|
||||
self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "abandon_stage")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.runtime.run.call_count, 2)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"])
|
||||
|
||||
def test_stage_battle_with_confirmed_settlement_restart_only_finishes_record(self):
|
||||
with patch.object(self.runner, "_record", side_effect=SystemExit("crash after durable settlement reply")):
|
||||
with self.assertRaises(SystemExit):
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy)
|
||||
self.restart()
|
||||
self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "resume_result")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.runtime.run.call_count, 1)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
|
||||
def test_stop_during_recovery_settlement_keeps_ack_and_resumes_only_optional_record(self):
|
||||
initial_cancel = threading.Event()
|
||||
def complete(request, *, cancel_event):
|
||||
result = self.runtime._run(request, cancel_event=cancel_event)
|
||||
cancel_event.set()
|
||||
return result
|
||||
self.runtime.run.side_effect = complete
|
||||
self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=initial_cancel)
|
||||
self.restart()
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
||||
recovery_cancel = threading.Event()
|
||||
def settlement_ack_after_stop(path, payload):
|
||||
if path == "battleService/battleEnd":
|
||||
recovery_cancel.set()
|
||||
return {"resCode": 0, "reward": {"money": 11}}
|
||||
self.client.call.side_effect = settlement_ack_after_stop
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel)
|
||||
self.assertTrue(recovery_cancel.is_set())
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"])
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertEqual(record["phase"], "settlement_acknowledged")
|
||||
self.assertTrue(record["settlement_confirmed"])
|
||||
self.assertFalse(record["record_dispatched"])
|
||||
self.assertIsNot(record.get("record_confirmed"), True)
|
||||
self.assertEqual(record["response"], {"resCode": 0, "reward": {"money": 11}})
|
||||
self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel)
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"])
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
self.assertIsNone(self.runner.pending(self.snapshot))
|
||||
self.assertEqual(self.runtime.run.call_count, 1)
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(len(self.paths()), 3)
|
||||
|
||||
def legacy_timeout(self, **changes):
|
||||
record = self.runner.journal.begin(self.snapshot, self.action)
|
||||
self.runner.journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart",
|
||||
start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False},
|
||||
battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False,
|
||||
terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对")
|
||||
self.runner.journal.update(record, "unknown", **changes)
|
||||
return record
|
||||
|
||||
def test_legacy_worker_timeout_uses_original_failure_exit_once(self):
|
||||
self.legacy_timeout()
|
||||
before = deepcopy(self.snapshot.raw)
|
||||
self.restart()
|
||||
status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot)
|
||||
self.assertEqual(status["state"], "abandon_stage")
|
||||
self.assertIn("原始战斗输入", status["message"])
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["battleService/recordBattleResult"])
|
||||
self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0101", "cityId": "1", "result": 0})
|
||||
self.assertIsNone(self.runner.pending(self.snapshot))
|
||||
done = self.runner.journal.records(self.snapshot)[0]
|
||||
self.assertEqual(done["outcome"], "abandoned")
|
||||
self.assertTrue(done["record_confirmed"])
|
||||
self.assertNotIn("battle_data", done)
|
||||
self.assertEqual(self.snapshot.raw, before)
|
||||
self.runtime.run.assert_not_called()
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(len(self.paths()), 1)
|
||||
|
||||
def test_lost_failure_response_stays_pending_and_is_never_replayed(self):
|
||||
self.legacy_timeout()
|
||||
self.client.call.side_effect = TimeoutError("lost failure acknowledgement")
|
||||
with self.assertRaises(TimeoutError):
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.restart()
|
||||
record = self.runner.pending(self.snapshot)
|
||||
self.assertEqual(record["phase"], "record_unknown")
|
||||
self.assertTrue(record["record_dispatched"])
|
||||
self.assertEqual(self.runner.recovery_status(record)["state"], "blocked")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["battleService/recordBattleResult"])
|
||||
|
||||
def test_real_preaccept_source_zero_legacy_timeout_exits_without_task_or_offer(self):
|
||||
self.action.update(stage_id="0102", task_type_id="", source_task_id=0,
|
||||
source_task_type_id="4001004", source_step_number=0, stage_category=None)
|
||||
self.legacy_timeout()
|
||||
before = deepcopy(self.snapshot.raw)
|
||||
self.restart()
|
||||
status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot.raw)
|
||||
self.assertEqual(status["state"], "abandon_stage")
|
||||
self.assertIn("旧记录缺少原始战斗输入", status["message"])
|
||||
self.assertNotIn("来源委托已变化", status["message"])
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertEqual(self.paths(), ["battleService/recordBattleResult"])
|
||||
self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0102", "cityId": "1", "result": 0})
|
||||
self.assertIsNone(self.runner.pending(self.snapshot))
|
||||
self.assertEqual(self.snapshot.raw, before)
|
||||
self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0)
|
||||
self.assertEqual(self.runner.journal.records(self.snapshot)[0]["outcome"], "abandoned")
|
||||
|
||||
def test_failure_acknowledged_before_crash_finishes_locally_without_second_record(self):
|
||||
self.legacy_timeout()
|
||||
finish = self.runner.journal.finish
|
||||
self.runner.journal.finish = Mock(side_effect=SystemExit("crash after durable failure reply"))
|
||||
with self.assertRaises(SystemExit):
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.runner.journal.finish = finish
|
||||
self.restart()
|
||||
self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "finish_abandonment")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.assertIsNone(self.runner.pending(self.snapshot))
|
||||
self.assertEqual(self.paths(), ["battleService/recordBattleResult"])
|
||||
|
||||
def test_unconfirmed_start_or_changed_source_or_settlement_attempt_blocks_failure_exit(self):
|
||||
self.legacy_timeout()
|
||||
for changes in ({"start_response": None}, {"settlement_dispatched": True},
|
||||
{"path": "battleService/battleEnd"}, {"source_task_id": 999},
|
||||
{"terminal_reason": "unclassified_failure"}):
|
||||
with self.subTest(changes=changes):
|
||||
original = deepcopy(self.runner.pending(self.snapshot))
|
||||
self.runner.journal.update(self.runner.pending(self.snapshot), "unknown", **changes)
|
||||
status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot)
|
||||
self.assertEqual(status["state"], "blocked")
|
||||
self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event())
|
||||
self.runner.journal.role(self.snapshot)["records"][-1] = original
|
||||
self.runner.journal.save()
|
||||
self.assertIsNotNone(self.runner.pending(self.snapshot))
|
||||
self.client.call.assert_not_called()
|
||||
self.runtime.run.assert_not_called()
|
||||
|
||||
|
||||
class EngineBattleRecoveryTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
from ranch_assistant.engine import Engine, demo_snapshot
|
||||
from ranch_assistant.game_data import ProgressionData
|
||||
from ranch_assistant.model import Catalog, Policy, Snapshot
|
||||
from ranch_assistant.progression import ProgressionPolicy
|
||||
self.folder = self.enterContext(workspace_temp())
|
||||
self.catalog = Catalog()
|
||||
self.raw = deepcopy(demo_snapshot(self.catalog).raw)
|
||||
self.raw["currentTasks"] = [{"id": 71, "typeId": "1002013", "curStep": 1}]
|
||||
self.client = Mock()
|
||||
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw))
|
||||
self.client.call.return_value = {"resCode": 0, "triggerEvent": False}
|
||||
self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json",
|
||||
game_data=ProgressionData({"task_info": {}, "stage_info": {}, "game_setting": {}}),
|
||||
experimental_runtime=ExperimentalRuntime())
|
||||
self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
|
||||
self.engine.progression_policy = ProgressionPolicy(enabled=True, battle_mode="experimental")
|
||||
self.engine.snapshot = Snapshot(deepcopy(self.raw))
|
||||
self.engine.master_sync.settle = Mock()
|
||||
self.action = intent(kind="stage_battle", stage_id="0102", task_type_id="", source_task_id=0,
|
||||
source_task_type_id="4001004", source_step_number=0)
|
||||
self.record = self.engine.battle_journal.begin(self.engine.snapshot, self.action)
|
||||
self.engine.battle_journal.update(self.record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart",
|
||||
start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False},
|
||||
battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False,
|
||||
terminal_reason="worker_wall_clock_limit")
|
||||
self.engine.auto = False
|
||||
|
||||
def test_disabled_cold_commission_origin_blocks_until_quest_policy_is_enabled(self):
|
||||
self.engine.game_data = None
|
||||
self.engine.quest_policy.enabled = False
|
||||
self.engine.daily_policy.enabled = True
|
||||
before = self.engine.battle_journal.path.read_bytes()
|
||||
record = deepcopy(self.record)
|
||||
status = self.engine.pending_battle_recovery()
|
||||
self.assertEqual(status["state"], "blocked_policy")
|
||||
self.assertFalse(status["resumable"])
|
||||
self.assertIn("等待启用自动委托来源策略", status["message"])
|
||||
self.assertEqual(self.engine.battle_journal.path.read_bytes(), before)
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record)
|
||||
self.client.call.assert_not_called()
|
||||
self.assertFalse(self.engine.quest_policy.enabled)
|
||||
self.assertTrue(self.engine.daily_policy.enabled)
|
||||
self.engine.quest_policy.enabled = True
|
||||
self.assertTrue(self.engine.pending_battle_recovery()["resumable"])
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
self.assertEqual(self.client.call.call_args.args[0], "battleService/recordBattleResult")
|
||||
|
||||
def test_enabled_cold_commission_origin_does_not_require_mainline_policy(self):
|
||||
self.engine.game_data = None
|
||||
self.engine.progression_policy.enabled = False
|
||||
self.engine.quest_policy.enabled = True
|
||||
status = self.engine.pending_battle_recovery()
|
||||
self.assertEqual(status["state"], "abandon_stage")
|
||||
self.assertTrue(status["resumable"])
|
||||
self.assertIsNotNone(self.engine.game_data)
|
||||
self.assertTrue(self.engine._is_commission(self.record))
|
||||
self.assertFalse(self.engine.progression_policy.enabled)
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_disabled_map_and_mainline_origins_name_their_policies(self):
|
||||
self.engine.progression_policy.enabled = False
|
||||
self.engine.sweep_policy.enabled = False
|
||||
for kind, source_id, source_type, source_step, label in (
|
||||
("map_battle", 0, "", 0, "自动扫荡"),
|
||||
("stage_battle", 71, "1002013", 1, "自动主线")):
|
||||
with self.subTest(kind=kind):
|
||||
self.engine.game_data = None
|
||||
self.engine.battle_journal.update(self.record, "waiting_for_battle_clock", kind=kind,
|
||||
source_task_id=source_id, source_task_type_id=source_type, source_step_number=source_step,
|
||||
battle_data={"win": True}, execution_status="completed", terminal=True,
|
||||
experimental_settlement_eligible=True, approximate=True, faithful=False, resume_clock_ready=True)
|
||||
self.assertTrue(self.engine.battles.recovery_status(self.record, snapshot=self.engine.snapshot)["resumable"])
|
||||
status = self.engine.pending_battle_recovery()
|
||||
self.assertEqual(status["state"], "blocked_policy")
|
||||
self.assertFalse(status["resumable"])
|
||||
self.assertIn("等待启用" + label + "来源策略", status["message"])
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_web_explicit_running_resumes_preaccept_failure_while_auto_stays_false(self):
|
||||
self.engine.cancel_progression()
|
||||
self.engine.poll(resume_pending=False)
|
||||
self.client.call.assert_not_called()
|
||||
self.assertTrue(self.engine.pending_battle_recovery()["resumable"])
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertFalse(self.engine.auto)
|
||||
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
self.assertEqual(self.client.call.call_args.args, ("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0}))
|
||||
self.assertEqual(self.engine.snapshot.raw["currentTasks"], self.raw["currentTasks"])
|
||||
self.assertFalse(self.engine._progression_pending())
|
||||
self.engine._require_no_battle() # Other selected strategies are no longer blocked.
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
|
||||
def test_new_stop_during_snapshot_read_wins_over_old_running_argument(self):
|
||||
read = self.client.snapshot.side_effect
|
||||
def read_then_stop():
|
||||
result = read()
|
||||
self.engine.cancel_progression()
|
||||
return result
|
||||
self.client.snapshot.side_effect = read_then_stop
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertTrue(self.engine._progression_cancel.is_set())
|
||||
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
self.client.call.assert_not_called()
|
||||
self.client.snapshot.side_effect = read
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
|
||||
def test_guard_is_read_only_and_unknown_settlement_is_blocked(self):
|
||||
self.engine.battle_journal.update(self.record, "unknown", path="battleService/battleEnd", settlement_dispatched=True)
|
||||
before = self.engine.battle_journal.path.read_bytes()
|
||||
status = self.engine.pending_battle_recovery()
|
||||
self.assertEqual(status["state"], "blocked")
|
||||
self.assertFalse(status["resumable"])
|
||||
self.assertEqual(self.engine.battle_journal.path.read_bytes(), before)
|
||||
record = deepcopy(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record)
|
||||
self.client.call.assert_not_called()
|
||||
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
|
||||
def test_engine_generation_cancel_in_worker_resumes_single_started_entry(self):
|
||||
from ranch_assistant.model import Snapshot
|
||||
from ranch_assistant.progression import ProgressionIntent
|
||||
self.engine.battle_journal.finish(self.engine.snapshot, self.record, "cancelled")
|
||||
self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900]}]
|
||||
self.raw["history"]["unlockStage"] = {"0102": [1]}
|
||||
self.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.engine.snapshot.now)
|
||||
self.engine.snapshot = Snapshot(deepcopy(self.raw))
|
||||
self.engine.battles.catalog = fixture()[0]
|
||||
self.engine.game_data.stages["0102"] = {"level": {"1": {"battle": {"fixture": True}}}}
|
||||
self.engine._battle_catalog_ready = True
|
||||
self.engine._ensure_progression()
|
||||
scope, _ = self.engine.progression_planner._account(self.engine.snapshot)
|
||||
action = ProgressionIntent(kind="stage_battle", description="offline preaccept farming", stage_id="0102",
|
||||
difficulty=1, battle_kind="ordinary_stage", path="stageService/stageStart", team="teamA",
|
||||
battle_mode="experimental", account_key=scope, token="offline-fixture", source_task_type_id="4001004")
|
||||
self.engine.progression_planner._issued[action.token] = action.to_dict()
|
||||
self.engine._select_battle_runtime("experimental")
|
||||
runtime = self.engine.battles.runtime
|
||||
def interrupted(request, *, cancel_event):
|
||||
self.engine.cancel_progression()
|
||||
return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled",
|
||||
"faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"}
|
||||
runtime.run.side_effect = interrupted
|
||||
self.engine.battles.run(self.client, self.engine.snapshot, action,
|
||||
self.engine.progression_policy, cancel=self.engine._progression_cancel)
|
||||
self.assertEqual(self.engine._progression_cancel_generation, 1)
|
||||
self.assertEqual(self.engine.pending_battle_recovery()["state"], "retry_local_runtime")
|
||||
runtime.run.side_effect = runtime._run
|
||||
self.engine.poll(resume_pending=True)
|
||||
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
||||
self.assertEqual([call.args[0] for call in self.client.call.call_args_list],
|
||||
["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
||||
self.assertEqual(runtime.run.call_count, 2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,146 @@
|
||||
"""Bounded, offline regressions for the fixed battle worker's stdin transport."""
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from ranch_assistant import battle_simulator as simulator
|
||||
from ranch_assistant.battle_quick import simulate_quick
|
||||
from ranch_assistant.tests.test_battle_simulator import request
|
||||
|
||||
|
||||
# Delay the real worker's first read past several parent polling quanta.
|
||||
SLOW_WORKER = """
|
||||
import runpy, sys, time
|
||||
time.sleep(.2)
|
||||
sys.argv = ['ranch_assistant.battle_simulator', '--worker']
|
||||
runpy.run_module('ranch_assistant.battle_simulator', run_name='__main__')
|
||||
"""
|
||||
|
||||
|
||||
class PartialFirstWrite:
|
||||
"""Reproduce POSIX's partial-write/None-retry behavior on every platform.
|
||||
|
||||
The child and its pipes are real. A tiny first write followed by a timeout
|
||||
leaves stdin open; a retry without input never resumes that write. No
|
||||
background writer is needed, so killed children cannot leave writer threads.
|
||||
"""
|
||||
|
||||
def __init__(self, process):
|
||||
self.process = process
|
||||
self.partial_write = False
|
||||
self.timeouts = 0
|
||||
|
||||
def __getattr__(self, name):
|
||||
return getattr(self.process, name)
|
||||
|
||||
def communicate(self, input=None, timeout=None):
|
||||
if self.process.stdin is not None and self.process.poll() is None:
|
||||
if input is not None:
|
||||
self.process.stdin.write(input[:512])
|
||||
self.process.stdin.flush()
|
||||
self.partial_write = True
|
||||
try:
|
||||
self.process.wait(timeout=timeout)
|
||||
except subprocess.TimeoutExpired:
|
||||
self.timeouts += 1
|
||||
raise
|
||||
try:
|
||||
return self.process.communicate(input=input, timeout=timeout)
|
||||
except subprocess.TimeoutExpired:
|
||||
self.timeouts += 1
|
||||
raise
|
||||
|
||||
|
||||
class BattleWorkerTransportTests(unittest.TestCase):
|
||||
def large_request(self):
|
||||
payload = request()
|
||||
# A valid snapshot field retained by the combat-only serializer.
|
||||
payload['roster']['monsters'][0]['nicName'] = 'x' * (128 * 1024)
|
||||
return payload
|
||||
|
||||
def launch_slow_worker(self, *, partial=False, cancel_event=None):
|
||||
real_popen = subprocess.Popen
|
||||
launched = []
|
||||
streams = []
|
||||
|
||||
def launch(command, **kwargs):
|
||||
self.assertEqual(command, [sys.executable, '-m',
|
||||
'ranch_assistant.battle_simulator', '--worker'])
|
||||
self.assertNotIn('shell', kwargs)
|
||||
stream = kwargs['stdin']
|
||||
if stream != subprocess.PIPE:
|
||||
streams.append(stream)
|
||||
wire = stream.read()
|
||||
self.assertGreater(len(wire), 128 * 1024)
|
||||
self.assertLessEqual(len(wire), simulator.MAX_WIRE_BYTES)
|
||||
self.assertNotIn(b'account-secret', wire)
|
||||
self.assertEqual(json.loads(wire)['request']['roster']['monsters'][0]['nicName'],
|
||||
'x' * (128 * 1024))
|
||||
stream.seek(0)
|
||||
process = real_popen([sys.executable, '-c', SLOW_WORKER], **kwargs)
|
||||
observed = PartialFirstWrite(process) if partial else process
|
||||
launched.append(observed)
|
||||
if cancel_event is not None:
|
||||
cancel_event.set()
|
||||
return observed
|
||||
|
||||
return launch, launched, streams
|
||||
|
||||
def assert_cleaned_up(self, processes, streams):
|
||||
self.assertEqual(len(processes), 1)
|
||||
self.assertIsNotNone(processes[0].poll())
|
||||
self.assertTrue(processes[0].stdout.closed)
|
||||
self.assertTrue(processes[0].stderr.closed)
|
||||
for stream in streams:
|
||||
self.assertTrue(stream.closed)
|
||||
|
||||
def test_partial_first_quantum_delivers_one_complete_request(self):
|
||||
payload = self.large_request()
|
||||
expected = simulate_quick(payload)
|
||||
self.assertIn(expected['outcome'], ('win', 'loss'))
|
||||
launch, processes, streams = self.launch_slow_worker(partial=True)
|
||||
with patch.object(simulator.subprocess, 'Popen', side_effect=launch):
|
||||
actual = simulator.ExperimentalBattleRuntime().run(payload, timeout=1.5)
|
||||
self.assert_cleaned_up(processes, streams)
|
||||
self.assertGreaterEqual(processes[0].timeouts, 2)
|
||||
self.assertEqual(actual, expected)
|
||||
|
||||
def test_native_slow_reader_preserves_result_and_omits_credentials(self):
|
||||
payload = self.large_request()
|
||||
expected = simulate_quick(payload)
|
||||
payload['credentials'] = 'account-secret'
|
||||
payload['roster']['master']['token'] = 'account-secret'
|
||||
launch, processes, streams = self.launch_slow_worker()
|
||||
with patch.object(simulator.subprocess, 'Popen', side_effect=launch):
|
||||
actual = simulator.ExperimentalBattleRuntime().run(payload, timeout=1.5)
|
||||
self.assert_cleaned_up(processes, streams)
|
||||
self.assertEqual(actual, expected)
|
||||
|
||||
def test_cancel_and_deadline_reap_slow_reader_and_close_input(self):
|
||||
for cancelled in (False, True):
|
||||
with self.subTest(cancelled=cancelled):
|
||||
event = threading.Event()
|
||||
launch, processes, streams = self.launch_slow_worker(
|
||||
cancel_event=event if cancelled else None)
|
||||
with patch.object(simulator.subprocess, 'Popen', side_effect=launch):
|
||||
result = simulator.ExperimentalBattleRuntime().run(
|
||||
self.large_request(), cancel_event=event,
|
||||
timeout=1.5 if cancelled else .1)
|
||||
self.assertEqual(result['outcome'], 'cancelled' if cancelled else 'timeout')
|
||||
self.assertFalse(result['terminal'])
|
||||
self.assertIsNone(result['battle_data'])
|
||||
self.assert_cleaned_up(processes, streams)
|
||||
|
||||
def test_oversize_input_never_launches_worker(self):
|
||||
with patch.object(simulator, 'MAX_WIRE_BYTES', 1024), \
|
||||
patch.object(simulator.subprocess, 'Popen') as launch:
|
||||
result = simulator.ExperimentalBattleRuntime().run(self.large_request())
|
||||
launch.assert_not_called()
|
||||
self.assertEqual(result['terminal_reason'], 'request_exceeds_worker_input_limit')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user