489 lines
28 KiB
Python
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()
|