Files

489 lines
28 KiB
Python

from contextlib import ExitStack
from copy import deepcopy
from dataclasses import asdict, replace
import hashlib
import json
import os
from pathlib import Path
import struct
import sys
import threading
import time
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import zipfile
import zlib
from ranch_assistant.battle_runtime import (
BattleRequest, BattleRuntime, ORIGINAL_APK_SHA256, ORIGINAL_MAIN_SHA256, original_fixture_request,
)
from ranch_assistant.tests.test_core import workspace_temp
from tools.battle_runtime.isolation import ProcessResult, run_isolated
from tools.battle_runtime.swf_library import encode_tag, library_only, symbols, tags
from tools.battle_runtime.trusted import verify_files
from tools.battle_runtime.inputs import ADD_FIELDS, MON_FIELDS, validate
from tools.battle_runtime.prepare import asset_index, write_atomic
class RuntimeContractTests(unittest.TestCase):
def setUp(self):
self.stack = ExitStack()
self.addCleanup(self.stack.close)
self.root = Path(self.stack.enter_context(workspace_temp()))
(self.root / "fixture_1.9.68.apk").write_bytes(b"Not an engine; contract tests never execute this")
self.stack.enter_context(patch("ranch_assistant.battle_runtime.ROOT", self.root))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.LOCAL", self.root / "runtime"))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.os", SimpleNamespace(name="nt")))
self.stack.enter_context(patch("tools.battle_runtime.trusted.verify_files", return_value=[]))
self.request = original_fixture_request()
def inspect(self, **changes):
return BattleRuntime().inspect(replace(self.request, **changes))
def codes(self, capability):
return {row["code"] for row in capability["reasons"]}
def test_native_fixture_support_never_grants_settlement_or_fidelity(self):
capability = self.inspect()
self.assertTrue(capability["supported"])
self.assertFalse(capability["faithful"])
self.assertFalse(capability["settlement_eligible"])
self.assertEqual(capability["coverage"]["validated_skills"], [3])
def test_default_purpose_refuses_before_starting_any_process(self):
request = BattleRequest("ordinary_stage", self.request.original_data, self.request.roster, stage_id="0101")
with patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime().run(request)
execute.assert_not_called()
self.assertEqual(result["status"], "unsupported")
self.assertIn("settlement_not_validated", self.codes(result["capability"]))
self.assertNotIn("outcome", result)
self.assertNotIn("offline_result", result)
def test_dict_contract_matches_dataclass_and_input_is_unchanged(self):
request = asdict(self.request)
before = json.loads(json.dumps(request))
self.assertEqual(BattleRuntime().inspect(request), BattleRuntime().inspect(self.request))
self.assertEqual(request, before)
def test_unknown_context_and_unhashable_context_refuse(self):
for context in ("boss", "pve", ["ordinary_stage"], None):
with self.subTest(context=context):
self.assertIn("unknown_context", self.codes(self.inspect(context=context)))
def test_task_routes_cannot_reuse_the_ordinary_stage_proof(self):
for context in ("task_battle", "task_pass_stage"):
capability = self.inspect(context=context, task_id="1001004", step_index=0)
self.assertFalse(capability["supported"])
self.assertIn("task_route_not_validated", self.codes(capability))
def test_other_stages_and_difficulties_refuse(self):
for changes in ({"stage_id":"0102"}, {"difficulty":2}, {"difficulty":True}, {"difficulty":"1"}):
self.assertIn("scene_not_validated", self.codes(self.inspect(**changes)))
def test_task_fields_are_rejected_even_with_ordinary_context(self):
self.assertIn("task_input_not_validated", self.codes(self.inspect(step_index=0)))
def test_unknown_roster_skills_equipment_and_estimates_refuse(self):
for roster in ({"hp":100,"atk":100}, {**self.request.roster,"skills":[9999]},
{**self.request.roster,"equipment":[123]}):
self.assertIn("roster_not_validated", self.codes(self.inspect(roster=roster)))
def test_unverified_original_tables_cannot_enable_unknown_mechanics(self):
data = {**self.request.original_data, "battle":{"controller":[{"type":"unimplemented"}]}}
self.assertIn("external_battle_data_unvalidated", self.codes(self.inspect(original_data=data)))
def test_claimed_original_identity_must_match_both_pins(self):
identity = {**self.request.original_data["resource_identity"], "main_swf_sha256":"0" * 64}
self.assertIn("resource_identity_mismatch", self.codes(self.inspect(original_data={
"source":"original_apk", "resource_identity":identity})))
def test_imported_commands_paths_and_unsigned_verified_manifests_never_execute(self):
for config in ({"command":["cmd","/c","anything"]}, {"executable":"evil.exe"},
{"backend":"original_air","verified":True,"supports":["*"]},
{"backend":"original_air","resource_root":"somewhere"}):
with self.subTest(config=config), patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime(config).run(self.request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("untrusted_runtime_config", self.codes(result["capability"]))
execute.assert_not_called()
def test_foreign_backend_refuses(self):
result = BattleRuntime({"backend":"basic_estimate"}).inspect(self.request)
self.assertIn("unknown_backend", self.codes(result))
def test_unsigned_result_in_request_is_not_an_engine_result(self):
request = {**asdict(self.request), "result":{"win":True}, "verified":True}
result = BattleRuntime().run(request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("unknown_request_fields", self.codes(result["capability"]))
def test_malformed_nonfinite_and_oversize_inputs_refuse(self):
for request in (None, [], {}, {**asdict(self.request),"roster":{"hp":float("nan")}},
{**asdict(self.request),"roster":{"payload":"x" * (4 * 1024 * 1024)}}):
self.assertFalse(BattleRuntime().inspect(request)["supported"])
def test_cancellation_before_run_does_not_inspect_or_launch(self):
event = threading.Event(); event.set()
runtime = BattleRuntime()
with patch.object(runtime,"inspect") as inspect:
result = runtime.run(self.request,cancel_event=event)
inspect.assert_not_called()
self.assertEqual(result["status"], "cancelled")
def test_timeout_must_be_finite_and_positive(self):
for value in (0, -1, True, float("nan"), float("inf"), "5"):
with self.subTest(value=value), self.assertRaises(ValueError):
BattleRuntime().run(self.request, timeout=value)
def fake_worker(self, mutate):
def execute(argv, **kwargs):
output = Path(argv[argv.index("--output")+1])
nonce = argv[argv.index("--nonce")+1]
payload = {"schema":1,"nonce":nonce,"evidence":{
"resource_identity":{"apk_sha256":ORIGINAL_APK_SHA256,"main_swf_sha256":ORIGINAL_MAIN_SHA256},
"resource_audit":{"all_present_assets_match_apk":True},"process_exit_code":0,
"result":{"status":"scene_completed","battle_executed":True,"settlement_eligible":False,
"scene_result":{"outcome":"win","battle_data":{"win":True,"cheatNum":0,"battlePosition":{
"battleType":"stage","stageLevel":"1","stageId":"0101","taskTypeId":None,"taskStep":0}},
"anomaly_records":{"text":"real anomaly","damages":[{"damage":999}]}}}}}
mutate(payload)
output.write_text(json.dumps(payload),encoding="utf-8")
return ProcessResult("completed",0,.1,"","")
return execute
def test_result_protocol_rejects_wrong_nonce_identity_claim_or_missing_execution(self):
mutations = [lambda p:p.update(nonce="wrong"),
lambda p:p["evidence"]["resource_identity"].update(apk_sha256="0" * 64),
lambda p:p["evidence"]["resource_identity"].update(main_swf_sha256="0" * 64),
lambda p:p["evidence"]["result"].update(settlement_eligible=True),
lambda p:p["evidence"]["result"].update(faithful=True),
lambda p:p["evidence"]["result"].update(battle_executed=False),
lambda p:p["evidence"]["resource_audit"].update(all_present_assets_match_apk=False),
lambda p:p["evidence"]["result"]["scene_result"].update(outcome="invented")]
for mutation in mutations:
with self.subTest(mutation=mutation), patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(mutation)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"], "error")
self.assertNotIn("outcome",result)
self.assertFalse(result["settlement_eligible"])
def test_original_anomaly_records_survive_protocol_without_filtering(self):
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(lambda p:None)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
self.assertEqual(result["offline_result"]["anomaly_records"]["damages"],[{"damage":999}])
self.assertFalse(result["faithful"])
def test_positive_original_anomaly_count_preserves_completed_result(self):
def anomaly(payload):
payload["evidence"]["result"]["scene_result"]["battle_data"]["cheatNum"] = 4
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(anomaly)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"anomaly")
self.assertTrue(result["battle_completed"])
self.assertFalse(result["checks_passed"])
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
def test_natural_native_time_limit_is_completed_loss_not_watchdog_timeout(self):
def expiry(payload):
scene = payload["evidence"]["result"]["scene_result"]
scene.update(outcome="loss",terminal_reason="time_limit")
scene["battle_data"].update(win=False,leftTime=0)
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(expiry)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["outcome"],"loss")
self.assertEqual(result["offline_result"]["terminal_reason"],"time_limit")
def test_default_deadline_allows_original_300_second_battle_and_explicit_is_preserved(self):
runtime=BattleRuntime()
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request)
self.assertGreater(execute.call_args.kwargs["timeout"],600)
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request,timeout=10)
self.assertGreater(execute.call_args.kwargs["timeout"],8)
self.assertLessEqual(execute.call_args.kwargs["timeout"],10)
def test_timed_out_worker_does_not_yield_a_battle_result(self):
with patch("tools.battle_runtime.isolation.run_isolated",return_value=ProcessResult("timeout",1,.1,"","")):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"timeout")
self.assertNotIn("outcome",result)
self.assertNotIn("offline_result",result)
class OriginalInputTests(unittest.TestCase):
"""Data-only preflight tests; no APK, AIR, account, or network is required."""
def setUp(self):
self.battle={"time":300,"groundType":1,"teams":[],"controller":[],"triggers":[],
"battleField":{"mapAreas":[],"mapObjects":[]}}
self.tables={"stage_info":{"0101":{"level":{"1":{"battle":self.battle}}}},
"task_info":{"original-task":{"steps":[
{"statusType":"battle","battle":self.battle},
{"statusType":"passStage","statusValue":{"stage":"0101","level":1}}]}},
"monster_info":{"1001010":{"skill_1":3,"skill_2":0,"imgFix":{"2":{"x":0,"y":0}}}},
"monster_skill":{"3":{}},"skin_info":{},"upstar_info":{},"item_info":{},
"team_info":{"battleTeam":{"0":{},"1":{}}},
"setting":{"groundType":{"1":{"battleImg":"background.png"}},"groundObject":{}},
"game_setting":{"normalBattleTime":300,"maxFeel":200},
"potential_info":{"potentialLevelMaxAdd":10}}
self.members={self.member(path) for path in ("data/img/bg/background.png","data/img/monster/q/1001010_q_2.png")}
mon=dict.fromkeys(MON_FIELDS,0)
mon.update(id=1000001,typeId=1001010,level=1,mode=2,process=3,potentialLevel=1,nicName="")
self.snapshot={"master":{"id":1,"level":1,"globalAtk":0,"globalDef":0,"globalHp":0,"globalDex":0},
"monsters":[mon],"monsterAttributes":[],"items":[],
"teams":[{"teamName":"teamB","teamType":"battleTeam","monsters":[1000001,0]}],
"history":{**dict.fromkeys(("numAddMoney","numChicken","countBattle"),0),
**{k:[] for k in ("monLib","equipLib","passAchi","guide_record","unlockCity")},
**{k:{} for k in ("numFeedMonsters","numKillMonsters","historyGacha","passTask","unlockTask","loopTask","unlockStage","passStage","payTypeCount","everyDayBuyProductNum")},
"guide_main":""}}
self.request={"context":"ordinary_stage","stage_id":"0101","difficulty":1,
"original_data":{"battle":self.battle},"roster":self.snapshot,"team":"teamB",
"battle_position":{"battleType":"stage","stageId":"0101","stageLevel":"1","taskTypeId":None,"taskStep":0}}
@staticmethod
def member(path):
return "assets/codes/"+hashlib.md5(path.encode()).hexdigest()
def validate(self,request=None):
return validate(self.request if request is None else request,source=(self.tables,self.members))
def codes(self,result):
return {r["code"] for r in result["reasons"]}
def test_raw_roster_contract_preserves_selected_team_b_and_empty_additions(self):
before=deepcopy(self.request);result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["native_request"]["roster"]["team_name"],"teamB")
self.assertEqual(result["native_request"]["roster"]["snapshot"]["monsterAttributes"],[])
self.assertEqual(self.request,before)
def test_wrapper_and_raw_contract_produce_identical_native_input(self):
raw=self.validate()
wrapped=deepcopy(self.request);wrapped.pop("team")
wrapped["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertEqual(self.validate(wrapped)["native_request"],raw["native_request"])
def test_missing_or_conflicting_team_is_never_defaulted(self):
request=deepcopy(self.request);request.pop("team")
self.assertIn("invalid_roster",self.codes(self.validate(request)))
request["team"]="teamA"
self.assertIn("invalid_selected_team",self.codes(self.validate(request)))
request["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertIn("invalid_roster",self.codes(self.validate(request)))
def test_all_three_contexts_keep_original_position(self):
for context,index in (("task_battle",0),("task_pass_stage",1)):
request=deepcopy(self.request);request.update(context=context,stage_id=None,
task_id="account-instance",step_index=index,battle_position={"battleType":"task",
"stageId":None,"stageLevel":None,"taskTypeId":"original-task","taskStep":index})
result=self.validate(request)
self.assertEqual(result["reasons"],[])
self.assertEqual(result["position"],request["battle_position"])
request["battle_position"]["battleType"]="stage"
self.assertIn("battle_position_mismatch",self.codes(self.validate(request)))
def test_mismatched_task_status_step_and_authored_config_refuse(self):
request=deepcopy(self.request);request.update(context="task_battle",stage_id=None,
task_id="original-task",step_index=1,battle_position=None)
self.assertIn("invalid_battle_context",self.codes(self.validate(request)))
request=deepcopy(self.request);request["original_data"]["battle"]["time"]=1
self.assertIn("battle_config_mismatch",self.codes(self.validate(request)))
def test_unknown_original_mechanics_refuse_even_with_canonical_config(self):
for field,value,code in (("controller",[{"type":"unknown"}],"unknown_battle_controller"),
("triggers",[{"type":"time","effects":[{"type":"story"}]}],"unsupported_trigger_effect")):
with self.subTest(field=field):
self.battle[field]=value
self.assertIn(code,self.codes(self.validate()))
self.battle[field]=[]
self.battle["battleField"]["mapAreas"]=[{"type":"block"}]
self.assertIn("unknown_battle_area",self.codes(self.validate()))
def test_missing_assets_and_malformed_arrays_refuse(self):
self.members.remove(self.member("data/img/monster/q/1001010_q_2.png"))
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.battle["teams"]={}
self.assertIn("invalid_battle_array",self.codes(self.validate()))
def test_missing_history_duplicate_slots_and_partial_attributes_refuse(self):
request=deepcopy(self.request);del request["roster"]["history"]["passTask"]
self.assertIn("incomplete_battle_history",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["teams"][0]["monsters"]=[1000001,1000001]
self.assertIn("duplicate_selected_monster",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["monsterAttributes"]=[{"monsterId":1000001,"atk":0}]
self.assertIn("incomplete_monster_additions",self.codes(self.validate(request)))
def test_skin_uses_visual_table_and_original_species_skills(self):
self.tables["skin_info"]["1001011"]={"monType":"1001010"}
self.tables["monster_info"]["1001011"]={"imgFix":{"2":{}},"skill_1":9999}
self.members.add(self.member("data/img/monster/q/1001011_q_2.png"))
self.snapshot["monsters"][0]["skin"]=1001011
result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["coverage"]["skill_ids"],[3])
def test_equipment_requires_original_params_and_its_visible_asset(self):
self.snapshot["monsters"][0]["equip1"]=2000001
self.snapshot["items"]=[{"id":2000001,"typeId":50001,"num":1,"isUsed":1,
"itemClass":3,"equipParams":json.dumps(dict.fromkeys(ADD_FIELDS,0))}]
self.tables["item_info"]["50001"]={"position":{"position":1,"img":True}}
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.members.add(self.member("data/img/item/item_50001_o.png"))
self.assertEqual(self.validate()["reasons"],[])
self.snapshot["items"][0]["equipParams"]='{}'
self.assertIn("incomplete_equipment",self.codes(self.validate()))
def test_public_dataclass_retains_canonical_raw_roster_fields(self):
request=BattleRequest(**self.request)
self.assertEqual(asdict(request)["team"],"teamB")
self.assertEqual(asdict(request)["battle_position"],self.request["battle_position"])
def test_public_inspector_routes_engine_raw_roster_to_snapshot_validation(self):
with patch("tools.battle_runtime.inputs.original_source",return_value=(self.tables,self.members)), \
patch("tools.battle_runtime.trusted.verify_files",return_value=[]), \
patch("ranch_assistant.battle_runtime.os",SimpleNamespace(name="nt")):
result=BattleRuntime().inspect(self.request)
self.assertTrue(result["supported"],result["reasons"])
self.assertEqual(result["native_position"],self.request["battle_position"])
self.assertEqual(result["watchdog_seconds"],690)
self.assertFalse(result["settlement_eligible"])
self.assertTrue(result["native_admission_validation_pending"])
self.assertTrue(result["faithful"])
self.assertFalse(result["server_acceptance_verified"])
class ArtifactIdentityTests(unittest.TestCase):
def swf(self, payloads):
raw = bytearray(b"FWS\x32\0\0\0\0\0\0\x1e\x01\0")
for code,payload in payloads:
raw.extend(encode_tag(code,payload))
raw.extend(encode_tag(0,b""));struct.pack_into("<I",raw,4,len(raw))
return bytes(raw)
def test_library_copy_cannot_invoke_original_document_and_preserves_abc(self):
abc = b"opaque original ABC byte identity fixture"
bindings = struct.pack("<H",2)+struct.pack("<H",0)+b"GameStartup\0"+struct.pack("<H",42)+b"BattleAnimation\0"
raw = self.swf([(76,bindings),(82,struct.pack("<I",0)+b"main\0"+abc)])
converted,identity = library_only(raw)
output = dict(tags(converted))
self.assertEqual(symbols(output[76]),[(42,b"BattleAnimation")])
self.assertEqual(output[82][output[82].index(0,4)+1:],abc)
self.assertEqual(struct.unpack_from("<I",output[82])[0],1)
self.assertEqual(identity["removed_document_classes"],["GameStartup"])
self.assertEqual(identity["abc_sha256"],[hashlib.sha256(abc).hexdigest()])
def test_compressed_swf_has_same_library_code(self):
raw = self.swf([(82,struct.pack("<I",1)+b"main\0abc")])
compressed = b"CWS"+raw[3:8]+zlib.compress(raw[8:])
self.assertEqual(library_only(raw)[0],library_only(compressed)[0])
def test_executable_or_import_tags_and_truncation_refuse(self):
for tag in (12,59,72,57,71):
with self.subTest(tag=tag),self.assertRaises(ValueError):
library_only(self.swf([(tag,b"not allowed")]))
with self.assertRaises(ValueError):library_only(self.swf([])[:-1])
def test_digest_validation_ignores_a_local_manifest_claiming_verification(self):
with workspace_temp() as directory:
root=Path(directory); (root/"runner.exe").write_bytes(b"replaced code")
(root/"identity.json").write_text(json.dumps({"verified":True,"files":{"runner.exe":hashlib.sha256(b"replaced code").hexdigest()}}))
reasons=verify_files(root,{"runner.exe":hashlib.sha256(b"reviewed code").hexdigest()})
self.assertEqual(reasons,[{"code":"dependency_digest_mismatch","detail":"runner.exe"}])
def test_identical_preparation_does_not_replace_a_resource_open_by_another_job(self):
with workspace_temp() as directory:
path=Path(directory)/"resource";path.write_bytes(b"verified immutable bytes")
with patch.object(Path,"replace",side_effect=PermissionError("shared reader")) as replace_file:
write_atomic(path,b"verified immutable bytes")
replace_file.assert_not_called()
self.assertEqual(path.read_bytes(),b"verified immutable bytes")
def test_zip_index_ranges_decode_exact_original_stored_and_deflated_bytes(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
originals={"a"*32:b"packed original bytes"*50,"b"*32:bytes(range(256))}
with zipfile.ZipFile(path,"w") as archive:
for index,(key,data) in enumerate(originals.items()):
archive.writestr("assets/codes/"+key,data,compress_type=zipfile.ZIP_DEFLATED if index else zipfile.ZIP_STORED)
with zipfile.ZipFile(path) as archive:
entries=asset_index(path,archive)
with path.open("rb") as stream:
for key,entry in entries.items():
stream.seek(entry["offset"]);packed=stream.read(entry["compressed_size"])
data=zlib.decompress(packed,-15) if entry["method"]==8 else packed
self.assertEqual(data,originals[key])
self.assertEqual(len(data),entry["size"])
self.assertEqual(zlib.crc32(data),entry["crc32"])
def test_zip_index_refuses_mismatched_local_header_and_unsafe_keys(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/"+"a"*32,b"data")
with path.open("r+b") as stream:stream.seek(8);stream.write(struct.pack("<H",8))
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"metadata"):
asset_index(path,archive)
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/../../escape",b"data")
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"Unsupported"):
asset_index(path,archive)
class ProcessIsolationTests(unittest.TestCase):
def test_child_executes_in_its_own_directory_and_nonzero_exit_is_error(self):
with workspace_temp() as directory:
root=Path(directory)
result=run_isolated([sys.executable,"-I","-c","from pathlib import Path; print(Path.cwd().name)"],cwd=root,timeout=5)
self.assertEqual(result.status,"completed",result.stderr)
self.assertEqual(result.stdout.strip(),root.name)
result=run_isolated([sys.executable,"-I","-c","raise SystemExit(7)"],cwd=root,timeout=5)
self.assertEqual(result.status,"error")
self.assertEqual(result.returncode,7)
def test_wall_timeout_terminates_child_promptly(self):
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=.2)
self.assertEqual(result.status,"timeout")
self.assertLess(result.duration_seconds,3)
def test_mid_run_cancellation_terminates_child(self):
event=threading.Event();timer=threading.Timer(.2,event.set);timer.start()
try:
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=5,cancel_event=event)
finally:timer.cancel()
self.assertEqual(result.status,"cancelled")
self.assertLess(result.duration_seconds,3)
def test_pre_cancelled_run_does_not_spawn(self):
event=threading.Event();event.set()
with workspace_temp() as directory,patch("tools.battle_runtime.isolation.subprocess.Popen") as popen:
result=run_isolated([sys.executable,"-I","-c","pass"],cwd=Path(directory),timeout=5,cancel_event=event)
popen.assert_not_called();self.assertEqual(result.status,"cancelled")
@unittest.skipUnless(os.name=="nt","Windows Job Object process-tree check")
def test_timeout_kills_worker_descendant_not_only_parent(self):
import ctypes
from ctypes import wintypes
with workspace_temp() as directory:
root=Path(directory)
script="import subprocess,sys,time; from pathlib import Path; p=subprocess.Popen([sys.executable,'-I','-c','import time; time.sleep(30)']); Path('child.pid').write_text(str(p.pid)); time.sleep(30)"
result=run_isolated([sys.executable,"-I","-c",script],cwd=root,timeout=.6)
self.assertEqual(result.status,"timeout")
self.assertTrue((root/"child.pid").exists())
pid=int((root/"child.pid").read_text())
kernel=ctypes.WinDLL("kernel32",use_last_error=True)
kernel.OpenProcess.argtypes=[wintypes.DWORD,wintypes.BOOL,wintypes.DWORD];kernel.OpenProcess.restype=wintypes.HANDLE
kernel.GetExitCodeProcess.argtypes=[wintypes.HANDLE,ctypes.POINTER(wintypes.DWORD)];kernel.CloseHandle.argtypes=[wintypes.HANDLE]
handle=kernel.OpenProcess(0x1000,False,pid)
if handle:
try:
code=wintypes.DWORD();kernel.GetExitCodeProcess(handle,ctypes.byref(code));self.assertNotEqual(code.value,259)
finally:kernel.CloseHandle(handle)
if __name__=="__main__":unittest.main()