field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

test_fixture_tool_dispatch.py (15494B)


      1 """Actual native mock tools, argument fidelity and bounded compiler ownership."""
      2 
      3 from __future__ import annotations
      4 
      5 import json
      6 import os
      7 import shutil
      8 import signal
      9 import subprocess
     10 import sys
     11 import tempfile
     12 import time
     13 import unittest
     14 from pathlib import Path
     15 from unittest.mock import patch
     16 
     17 from scripts.fixture_tool_dispatch import (
     18     CompilerCommand,
     19     FixtureDispatchError,
     20     FixtureToolDispatcher,
     21 )
     22 from scripts.fixture_test_policy import limit
     23 
     24 
     25 class FixtureToolDispatchTests(unittest.TestCase):
     26     def setUp(self) -> None:
     27         evidence = os.environ.get("TERA_C138_TEST_EVIDENCE")
     28         if evidence:
     29             self.root = Path(tempfile.mkdtemp(prefix="tool-dispatch-", dir=evidence))
     30         else:
     31             temporary = tempfile.TemporaryDirectory()
     32             self.addCleanup(temporary.cleanup)
     33             self.root = Path(temporary.name).resolve()
     34         self.tools = self.root / "tools"
     35         self.tools.mkdir()
     36         self.dispatcher = FixtureToolDispatcher(
     37             self.tools, ("uv", "cargo", "install", "xcrun", "xcodebuild", "rg")
     38         )
     39         self.sequence = 0
     40 
     41     def command(
     42         self, argv: list[str], *, cwd: Path | None = None, timeout=None
     43     ) -> subprocess.CompletedProcess:
     44         self.sequence += 1
     45         command = CompilerCommand(
     46             argv,
     47             cwd or self.root,
     48             limit("native_helper") if timeout is None else timeout,
     49             budget="native_helper",
     50         )
     51         try:
     52             return command.execute()
     53         finally:
     54             prefix = self.root / f"command-{self.sequence:02}"
     55             prefix.with_suffix(".json").write_text(json.dumps(command.record, indent=2))
     56             for name, raw in command.output.items():
     57                 Path(str(prefix) + f".{name}").write_bytes(raw)
     58             self.assert_settled(command.record)
     59 
     60     def assert_settled(self, record: dict) -> None:
     61         self.assertTrue(record["wait_reaped"], record)
     62         self.assertTrue(record["group_absent"], record)
     63         self.assertLessEqual(record["elapsed_seconds"], record["timeout"] + 2.5)
     64         with self.assertRaises(ProcessLookupError):
     65             os.kill(record["pid"], 0)
     66         with self.assertRaises(ProcessLookupError):
     67             os.killpg(record["pgid"], 0)
     68 
     69     def body(self, role: str, status: int = 0) -> str:
     70         return (
     71             "import json, os, sys\nfrom pathlib import Path\n"
     72             f"Path({str(self.root / (role + '.json'))!r}).write_text(json.dumps({{"
     73             "'argv': sys.argv, 'file': __file__, 'interpreter': sys.executable, "
     74             "'cwd': os.getcwd(), 'path': os.environ['PATH'], "
     75             "'literal': os.environ.get('FIXTURE_LITERAL'), "
     76             "'stdin_closed': os.read(0, 1) == b'', 'pid': os.getpid(), "
     77             "'pgid': os.getpgrp(), 'sid': os.getsid(0)}))\n"
     78             f"sys.exit({status})\n"
     79         )
     80 
     81     def environment(self) -> dict:
     82         return {"PATH": str(self.tools), "FIXTURE_LITERAL": "space $literal value"}
     83 
     84     def test_first_copies_preserve_actual_body_arguments_and_process_identity(
     85         self,
     86     ) -> None:
     87         arguments = ["", "space argument", "$literal", "-m", "0644", "--quiet", "é"]
     88         bodies = {}
     89         for role, status in (("uv", 0), ("cargo", 7), ("install", 0)):
     90             body = self.body(role, status)
     91             bodies[role] = body
     92             self.dispatcher.executable(role, body)
     93             with patch.dict(os.environ, self.environment(), clear=True):
     94                 result = self.command([str(self.tools / role), *arguments])
     95             self.assertEqual(result.returncode, status, result.stderr)
     96             observed = json.loads((self.root / f"{role}.json").read_text())
     97             record = json.loads(
     98                 (self.root / f"command-{self.sequence:02}.json").read_text()
     99             )
    100             self.assertEqual(
    101                 observed["argv"], [str(self.tools / f"{role}.body.py"), *arguments]
    102             )
    103             self.assertEqual(observed["file"], str(self.tools / f"{role}.body.py"))
    104             self.assertEqual(observed["interpreter"], sys.executable)
    105             self.assertEqual(observed["cwd"], str(self.root))
    106             self.assertEqual(observed["path"], str(self.tools))
    107             self.assertEqual(observed["literal"], self.environment()["FIXTURE_LITERAL"])
    108             self.assertTrue(observed["stdin_closed"])
    109             self.assertEqual(
    110                 (observed["pid"], observed["pgid"], observed["sid"]),
    111                 (record["pid"],) * 3,
    112             )
    113         for role, body in bodies.items():
    114             self.assertEqual(
    115                 (self.tools / f"{role}.body.py").read_bytes(), body.encode()
    116             )
    117         compiler = json.loads(
    118             (self.dispatcher.directory / "compilation.json").read_text()
    119         )
    120         self.assertEqual(compiler["command"]["timeout"], limit("compiler"))
    121         self.assertEqual(compiler["command"]["exit"], 0)
    122         self.assert_settled(compiler["command"])
    123         independent_tools = self.root / "independent-tools"
    124         independent_tools.mkdir()
    125         independent = FixtureToolDispatcher(independent_tools, self.dispatcher.roles)
    126         independent.executable("uv", self.body("independent"))
    127         for field in ("source", "binary"):
    128             self.assertEqual(
    129                 independent.record[field]["sha256"], compiler[field]["sha256"]
    130             )
    131         self.assertNotEqual(
    132             independent.record["command"]["pid"], compiler["command"]["pid"]
    133         )
    134         self.assertNotEqual(
    135             independent.binary.stat().st_ino, self.dispatcher.binary.stat().st_ino
    136         )
    137         self.assert_settled(independent.record["command"])
    138         (self.root / "stable-compilations.json").write_text(
    139             json.dumps([compiler, independent.record], indent=2) + "\n"
    140         )
    141         with patch.dict(os.environ, {"PATH": str(independent_tools)}, clear=True):
    142             result = self.command([str(independent_tools / "uv"), *arguments])
    143         self.assertEqual(result.returncode, 0, result.stderr)
    144         observed = json.loads((self.root / "independent.json").read_text())
    145         self.assertEqual(
    146             observed["argv"], [str(independent_tools / "uv.body.py"), *arguments]
    147         )
    148         record = json.loads(
    149             (self.root / f"command-{self.sequence:02}.json").read_text()
    150         )
    151         self.assertEqual(
    152             (observed["pid"], observed["pgid"], observed["sid"]),
    153             (record["pid"],) * 3,
    154         )
    155         self.assertEqual(observed["interpreter"], sys.executable)
    156         self.assertEqual(observed["cwd"], str(self.root))
    157         self.assertEqual(observed["path"], str(independent_tools))
    158         self.assertTrue(observed["stdin_closed"])
    159 
    160     def test_original_shell_forms_and_copy_permission_remain_independent(self) -> None:
    161         for role in ("xcrun", "uv", "xcodebuild", "rg"):
    162             self.dispatcher.executable(role, self.body(role))
    163         identities = [
    164             (self.tools / role).stat().st_ino
    165             for role in ("xcrun", "uv", "xcodebuild", "rg")
    166         ]
    167         self.assertEqual(len(set(identities)), 4)
    168         self.assertTrue(
    169             all(
    170                 not (self.tools / role).is_symlink()
    171                 for role in ("xcrun", "uv", "xcodebuild", "rg")
    172             )
    173         )
    174         (self.tools / "xcodebuild").chmod(0o600)
    175         (self.tools / "rg").unlink()
    176         for shell, role in (("/bin/sh", "uv"), ("/bin/bash", "xcrun")):
    177             script = self.root / f"{role}.sh"
    178             script.write_text(f"{role} \"space argument\" '$literal'\n")
    179             with patch.dict(os.environ, self.environment(), clear=True):
    180                 result = self.command([shell, str(script)])
    181             self.assertEqual(result.returncode, 0, result.stderr)
    182             self.assertEqual(
    183                 json.loads((self.root / f"{role}.json").read_text())["argv"][1:],
    184                 ["space argument", "$literal"],
    185             )
    186         with patch.dict(os.environ, self.environment(), clear=True):
    187             for role, expected in (("xcodebuild", 126), ("rg", 127)):
    188                 with self.subTest(role=role):
    189                     result = self.command(["/bin/sh", "-c", role])
    190                     self.assertEqual(result.returncode, expected)
    191 
    192     def test_missing_body_unknown_role_and_foreign_path_do_not_execute(self) -> None:
    193         self.dispatcher.executable("uv", self.body("uv"))
    194         (self.tools / "uv.body.py").unlink()
    195         unknown = self.tools / "unknown"
    196         shutil.copyfile(self.dispatcher.binary, unknown)
    197         unknown.chmod(0o700)
    198         with patch.dict(os.environ, self.environment(), clear=True):
    199             self.assertEqual(self.command([str(self.tools / "uv")]).returncode, 66)
    200             self.assertEqual(self.command([str(unknown)]).returncode, 64)
    201         foreign = self.root / "foreign"
    202         foreign.mkdir()
    203         (foreign / "uv.body.py").write_text(self.body("uv"))
    204         with patch.dict(os.environ, {"PATH": str(foreign)}, clear=True):
    205             self.assertEqual(self.command([str(self.tools / "uv")]).returncode, 64)
    206         self.dispatcher.executable("uv", self.body("uv"))
    207         self.dispatcher.executable("cargo", self.body("cargo"))
    208         foreign_image = foreign / "uv"
    209         shutil.copyfile(self.dispatcher.binary, foreign_image)
    210         foreign_image.chmod(0o700)
    211         for image, argv0 in (
    212             (foreign_image, self.tools / "uv"),
    213             (self.tools / "uv", self.tools / "cargo"),
    214         ):
    215             with self.subTest(image=str(image), argv0=str(argv0)):
    216                 script = self.root / f"exec-image-{self.sequence:02}.py"
    217                 intent = script.with_suffix(".json")
    218                 native_argv = [str(argv0), "space $literal"]
    219                 script.write_text(
    220                     "import json, os\nfrom pathlib import Path\n"
    221                     f"Path({str(intent)!r}).write_text(json.dumps({{'image': {str(image)!r}, 'argv': {native_argv!r}, 'pid': os.getpid(), 'pgid': os.getpgrp()}}))\n"
    222                     f"os.execv({str(image)!r}, {native_argv!r})\n"
    223                 )
    224                 with patch.dict(os.environ, self.environment(), clear=True):
    225                     result = self.command([sys.executable, str(script)])
    226                 self.assertEqual(result.returncode, 64, result.stderr)
    227                 observed = json.loads(intent.read_text())
    228                 record = json.loads(
    229                     (self.root / f"command-{self.sequence:02}.json").read_text()
    230                 )
    231                 self.assertEqual(observed["pid"], record["pid"])
    232                 self.assertEqual(observed["pgid"], record["pgid"])
    233         alias = self.root / "tools-alias"
    234         alias.symlink_to(self.tools, target_is_directory=True)
    235         with patch.dict(os.environ, {"PATH": str(alias)}, clear=True):
    236             self.assertEqual(self.command([str(self.tools / "uv")]).returncode, 64)
    237         self.assertFalse((self.root / "uv.json").exists())
    238         self.assertFalse((self.root / "cargo.json").exists())
    239         with self.assertRaises(FixtureDispatchError):
    240             self.dispatcher.executable("unknown", "raise AssertionError\n")
    241 
    242     def test_real_handler_signal_is_the_actual_process_status(self) -> None:
    243         self.dispatcher.executable(
    244             "cargo",
    245             "import json, os, signal\nfrom pathlib import Path\n"
    246             f"Path({str(self.root / 'signal.json')!r}).write_text(json.dumps({{'pid': os.getpid(), 'pgid': os.getpgrp()}}))\n"
    247             "os.kill(os.getpid(), signal.SIGTERM)\n",
    248         )
    249         with patch.dict(os.environ, self.environment(), clear=True):
    250             result = self.command([str(self.tools / "cargo")])
    251         self.assertEqual(result.returncode, -signal.SIGTERM)
    252         observed = json.loads((self.root / "signal.json").read_text())
    253         record = json.loads((self.root / "command-01.json").read_text())
    254         self.assertEqual(observed["pid"], record["pid"])
    255         self.assertEqual(observed["pgid"], record["pgid"])
    256 
    257     def test_compiler_absence_and_nonzero_fail_closed_with_exact_raw_record(
    258         self,
    259     ) -> None:
    260         for case, compiler in (("absent", None), ("nonzero", "/usr/bin/false")):
    261             tools = self.root / case
    262             tools.mkdir()
    263             with (
    264                 self.subTest(case=case),
    265                 patch(
    266                     "scripts.fixture_tool_dispatch.shutil.which", return_value=compiler
    267                 ),
    268             ):
    269                 with self.assertRaises(FixtureDispatchError):
    270                     FixtureToolDispatcher(tools, ("uv",))
    271             directory = tools / ".fixture-dispatch"
    272             record = json.loads((directory / "compilation.json").read_text())
    273             self.assertFalse((directory / "dispatch").exists())
    274             if compiler:
    275                 self.assertEqual(record["command"]["exit"], 1)
    276                 self.assert_settled(record["command"])
    277                 self.assertEqual((directory / "compiler.stdout").read_bytes(), b"")
    278                 self.assertEqual((directory / "compiler.stderr").read_bytes(), b"")
    279 
    280     def test_compiler_timeout_kills_ignoring_descendant_and_prevents_late_write(
    281         self,
    282     ) -> None:
    283         ready, late = self.root / "compiler-child.json", self.root / "late.txt"
    284         script = self.root / "compiler-control.py"
    285         script.write_text(
    286             "import json, os, signal, subprocess, sys, time\nfrom pathlib import Path\n"
    287             "signal.signal(signal.SIGTERM, signal.SIG_IGN)\n"
    288             f"child = subprocess.Popen([sys.executable, '-c', {('import os, signal, time; from pathlib import Path; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1); Path(' + repr(str(late)) + ').write_text("late")')!r}])\n"
    289             f"Path({str(ready)!r}).write_text(json.dumps({{'pid': os.getpid(), 'child': child.pid, 'pgid': os.getpgrp(), 'stdin_closed': os.read(0, 1) == b''}}))\n"
    290             "time.sleep(10)\n"
    291         )
    292         with self.assertRaises(subprocess.TimeoutExpired):
    293             self.command([sys.executable, str(script)], timeout=0.5)
    294         observed = json.loads(ready.read_text())
    295         self.assertTrue(observed["stdin_closed"])
    296         with self.assertRaises(ProcessLookupError):
    297             os.kill(observed["child"], 0)
    298         time.sleep(0.5)
    299         self.assertFalse(late.exists())
    300         record = json.loads((self.root / "command-01.json").read_text())
    301         self.assertIn(signal.SIGKILL, [row["signal"] for row in record["signals"]])
    302 
    303     def test_compiler_overflow_caps_retained_bytes_and_settles(self) -> None:
    304         for name, descriptor in (("stdout", 1), ("stderr", 2)):
    305             with self.subTest(stream=name):
    306                 script = self.root / f"overflow-{name}.py"
    307                 script.write_text(
    308                     f"import os\nos.write({descriptor}, b'x' * (2 * 1024 * 1024))\n"
    309                 )
    310                 with self.assertRaises(FixtureDispatchError):
    311                     self.command([sys.executable, str(script)])
    312                 prefix = self.root / f"command-{self.sequence:02}"
    313                 self.assertEqual(
    314                     len(Path(str(prefix) + f".{name}").read_bytes()),
    315                     CompilerCommand.LIMITS[name],
    316                 )
    317                 self.assertEqual(
    318                     json.loads(prefix.with_suffix(".json").read_text())[
    319                         "output_excess"
    320                     ],
    321                     name,
    322                 )