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_release_evidence.py (27441B)


      1 """Actual release shell branches with synthetic dependency/artifact dispatch."""
      2 
      3 from __future__ import annotations
      4 
      5 import json
      6 import os
      7 import selectors
      8 import shlex
      9 import signal
     10 import shutil
     11 import subprocess
     12 import sys
     13 import tempfile
     14 import time
     15 import unittest
     16 from pathlib import Path
     17 
     18 from scripts.fixture_tool_dispatch import FixtureToolDispatcher
     19 from scripts.fixture_test_policy import limit as fixture_limit, load_policy
     20 
     21 SCRIPTS = Path(__file__).resolve().parent
     22 if str(SCRIPTS) not in sys.path:
     23     sys.path.insert(0, str(SCRIPTS))
     24 
     25 
     26 class ReleaseCommand:
     27     """Bounded capture and cleanup while the unreaped leader reserves its PGID."""
     28 
     29     LIMITS = {"stdout": 1024 * 1024, "stderr": 64 * 1024}
     30 
     31     def __init__(self, argv: list[str], cwd: Path, environment: dict, timeout: float):
     32         if not 0 < timeout <= fixture_limit("release_command"):
     33             raise ValueError("release fixture deadline must be within 30 seconds")
     34         self.argv, self.cwd, self.environment, self.timeout = (
     35             argv,
     36             cwd,
     37             environment,
     38             timeout,
     39         )
     40         self.output = {name: bytearray() for name in self.LIMITS}
     41         self.selector = selectors.DefaultSelector()
     42         self.process = None
     43         self.started = time.monotonic()
     44         self.record = {
     45             "argv": argv,
     46             "cwd": str(cwd),
     47             "timeout": timeout,
     48             "policy_id": load_policy()["id"],
     49             "policy_sha256": load_policy()["source_sha256"],
     50             "started_ns": time.time_ns(),
     51             "signals": [],
     52             "wait_reaped": False,
     53             "group_absent": False,
     54         }
     55 
     56     def execute(self) -> subprocess.CompletedProcess:
     57         try:
     58             self.process = subprocess.Popen(
     59                 self.argv,
     60                 cwd=self.cwd,
     61                 env=self.environment,
     62                 stdin=subprocess.DEVNULL,
     63                 stdout=subprocess.PIPE,
     64                 stderr=subprocess.PIPE,
     65                 bufsize=0,
     66                 start_new_session=True,
     67             )
     68             self.record.update(pid=self.process.pid, pgid=self.process.pid)
     69             for name in self.LIMITS:
     70                 stream = getattr(self.process, name)
     71                 os.set_blocking(stream.fileno(), False)
     72                 self.selector.register(stream, selectors.EVENT_READ, name)
     73             self.capture(self.started + self.timeout)
     74         except BaseException as error:
     75             self.record["error"] = type(error).__name__
     76             raise
     77         finally:
     78             try:
     79                 if self.process is not None:
     80                     self.settle()
     81             finally:
     82                 self.selector.close()
     83                 self.record["elapsed_seconds"] = time.monotonic() - self.started
     84                 self.record["ended_ns"] = time.time_ns()
     85         return subprocess.CompletedProcess(
     86             self.argv,
     87             self.process.returncode,
     88             bytes(self.output["stdout"]),
     89             bytes(self.output["stderr"]),
     90         )
     91 
     92     def exited(self) -> bool:
     93         # WNOWAIT leaves the leader's PID reserved until the last group signal.
     94         state = os.waitid(
     95             os.P_PID, self.process.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT
     96         )
     97         return state is not None and state.si_pid == self.process.pid
     98 
     99     def capture(self, deadline: float) -> None:
    100         while self.selector.get_map() or not self.exited():
    101             remaining = deadline - time.monotonic()
    102             if remaining <= 0:
    103                 raise subprocess.TimeoutExpired(
    104                     self.argv,
    105                     self.timeout,
    106                     output=bytes(self.output["stdout"]),
    107                     stderr=bytes(self.output["stderr"]),
    108                 )
    109             self.read_ready(min(remaining, 0.05), reject_excess=True)
    110 
    111     def read_ready(self, timeout: float, *, reject_excess: bool) -> None:
    112         for key, _ in self.selector.select(timeout):
    113             name = key.data
    114             available = self.LIMITS[name] - len(self.output[name])
    115             size = min(65536, available + 1) if reject_excess else 65536
    116             data = os.read(key.fd, size)
    117             if not data:
    118                 self.selector.unregister(key.fileobj)
    119                 key.fileobj.close()
    120                 continue
    121             self.output[name].extend(data[:available])
    122             if len(data) > available:
    123                 self.record.setdefault("output_excess", name)
    124                 if reject_excess:
    125                     raise RuntimeError(f"release fixture {name} exceeds capture limit")
    126 
    127     def group_present(self) -> bool:
    128         try:
    129             os.killpg(self.process.pid, 0)
    130         except ProcessLookupError:
    131             return False
    132         except PermissionError:
    133             # Darwin can report EPERM for an unreaped, exited group leader.
    134             return True
    135         return True
    136 
    137     def send(self, number: int) -> None:
    138         # No wait/poll/reap is permitted before the final signal: PID reuse is fenced.
    139         try:
    140             os.killpg(self.process.pid, number)
    141         except ProcessLookupError:
    142             return
    143         except PermissionError:
    144             self.record.setdefault("signal_errors", []).append(
    145                 {"signal": number, "errno": 1}
    146             )
    147             if not self.exited():
    148                 raise
    149             return
    150         self.record["signals"].append({"signal": number, "at_ns": time.time_ns()})
    151 
    152     def drain_until(self, deadline: float) -> None:
    153         while self.selector.get_map() and time.monotonic() < deadline:
    154             self.read_ready(
    155                 min(0.01, max(0, deadline - time.monotonic())), reject_excess=False
    156             )
    157 
    158     def finish_cleanup(self, deadline: float) -> None:
    159         self.send(signal.SIGKILL)
    160         self.process.wait(timeout=max(0.001, deadline - time.monotonic()))
    161         self.record.update(wait_reaped=True, exit=self.process.returncode)
    162         self.drain_until(deadline)
    163         while self.group_present() and time.monotonic() < deadline:
    164             time.sleep(0.005)
    165         self.record["group_absent"] = not self.group_present()
    166         if not self.record["group_absent"] or self.selector.get_map():
    167             raise RuntimeError(
    168                 "release fixture cleanup did not settle its group and pipes"
    169             )
    170 
    171     def settle(self) -> None:
    172         deadline = time.monotonic() + fixture_limit("leaf_cleanup")
    173         try:
    174             self.send(signal.SIGTERM)
    175             grace = time.monotonic() + 0.2
    176             self.drain_until(grace)
    177             # Closed pipes do not prove a descendant exited; keep the leader reserved.
    178             while self.group_present() and time.monotonic() < grace:
    179                 time.sleep(0.005)
    180         except BaseException as error:
    181             self.record["cleanup_error"] = type(error).__name__
    182             raise
    183         finally:
    184             try:
    185                 self.finish_cleanup(deadline)
    186             except BaseException as error:
    187                 self.record["cleanup_error"] = type(error).__name__
    188                 raise
    189             finally:
    190                 for name in self.LIMITS:
    191                     getattr(self.process, name).close()
    192 
    193 
    194 class ReleaseFixture(unittest.TestCase):
    195     def setUp(self) -> None:
    196         evidence = os.environ.get("TERA_C138_TEST_EVIDENCE")
    197         if evidence:
    198             self.root = Path(tempfile.mkdtemp(prefix="release-", dir=evidence))
    199         else:
    200             temporary = tempfile.TemporaryDirectory()
    201             self.addCleanup(temporary.cleanup)
    202             self.root = Path(temporary.name).resolve()
    203         self.tools = self.root / "tools"
    204         self.tools.mkdir()
    205         self.dispatcher = FixtureToolDispatcher(
    206             self.tools, ("cargo", "uv", "install", "rg")
    207         )
    208         (self.root / "scripts").mkdir()
    209         for name in (
    210             "release-evidence.sh",
    211             "app_source.py",
    212             "ffi_source.py",
    213             "package_contract.py",
    214             "app_dependency_graph.py",
    215             "legacy_identifiers.py",
    216             "package_privacy.py",
    217         ):
    218             path = SCRIPTS / name
    219             if path.exists():
    220                 shutil.copyfile(path, self.root / "scripts" / name)
    221         for tool in (
    222             "jq",
    223             "shasum",
    224             "awk",
    225             "mktemp",
    226             "rm",
    227             "mkdir",
    228             "install",
    229             "cmp",
    230             "dirname",
    231             "git",
    232             "rg",
    233         ):
    234             resolved = shutil.which(tool)
    235             self.assertIsNotNone(resolved, f"fixture requires {tool}")
    236             (self.tools / tool).symlink_to(resolved)
    237         metadata = {
    238             "packages": [
    239                 {
    240                     "id": "ffi",
    241                     "name": "tera_ffi",
    242                     "version": "0.1.0-alpha",
    243                     "source": None,
    244                     "license": "GPL-3.0-or-later",
    245                 }
    246             ],
    247             "resolve": {"nodes": [{"id": "ffi", "dependencies": []}]},
    248             "workspace_members": ["ffi"],
    249         }
    250         self.write("metadata.json", json.dumps(metadata))
    251         self.executable(
    252             "cargo",
    253             "import os\nfrom pathlib import Path\n"
    254             "print(Path(os.environ['FIXTURE_METADATA']).read_text())\n",
    255         )
    256         self.executable(
    257             "uv",
    258             "import json, os, sys\nfrom pathlib import Path\n"
    259             "args = sys.argv[1:]\n"
    260             "expected = ['run', '--project', os.environ['FIXTURE_PROJECT'], "
    261             "'--offline', '--frozen', 'python']\n"
    262             "if args[:6] != expected: sys.exit(64)\n"
    263             "with Path(os.environ['FIXTURE_UV_LOG']).open('a') as out:\n"
    264             "    out.write(json.dumps(args) + '\\n')\n"
    265             "os.execv(sys.executable, [sys.executable, *args[6:]])\n",
    266         )
    267         installer = shutil.which("install")
    268         self.executable(
    269             "install",
    270             "import os, sys\nfrom pathlib import Path\n"
    271             "with Path(os.environ['FIXTURE_INSTALL_LOG']).open('a') as out:\n"
    272             "    out.write('install\\n')\n"
    273             f"os.execv({installer!r}, [{installer!r}, *sys.argv[1:]])\n",
    274         )
    275         self.write("Package.swift", "// fixture package\n")
    276         self.write("project.yml", "name: Tera\n")
    277         self.write(
    278             "Tera/Runtime/TeraGeneratedFixture.swift",
    279             "private func value() -> Int { 1 }\n",
    280         )
    281         self.write("Tera/Resources/message.txt", "fixture resource\n")
    282         self.write("Tera/Config/Debug.xcconfig", "FIXTURE = one\n")
    283         self.write("Tera/Info.plist", "fixture plist\n")
    284         self.write("Tera/Resources/PrivacyInfo.xcprivacy", "fixture privacy\n")
    285         self.write("Tera/Generated/Fixture.swift", "// synthetic generated binding\n")
    286         self.write("Tera/Frameworks/Fixture.a", "synthetic native bytes\n")
    287         self.write("Cargo.lock", "synthetic locked graph\n")
    288         shutil.copyfile(
    289             SCRIPTS.parent / "Package.resolved", self.root / "Package.resolved"
    290         )
    291         self.write(
    292             "Tera.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved",
    293             (self.root / "Package.resolved").read_text(),
    294         )
    295         self.write("Tera.xcodeproj/project.pbxproj", "synthetic generated project\n")
    296         self.write("TeraFFI/api/TeraKitBindings.symbols.json", "{}\n")
    297         self.write("api/TeraApp.symbols.json", "{}\n")
    298         self.write(
    299             "TeraFFI/provenance.json",
    300             json.dumps({"candidate": {"source": {"tree": "b" * 40}}}),
    301         )
    302         # Existing public producer paths are data, not newly invented identities.
    303         import ffi_source
    304 
    305         shutil.copyfile(
    306             SCRIPTS.parent / ffi_source.INPUTS[-1], self.root / ffi_source.INPUTS[-1]
    307         )
    308         self.epoch(1787871027)
    309         self.git("init", "--quiet")
    310         self.git("add", ".")
    311         self.environment = {
    312             **os.environ,
    313             "PATH": str(self.tools),
    314             "TMPDIR": str(self.root),
    315             "FIXTURE_METADATA": str(self.root / "metadata.json"),
    316             "FIXTURE_PROJECT": str(self.root / "scripts/persona-verifier"),
    317             "FIXTURE_UV_LOG": str(self.root / "uv.jsonl"),
    318             "FIXTURE_INSTALL_LOG": str(self.root / "install.log"),
    319         }
    320         self.commands = 0
    321 
    322     def write(self, relative: str, text: str) -> None:
    323         path = self.root / relative
    324         path.parent.mkdir(parents=True, exist_ok=True)
    325         path.write_text(text)
    326 
    327     def executable(self, name: str, body: str) -> None:
    328         self.dispatcher.executable(name, body)
    329 
    330     def git(self, *arguments: str) -> str:
    331         return subprocess.check_output(
    332             ["git", *arguments], cwd=self.root, text=True, stderr=subprocess.DEVNULL
    333         ).strip()
    334 
    335     def epoch(self, value: int) -> None:
    336         self.write("TeraFFI/producer.toml", f"[build]\nsource_date_epoch = {value}\n")
    337         self.write(
    338             "TeraFFI/source/aarch64-apple-ios.json",
    339             json.dumps(
    340                 {
    341                     "foundation": {"revision": "a" * 40},
    342                     "build": {"source_date_epoch": value},
    343                 }
    344             ),
    345         )
    346 
    347     def run_release(self, mode: str, *, timeout=None) -> subprocess.CompletedProcess:
    348         argv = ["/bin/sh", str(self.root / "scripts/release-evidence.sh"), mode]
    349         command = ReleaseCommand(
    350             argv,
    351             self.root,
    352             self.environment,
    353             fixture_limit("release_command") if timeout is None else timeout,
    354         )
    355         self.commands += 1
    356         try:
    357             return command.execute()
    358         finally:
    359             record = command.record
    360             for name, output in command.output.items():
    361                 (self.root / f"command-{self.commands:02}.{name}").write_bytes(output)
    362                 record[name] = output.decode(errors="replace")
    363             self.write(f"command-{self.commands:02}.json", json.dumps(record))
    364 
    365     def prior(self) -> dict[str, bytes]:
    366         return {
    367             name: (self.root / "release" / name).read_bytes()
    368             for name in ("sbom.cdx.json", "provenance.json")
    369         }
    370 
    371     def baseline(self) -> dict[str, bytes]:
    372         result = self.run_release("write")
    373         self.assertEqual(result.returncode, 0, result.stderr)
    374         self.installs = (self.root / "install.log").read_bytes()
    375         return self.prior()
    376 
    377     def assert_rejected_unchanged(self, mode: str, prior: dict[str, bytes]) -> None:
    378         result = self.run_release(mode)
    379         self.assertNotEqual(result.returncode, 0, result.stdout)
    380         self.assertEqual(self.prior(), prior)
    381         self.assertEqual((self.root / "install.log").read_bytes(), self.installs)
    382 
    383 
    384 class ReleaseEvidenceTests(ReleaseFixture):
    385     def assert_staged_change_stales(self, relative: str, text: str) -> None:
    386         prior = self.baseline()
    387         self.write(relative, text)
    388         self.git("add", relative)
    389         self.assert_rejected_unchanged("check", prior)
    390 
    391     def test_private_body_only_staged_change_invalidates_release_evidence(self) -> None:
    392         self.assert_staged_change_stales(
    393             "Tera/Runtime/TeraGeneratedFixture.swift",
    394             "private func value() -> Int { 2 }\n",
    395         )
    396 
    397     def test_resource_change_invalidates_release_evidence(self) -> None:
    398         self.assert_staged_change_stales("Tera/Resources/message.txt", "new resource\n")
    399 
    400     def test_configuration_change_invalidates_release_evidence(self) -> None:
    401         self.assert_staged_change_stales(
    402             "Tera/Config/Debug.xcconfig", "FIXTURE = two\n"
    403         )
    404 
    405     def test_staged_add_remove_invalidates_release_evidence(self) -> None:
    406         prior = self.baseline()
    407         self.write("Tera/Runtime/Added.swift", "private func added() {}\n")
    408         self.git("add", "Tera/Runtime/Added.swift")
    409         self.assert_rejected_unchanged("check", prior)
    410         prior = self.baseline()
    411         self.git("rm", "-f", "Tera/Runtime/Added.swift")
    412         self.assert_rejected_unchanged("check", prior)
    413 
    414     def test_package_and_project_manifest_edits_invalidate_release_evidence(
    415         self,
    416     ) -> None:
    417         for relative in ("Package.swift", "project.yml"):
    418             with self.subTest(relative=relative):
    419                 self.assert_staged_change_stales(
    420                     relative, "changed authored manifest\n"
    421                 )
    422 
    423     def test_app_or_epoch_drift_during_rendering_rejects_before_output_change(
    424         self,
    425     ) -> None:
    426         prior = self.baseline()
    427         control = self.root / "drift.json"
    428         self.environment["FIXTURE_DRIFT"] = str(control)
    429         self.executable(
    430             "cargo",
    431             "import json, os, subprocess\nfrom pathlib import Path\n"
    432             "control = Path(os.environ['FIXTURE_DRIFT'])\n"
    433             "if control.exists():\n"
    434             "    value = json.loads(control.read_text())\n"
    435             "    Path(value['path']).write_text(value['text'])\n"
    436             "    subprocess.run(['git', 'add', value['path']], check=True)\n"
    437             "print(Path(os.environ['FIXTURE_METADATA']).read_text())\n",
    438         )
    439         for relative, text in (
    440             (
    441                 "Tera/Runtime/TeraGeneratedFixture.swift",
    442                 "private func value() -> Int { 2 }\n",
    443             ),
    444             ("TeraFFI/producer.toml", "[build]\nsource_date_epoch = 12345\n"),
    445         ):
    446             original = (self.root / relative).read_bytes()
    447             for mode in ("write", "check"):
    448                 with self.subTest(relative=relative, mode=mode):
    449                     self.write(
    450                         "drift.json",
    451                         json.dumps({"path": str(self.root / relative), "text": text}),
    452                     )
    453                     self.assert_rejected_unchanged(mode, prior)
    454                     (self.root / relative).write_bytes(original)
    455                     self.git("add", relative)
    456             control.unlink()
    457 
    458 
    459 class ReleaseScannerTests(ReleaseFixture):
    460     def test_clean_deterministic_write_and_check_bind_canonical_epoch(self) -> None:
    461         self.epoch(12345)
    462         self.git("add", "TeraFFI")
    463         prior = self.baseline()
    464         self.assertEqual(self.run_release("check").returncode, 0)
    465         self.assertEqual(self.run_release("write").returncode, 0)
    466         self.assertEqual(self.prior(), prior)
    467         output = json.loads(prior["provenance.json"])
    468         self.assertEqual(output["source"]["source_date_epoch"], 12345)
    469         self.assertEqual(output["schema"], "tera.release-provenance.v1")
    470         self.assertEqual(output["source"]["authored_app"]["policy"], "staged_inputs")
    471         self.assertIn(
    472             "Tera/Runtime/TeraGeneratedFixture.swift",
    473             output["source"]["authored_app"]["files"],
    474         )
    475 
    476     def test_missing_scanner_rejects_write_and_check_preserving_prior_bytes(
    477         self,
    478     ) -> None:
    479         prior = self.baseline()
    480         (self.tools / "rg").unlink()
    481         for mode in ("write", "check"):
    482             with self.subTest(mode=mode):
    483                 self.assert_rejected_unchanged(mode, prior)
    484 
    485     def test_scanner_status2_rejects_write_and_check_preserving_prior_bytes(
    486         self,
    487     ) -> None:
    488         prior = self.baseline()
    489         self.executable("rg", "import sys\nsys.exit(2)\n")
    490         for mode in ("write", "check"):
    491             with self.subTest(mode=mode):
    492                 self.assert_rejected_unchanged(mode, prior)
    493 
    494     def test_forbidden_material_rejects_without_printing_it_or_changing_outputs(
    495         self,
    496     ) -> None:
    497         prior = self.baseline()
    498         metadata = json.loads((self.root / "metadata.json").read_text())
    499         sentinel = "BEGIN PRIVATE KEY C138_PROTECTED_SENTINEL"
    500         metadata["packages"][0]["source"] = sentinel
    501         self.write("metadata.json", json.dumps(metadata))
    502         for mode in ("write", "check"):
    503             with self.subTest(mode=mode):
    504                 result = self.run_release(mode)
    505                 self.assertNotEqual(result.returncode, 0)
    506                 self.assertEqual(self.prior(), prior)
    507                 self.assertNotIn(sentinel.encode(), result.stdout + result.stderr)
    508 
    509     def test_unreadable_rendered_input_rejects_write_and_check_preserving_prior_bytes(
    510         self,
    511     ) -> None:
    512         prior = self.baseline()
    513         scanner = shutil.which("rg")
    514         self.executable(
    515             "rg",
    516             "import os, sys\n"
    517             "import subprocess\n"
    518             "os.chmod(sys.argv[-1], 0)\n"
    519             f"status = subprocess.run([{scanner!r}, *sys.argv[1:]], check=False).returncode\n"
    520             "os.chmod(sys.argv[-1], 0o644)\n"
    521             "sys.exit(status)\n",
    522         )
    523         for mode in ("write", "check"):
    524             with self.subTest(mode=mode):
    525                 self.assert_rejected_unchanged(mode, prior)
    526 
    527 
    528 class ReleaseProcessTests(ReleaseFixture):
    529     def control(self, body: str) -> None:
    530         self.write(
    531             "control.py",
    532             "import json, os, signal, sys, time\nfrom pathlib import Path\n"
    533             "root = Path(__file__).parent\n"
    534             "(root / 'direct.json').write_text(json.dumps({"
    535             "'pid': os.getpid(), 'pgid': os.getpgrp(), 'sid': os.getsid(0)}))\n" + body,
    536         )
    537         self.write(
    538             "scripts/release-evidence.sh",
    539             f"exec {shlex.quote(sys.executable)} {shlex.quote(str(self.root / 'control.py'))}\n",
    540         )
    541 
    542     def settled(self) -> dict:
    543         record = json.loads(
    544             (self.root / f"command-{self.commands:02}.json").read_text()
    545         )
    546         direct = json.loads((self.root / "direct.json").read_text())
    547         self.assertEqual(
    548             (direct["pid"], direct["pgid"], direct["sid"]), (record["pid"],) * 3
    549         )
    550         self.assertTrue(record["wait_reaped"])
    551         self.assertTrue(record["group_absent"])
    552         with self.assertRaises(ProcessLookupError):
    553             os.killpg(record["pgid"], 0)
    554         self.assertLessEqual(record["elapsed_seconds"], record["timeout"] + 2.5)
    555         return record
    556 
    557     def test_normal_and_rejected_commands_preserve_bytes_status_and_deadline(
    558         self,
    559     ) -> None:
    560         for status in (0, 7):
    561             with self.subTest(status=status):
    562                 self.control(
    563                     f"print('ordinary stdout'); print('ordinary stderr', file=sys.stderr); sys.exit({status})\n"
    564                 )
    565                 result = self.run_release("write")
    566                 self.assertEqual(result.returncode, status)
    567                 self.assertEqual(result.stdout, b"ordinary stdout\n")
    568                 self.assertEqual(result.stderr, b"ordinary stderr\n")
    569                 self.assertEqual(
    570                     self.settled()["timeout"], fixture_limit("release_command")
    571                 )
    572 
    573     def test_stdin_is_closed_even_when_the_caller_has_input(self) -> None:
    574         self.control("print(repr(sys.stdin.buffer.read()))\n")
    575         reader, writer = os.pipe()
    576         original = os.dup(0)
    577         try:
    578             os.write(writer, b"P139R_SYNTHETIC_INHERITED_INPUT")
    579             os.close(writer)
    580             os.dup2(reader, 0)
    581             result = self.run_release("write", timeout=1)
    582         finally:
    583             os.dup2(original, 0)
    584             os.close(original)
    585             os.close(reader)
    586         self.assertEqual(result.returncode, 0)
    587         self.assertEqual(result.stdout, b"b''\n")
    588         self.settled()
    589 
    590     def test_exact_output_limits_are_preserved(self) -> None:
    591         self.control(
    592             "sys.stdout.buffer.write(b'x' * 1048576); sys.stderr.buffer.write(b'y' * 65536)\n"
    593         )
    594         result = self.run_release("write", timeout=2)
    595         self.assertEqual(result.returncode, 0)
    596         self.assertEqual(result.stdout, b"x" * 1048576)
    597         self.assertEqual(result.stderr, b"y" * 65536)
    598         self.settled()
    599 
    600     def test_output_excess_rejects_and_settles(self) -> None:
    601         for stream, limit in ReleaseCommand.LIMITS.items():
    602             with self.subTest(stream=stream):
    603                 self.control(
    604                     f"while True: sys.{stream}.buffer.write(b'x' * {limit + 1}); sys.{stream}.flush()\n"
    605                 )
    606                 with self.assertRaisesRegex(RuntimeError, "exceeds capture limit"):
    607                     self.run_release("write", timeout=2)
    608                 record = self.settled()
    609                 self.assertEqual(record["output_excess"], stream)
    610                 output = self.root / f"command-{self.commands:02}.{stream}"
    611                 self.assertEqual(output.stat().st_size, limit)
    612 
    613     def child_control(self, *, ignore_term: bool, close_pipes: bool) -> None:
    614         handler = "(root / 'term.txt').write_text('received TERM')"
    615         if not ignore_term:
    616             handler += "; sys.exit(0)"
    617         self.control(
    618             "child = os.fork()\n"
    619             "if child == 0:\n"
    620             f"    signal.signal(signal.SIGTERM, lambda *_: ({handler.replace('; ', ', ')}))\n"
    621             "    (root / 'ready.json').write_text(json.dumps({'pid': os.getpid(), 'pgid': os.getpgrp(), 'sid': os.getsid(0)}))\n"
    622             + ("    os.close(1); os.close(2)\n" if close_pipes else "")
    623             + "    time.sleep(1.2)\n"
    624             "    (root / 'late.txt').write_text('escaped late write')\n"
    625             "    while True: time.sleep(1)\n"
    626             "while not (root / 'ready.json').exists(): time.sleep(0.005)\n"
    627             "print('ready child', flush=True)\n"
    628         )
    629 
    630     def assert_child_settled(self, *, ignore_term: bool) -> dict:
    631         record = self.settled()
    632         child = json.loads((self.root / "ready.json").read_text())
    633         self.assertEqual(child["pgid"], record["pgid"])
    634         self.assertEqual(child["sid"], record["pgid"])
    635         self.assertEqual((self.root / "term.txt").read_text(), "received TERM")
    636         with self.assertRaises(ProcessLookupError):
    637             os.kill(child["pid"], 0)
    638         if ignore_term:
    639             self.assertIn(
    640                 signal.SIGKILL, [event["signal"] for event in record["signals"]]
    641             )
    642         # Ready, actual TERM and absent PID/group establish what the scheduled writer did.
    643         time.sleep(1.25)
    644         self.assertFalse((self.root / "late.txt").exists())
    645         return record
    646 
    647     def test_timeout_settles_child_retaining_capture_pipes(self) -> None:
    648         self.child_control(ignore_term=False, close_pipes=False)
    649         with self.assertRaises(subprocess.TimeoutExpired) as observed:
    650             self.run_release("write", timeout=0.3)
    651         self.assertEqual(observed.exception.timeout, 0.3)
    652         self.assertEqual(observed.exception.stdout, b"ready child\n")
    653         self.assertEqual(
    654             self.assert_child_settled(ignore_term=False)["error"], "TimeoutExpired"
    655         )
    656 
    657     def test_timeout_kills_child_ignoring_term(self) -> None:
    658         self.child_control(ignore_term=True, close_pipes=False)
    659         with self.assertRaises(subprocess.TimeoutExpired):
    660             self.run_release("write", timeout=0.3)
    661         self.assert_child_settled(ignore_term=True)
    662 
    663     def test_normal_completion_settles_child_with_closed_capture_pipes(self) -> None:
    664         self.child_control(ignore_term=True, close_pipes=True)
    665         result = self.run_release("write", timeout=2)
    666         self.assertEqual(result.returncode, 0)
    667         self.assertEqual(result.stdout, b"ready child\n")
    668         self.assert_child_settled(ignore_term=True)
    669 
    670 
    671 if __name__ == "__main__":
    672     unittest.main()