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()