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 )