test_xcode_selection.py (33845B)
1 from __future__ import annotations 2 3 import json 4 import os 5 import shutil 6 import signal 7 import subprocess 8 import sys 9 import tempfile 10 import time 11 import traceback 12 import unittest 13 from pathlib import Path 14 15 from scripts.fixture_tool_dispatch import CompilerCommand, FixtureToolDispatcher 16 from scripts.fixture_test_policy import limit, load_policy 17 18 ROOT = Path(__file__).resolve().parent.parent 19 20 21 class OwnedFixtureProcess: 22 """Reserve a fixture group leader until its descendants have settled.""" 23 24 def __init__(self, argv, *, cwd, env, stdout, stderr, record_path): 25 self.argv = argv 26 self.record_path = record_path 27 self.started = time.monotonic() 28 self.deadline = self.started + limit("xcode_wrapper") 29 self.process = subprocess.Popen( 30 argv, cwd=cwd, env=env, stdout=stdout, stderr=stderr, start_new_session=True 31 ) 32 self.pid = self.process.pid 33 self.returncode = None 34 self.attempted_cleanup = False 35 self.settled = False 36 self.record = { 37 "argv": argv, 38 "cwd": str(cwd), 39 "pid": self.pid, 40 "pgid": self.pid, 41 "started_ns": time.time_ns(), 42 "signals": [], 43 "observations": [], 44 "policy_id": load_policy()["id"], 45 "policy_sha256": load_policy()["source_sha256"], 46 } 47 48 def poll(self): 49 if self.settled: 50 return self.returncode 51 result = os.waitid(os.P_PID, self.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) 52 if result is not None: 53 self.returncode = ( 54 result.si_status 55 if result.si_code == os.CLD_EXITED 56 else -result.si_status 57 ) 58 self.record.setdefault("exit_observed_ns", time.time_ns()) 59 return self.returncode 60 61 def wait(self, timeout): 62 deadline = min(self.deadline, time.monotonic() + timeout) 63 while self.poll() is None: 64 remaining = deadline - time.monotonic() 65 if remaining <= 0: 66 raise subprocess.TimeoutExpired(self.argv, timeout) 67 time.sleep(min(0.01, remaining)) 68 return self.returncode 69 70 def send_signal(self, number): 71 if self.poll() is None: 72 os.kill(self.pid, number) 73 self.record["signals"].append( 74 {"pid": self.pid, "signal": number, "at_ns": time.time_ns()} 75 ) 76 77 def group_signal(self, number): 78 try: 79 os.killpg(self.pid, number) 80 self.record["signals"].append( 81 {"pgid": self.pid, "signal": number, "at_ns": time.time_ns()} 82 ) 83 except ProcessLookupError: 84 pass 85 86 def signal_live_group(self, number, deadline): 87 if self.poll() is not None and not self.members(deadline): 88 return False 89 try: 90 self.group_signal(number) 91 except PermissionError: 92 self.record.setdefault("signal_errors", []).append( 93 { 94 "signal": number, 95 "at_ns": time.time_ns(), 96 "error": traceback.format_exc(), 97 } 98 ) 99 if self.poll() is None or self.members(deadline): 100 raise 101 return False 102 return True 103 104 def capture_members(self, deadline): 105 remaining = deadline - time.monotonic() 106 if remaining <= 0.05: 107 raise AssertionError("owned observer cleanup budget is exhausted") 108 argv = ["ps", "-axo", "pid=,ppid=,pgid=,uid=,lstart="] 109 observer = subprocess.Popen( 110 argv, 111 stdin=subprocess.DEVNULL, 112 stdout=subprocess.PIPE, 113 stderr=subprocess.PIPE, 114 start_new_session=True, 115 ) 116 command = {"argv": argv, "pid": observer.pid, "pgid": observer.pid} 117 self.record["observations"].append(command) 118 try: 119 try: 120 stdout, stderr = observer.communicate( 121 timeout=min(0.25, remaining - 0.05) 122 ) 123 except subprocess.TimeoutExpired: 124 observer.kill() 125 command["timeout"] = True 126 stdout, stderr = observer.communicate( 127 timeout=max(0.001, deadline - time.monotonic()) 128 ) 129 except BaseException: 130 command["cleanup_exception"] = traceback.format_exc() 131 raise 132 finally: 133 command.update( 134 exit=observer.returncode, 135 wait_reaped=observer.returncode is not None, 136 at_ns=time.time_ns(), 137 ) 138 try: 139 os.killpg(observer.pid, 0) 140 command["group_absent"] = False 141 except ProcessLookupError: 142 command["group_absent"] = True 143 if not command["group_absent"]: 144 raise AssertionError("owned process observer group remains") 145 return stdout, stderr, command 146 147 def members(self, deadline): 148 stdout, stderr, command = self.capture_members(deadline) 149 prefix = str(self.record_path) + f".ps-{len(self.record['observations']):02}" 150 Path(prefix + ".stdout").write_bytes(stdout) 151 Path(prefix + ".stderr").write_bytes(stderr) 152 if len(stdout) > 2_000_000 or len(stderr) > 65_536 or command["exit"]: 153 raise AssertionError("owned fixture group observation failed") 154 rows = [] 155 for line in stdout.decode().splitlines(): 156 fields = line.split(None, 4) 157 if len(fields) == 5 and int(fields[2]) == self.pid: 158 rows.append(dict(zip(("pid", "ppid", "pgid", "uid", "birth"), fields))) 159 command["members"] = rows 160 return [row for row in rows if int(row["pid"]) != self.pid] 161 162 def require_group_absent(self): 163 try: 164 os.killpg(self.pid, 0) 165 except ProcessLookupError: 166 return 167 raise AssertionError("owned fixture group remains after leader reaping") 168 169 def close(self): 170 if self.attempted_cleanup: 171 if not self.settled: 172 raise AssertionError("previous owned fixture cleanup failed") 173 return 174 self.attempted_cleanup = True 175 started = time.monotonic() 176 deadline = started + limit("leaf_cleanup") 177 self.record["cleanup_started_ns"] = time.time_ns() 178 try: 179 if self.signal_live_group(signal.SIGTERM, deadline): 180 time.sleep(0.1) 181 self.signal_live_group(signal.SIGKILL, deadline) 182 while self.members(deadline): 183 if time.monotonic() >= deadline: 184 raise AssertionError("owned fixture descendants did not settle") 185 time.sleep(min(0.01, max(0, deadline - time.monotonic()))) 186 self.record["descendants_absent_ns"] = time.time_ns() 187 self.returncode = self.process.wait( 188 timeout=max(0.001, deadline - time.monotonic()) 189 ) 190 self.record.update(exit=self.returncode, wait_reaped=True) 191 self.require_group_absent() 192 self.record["group_absent"] = True 193 if time.monotonic() > deadline: 194 raise AssertionError("owned fixture cleanup exceeded two seconds") 195 self.settled = True 196 except BaseException: 197 self.record["cleanup_exception"] = traceback.format_exc() 198 raise 199 finally: 200 self.record.update( 201 settled=self.settled, 202 cleanup_seconds=time.monotonic() - started, 203 cleanup_ended_ns=time.time_ns(), 204 ) 205 self.record_path.write_text(json.dumps(self.record, indent=2) + "\n") 206 207 208 class XcodeSelectionTests(unittest.TestCase): 209 def setUp(self) -> None: 210 evidence = os.environ.get("TERA_C138_TEST_EVIDENCE") 211 if evidence: 212 self.root = Path(tempfile.mkdtemp(prefix="xcode-selector-", dir=evidence)) 213 else: 214 self.directory = tempfile.TemporaryDirectory() 215 self.addCleanup(self.directory.cleanup) 216 self.root = Path(self.directory.name) 217 (self.root / "scripts").mkdir() 218 shutil.copyfile(ROOT / "scripts/xcode.sh", self.root / "scripts/xcode.sh") 219 (self.root / "TeraUITests").mkdir() 220 shutil.copyfile( 221 ROOT / "TeraUITests/TeraAccessibilityUITests.swift", 222 self.root / "TeraUITests/TeraAccessibilityUITests.swift", 223 ) 224 self.arguments = self.root / "arguments.json" 225 self.selector_sequence = 0 226 self.dispatcher = FixtureToolDispatcher(self.root, ("xcodebuild",)) 227 self.dispatcher.executable( 228 "xcodebuild", 229 "import json, os, sys\n" 230 "from pathlib import Path\n" 231 "Path(os.environ['TEST_XCODE_ARGUMENTS']).write_text(json.dumps(sys.argv[1:]))\n", 232 ) 233 self.environment = { 234 **os.environ, 235 "PATH": f"{self.root}:{os.environ['PATH']}", 236 "TEST_XCODE_ARGUMENTS": str(self.arguments), 237 "XCODE_DERIVED_DATA": str(self.root / "derived"), 238 "XCODE_SOURCE_PACKAGES": str(self.root / "sources"), 239 "XCODE_PACKAGE_CACHE": str(self.root / "cache"), 240 } 241 242 def run_selector(self, target: str, *selector: str) -> subprocess.CompletedProcess: 243 self.selector_sequence += 1 244 command = CompilerCommand( 245 [ 246 "/bin/bash", 247 str(self.root / "scripts/xcode.sh"), 248 "project-test", 249 "platform=iOS Simulator,id=078A0172-207D-4EA6-8767-74DF7C42A73A", 250 target, 251 *selector, 252 ], 253 self.root, 254 env=self.environment, 255 budget="selector_command", 256 ) 257 try: 258 result = command.execute() 259 finally: 260 (self.root / f"selector-{self.selector_sequence:02}.json").write_text( 261 json.dumps(command.record, indent=2) 262 ) 263 return subprocess.CompletedProcess( 264 result.args, 265 result.returncode, 266 result.stdout.decode(), 267 result.stderr.decode(), 268 ) 269 270 def assert_selection(self, target: str, *selector: str) -> None: 271 result = self.run_selector(target, *selector) 272 self.assertEqual(result.returncode, 0, result.stderr) 273 arguments = json.loads(self.arguments.read_text()) 274 expected = target + (f"/{selector[0]}" if selector and selector[0] else "") 275 self.assertIn(f"-only-testing:{expected}", arguments) 276 self.assertEqual(arguments[-1], "test") 277 self.assertIn("-disableAutomaticPackageResolution", arguments) 278 self.assertIn("-onlyUsePackageVersionsFromResolvedFile", arguments) 279 for flag, variable in [ 280 ("-derivedDataPath", "XCODE_DERIVED_DATA"), 281 ("-clonedSourcePackagesDirPath", "XCODE_SOURCE_PACKAGES"), 282 ("-packageCachePath", "XCODE_PACKAGE_CACHE"), 283 ]: 284 self.assertEqual( 285 arguments[arguments.index(flag) + 1], self.environment[variable] 286 ) 287 288 def test_default_full_targets_and_empty_make_argument_are_preserved(self) -> None: 289 self.assert_selection("TeraTests") 290 self.assert_selection("TeraUITests") 291 self.assert_selection("TeraUITests", "") 292 293 def test_owned_class_and_method_select_exact_native_case(self) -> None: 294 self.assert_selection("TeraUITests", "TeraAccessibilityUITests") 295 self.assert_selection( 296 "TeraUITests", 297 "TeraAccessibilityUITests/testActualPhotoDescriptionRemainsEditableAcrossSaveFailureAndRecovery", 298 ) 299 300 def test_unknown_or_injected_selector_never_launches_xcode(self) -> None: 301 for target, selector in [ 302 ("TeraTests", "TeraAccessibilityUITests"), 303 ("Unknown", "TeraAccessibilityUITests"), 304 ("TeraUITests", "MissingUITests"), 305 ("TeraUITests", "TeraAccessibilityUITests/testMissing"), 306 ("TeraUITests", "../TeraAccessibilityUITests"), 307 ("TeraUITests", "TeraAccessibilityUITests/"), 308 ( 309 "TeraUITests", 310 "TeraAccessibilityUITests/testMissing/-skip-testing:TeraUITests", 311 ), 312 ("TeraUITests", "TeraAccessibilityUITests;touch marker"), 313 ]: 314 with self.subTest(target=target, selector=selector): 315 result = self.run_selector(target, selector) 316 self.assertNotEqual(result.returncode, 0) 317 self.assertFalse(self.arguments.exists()) 318 319 def test_extra_arguments_never_launch_xcode(self) -> None: 320 result = self.run_selector("TeraUITests", "", "-skip-testing:TeraUITests") 321 self.assertNotEqual(result.returncode, 0) 322 self.assertFalse(self.arguments.exists()) 323 324 325 class PhysicalXcodeLifecycleTests(unittest.TestCase): 326 OPERATIONS = ("physical-app-build", "physical-ui-build", "physical-ui-test") 327 328 def setUp(self) -> None: 329 evidence = os.environ.get("TERA_C138_TEST_EVIDENCE") 330 if evidence: 331 self.root = Path(tempfile.mkdtemp(prefix="physical-wrapper-", dir=evidence)) 332 else: 333 temporary = tempfile.TemporaryDirectory() 334 self.addCleanup(temporary.cleanup) 335 self.root = Path(temporary.name).resolve() 336 (self.root / "scripts").mkdir() 337 for name in ("xcode.sh", "xcode_child.py"): 338 if (ROOT / "scripts" / name).exists(): 339 shutil.copyfile(ROOT / "scripts" / name, self.root / "scripts" / name) 340 self.tools = self.root / "tools" 341 self.tools.mkdir() 342 self.dispatcher = FixtureToolDispatcher( 343 self.tools, ("xcrun", "uv", "xcodebuild") 344 ) 345 self.locks = self.root / "locks" 346 self.locks.mkdir() 347 self.sentinel = self.locks / "tera-ios-lock-state.unrelated" 348 self.sentinel.write_bytes(b"unrelated invocation lock\n") 349 for name in ("mktemp", "unlink", "dirname", "mkdir"): 350 (self.tools / name).symlink_to(shutil.which(name)) 351 self.executable( 352 "xcrun", 353 "import json, os, sys\nfrom pathlib import Path\n" 354 "assert sys.argv[1:5] == ['devicectl', 'device', 'info', 'lockState']\n" 355 "path = Path(sys.argv[sys.argv.index('--json-output') + 1])\n" 356 "path.write_text(json.dumps({'result': {'passcodeRequired': False, 'unlockedSinceBoot': True}}))\n" 357 "Path(os.environ['MOCK_PREFLIGHT']).write_text(json.dumps({'lock': str(path), 'pid': os.getpid()}))\n" 358 "sys.exit(5 if os.environ['MOCK_MODE'] == 'preflight' else 0)\n", 359 ) 360 self.executable( 361 "uv", 362 "import json, os, sys, time\nfrom pathlib import Path\n" 363 "args = sys.argv[1:]\n" 364 "expected = ['run', '--project', os.environ['MOCK_PROJECT'], '--offline', '--frozen', 'python']\n" 365 "assert args[:6] == expected\n" 366 "Path(os.environ['MOCK_UV']).write_text(json.dumps(args))\n" 367 "deadline = time.monotonic() + 5\n" 368 "while os.environ['MOCK_MODE'] == 'early' and not Path(os.environ['MOCK_RELEASE']).exists() and time.monotonic() < deadline: time.sleep(0.01)\n" 369 "os.execv(sys.executable, [sys.executable, *args[6:]])\n", 370 ) 371 self.executable( 372 "xcodebuild", 373 "import json, os, signal, sys, time\nfrom pathlib import Path\n" 374 "lock = Path(json.loads(Path(os.environ['MOCK_PREFLIGHT']).read_text())['lock'])\n" 375 "ready = Path(os.environ['MOCK_READY'])\n" 376 "release = Path(os.environ['MOCK_RELEASE'])\n" 377 "event = Path(os.environ['MOCK_SIGNAL'])\n" 378 "settled = Path(os.environ['MOCK_SETTLED'])\n" 379 "observed = None\n" 380 "ignored_int = signal.getsignal(signal.SIGINT) == signal.SIG_IGN\n" 381 "def handle(number, frame):\n" 382 " global observed\n" 383 " observed = number\n" 384 " event.write_text(json.dumps({'pid': os.getpid(), 'signal': number, 'lock_exists': lock.exists()}))\n" 385 "signal.signal(signal.SIGINT, handle)\n" 386 "signal.signal(signal.SIGTERM, handle)\n" 387 "ready.write_text(json.dumps({'pid': os.getpid(), 'parent': os.getppid(), 'lock': str(lock), 'lock_exists': lock.exists(), 'ignored_int': ignored_int, 'argv': sys.argv[1:]}))\n" 388 "deadline = time.monotonic() + 10\n" 389 "while not release.exists() and time.monotonic() < deadline: time.sleep(0.01)\n" 390 "mode = os.environ['MOCK_MODE']\n" 391 "status = 33 if observed is not None else (19 if mode == 'failure' else 0)\n" 392 "settled.write_text(json.dumps({'pid': os.getpid(), 'signal': observed, 'exit': status, 'lock_exists': lock.exists()}))\n" 393 "if mode == 'self-signal':\n" 394 " signal.signal(signal.SIGTERM, signal.SIG_DFL)\n" 395 " os.kill(os.getpid(), signal.SIGTERM)\n" 396 "sys.exit(status)\n", 397 ) 398 self.sequence = 0 399 self.active_process = None 400 401 def executable(self, name: str, body: str) -> None: 402 self.dispatcher.executable(name, body) 403 404 def await_file( 405 self, path: Path, process: subprocess.Popen, *, timeout=None 406 ) -> dict: 407 deadline = min( 408 process.deadline, 409 process.started + limit("xcode_readiness") 410 if timeout is None 411 else time.monotonic() + timeout, 412 ) 413 while time.monotonic() < deadline: 414 if path.exists(): 415 try: 416 return json.loads(path.read_text()) 417 except json.JSONDecodeError: 418 pass 419 if process.poll() is not None: 420 self.fail( 421 f"wrapper settled before fixture readiness: {process.returncode}" 422 ) 423 time.sleep(0.01) 424 self.fail("wrapper fixture readiness deadline expired") 425 426 def settle_on_failure(self, process) -> None: 427 if process is not None: 428 process.close() 429 430 def check_previous_cleanup(self) -> None: 431 if self.active_process is not None and not self.active_process.settled: 432 raise AssertionError("prior physical fixture cleanup is incomplete") 433 434 def restore_role(self, process, mode, xcode, previous_mode, prefix) -> None: 435 self.settle_on_failure(process) 436 started = time.time_ns() 437 if mode == "missing": 438 (self.tools / "saved-xcode").rename(xcode) 439 else: 440 xcode.chmod(previous_mode) 441 Path(str(prefix) + ".role-restoration.json").write_text( 442 json.dumps({"started_ns": started, "ended_ns": time.time_ns()}) + "\n" 443 ) 444 445 def observe_child(self, process, paths, mode, forwarded): 446 ready, event, release, settled = paths 447 data = self.await_file(ready, process) 448 self.assertTrue(data["lock_exists"]) 449 self.assertFalse(data["ignored_int"]) 450 self.assertTrue(Path(data["lock"]).exists()) 451 if forwarded is not None: 452 process.send_signal(forwarded) 453 signal_data = self.await_file(event, process, timeout=5) 454 self.assertEqual(signal_data["pid"], data["pid"]) 455 self.assertEqual(signal_data["signal"], forwarded) 456 self.assertTrue(signal_data["lock_exists"]) 457 self.assertIsNone(process.poll()) 458 release.write_text("settle\n") 459 status = process.wait(timeout=5) 460 completion = json.loads(settled.read_text()) 461 self.assertTrue(completion["lock_exists"]) 462 expected = ( 463 33 464 if forwarded is not None 465 else {"failure": 19, "self-signal": 143}.get(mode, 0) 466 ) 467 self.assertEqual(status, expected) 468 return data, status 469 470 def lifecycle( 471 self, 472 operation: str, 473 mode: str, 474 forwarded: int | None = None, 475 *, 476 launch_timeout: float = 5, 477 ) -> None: 478 self.check_previous_cleanup() 479 self.sequence += 1 480 prefix = self.root / f"run-{self.sequence:02}" 481 preflight, ready, release, event, settled = ( 482 Path(str(prefix) + suffix) 483 for suffix in (".preflight", ".ready", ".release", ".signal", ".settled") 484 ) 485 derived = self.root / "derived" 486 derived.mkdir(exist_ok=True) 487 xcconfig = derived / "fixture.xcconfig" 488 xcconfig.write_text("FIXTURE = true\n") 489 environment = { 490 **os.environ, 491 "PATH": str(self.tools), 492 "TMPDIR": str(self.locks), 493 "XCODE_DERIVED_DATA": str(derived), 494 "XCODE_SOURCE_PACKAGES": str(self.root / "sources"), 495 "XCODE_PACKAGE_CACHE": str(self.root / "cache"), 496 "XCODE_RESULTS": str(self.root / "results"), 497 "TERA_IOS_DEVELOPMENT_TEAM": "A1B2C3D4E5", 498 "TERA_IOS_PHYSICAL_AUTOMATION": "1", 499 "TERA_IOS_UI_TEST_PHYSICAL_AUTOMATION": "1", 500 "TERA_IOS_UI_TEST_RUN_ID": "c138-fixture-01", 501 "TERA_IOS_UI_TEST_BLOSSOM_ORIGINS": "https://fixture.invalid", 502 "MOCK_PREFLIGHT": str(preflight), 503 "MOCK_READY": str(ready), 504 "MOCK_RELEASE": str(release), 505 "MOCK_SIGNAL": str(event), 506 "MOCK_SETTLED": str(settled), 507 "MOCK_MODE": mode, 508 "MOCK_PROJECT": str(self.root / "scripts/persona-verifier"), 509 "MOCK_UV": str(prefix) + ".uv", 510 } 511 argv = [ 512 "/bin/bash", 513 str(self.root / "scripts/xcode.sh"), 514 operation, 515 "id=AABB-CCDD", 516 ] 517 argv += ( 518 [str(xcconfig)] 519 if operation == "physical-app-build" 520 else [ 521 "TeraUITests/FixtureUITests/testFixture", 522 f"fixture-{self.sequence:02}", 523 ] 524 ) 525 xcode = self.tools / "xcodebuild" 526 previous_mode = xcode.stat().st_mode 527 if mode == "missing": 528 xcode.rename(self.tools / "saved-xcode") 529 elif mode == "not-executable": 530 xcode.chmod(0o600) 531 process = None 532 try: 533 with ( 534 Path(str(prefix) + ".stdout").open("wb") as stdout, 535 Path(str(prefix) + ".stderr").open("wb") as stderr, 536 ): 537 process = OwnedFixtureProcess( 538 argv, 539 cwd=self.root, 540 env=environment, 541 stdout=stdout, 542 stderr=stderr, 543 record_path=Path(str(prefix) + ".ownership.json"), 544 ) 545 self.active_process = process 546 self.addCleanup(self.settle_on_failure, process) 547 if mode == "early": 548 uv_log = Path(str(prefix) + ".uv") 549 self.await_file(uv_log, process) 550 process.send_signal(forwarded) 551 self.assertFalse(ready.exists()) 552 release.write_text("finish interpreter selection\n") 553 status = process.wait(timeout=5) 554 data = json.loads(preflight.read_text()) 555 self.assertEqual(status, 128 + forwarded) 556 self.assertFalse(ready.exists()) 557 elif mode in ("preflight", "missing", "not-executable"): 558 status = process.wait(timeout=launch_timeout) 559 data = json.loads(preflight.read_text()) 560 expected = {"preflight": 1, "missing": 127, "not-executable": 126}[ 561 mode 562 ] 563 self.assertEqual(status, expected) 564 self.assertFalse(ready.exists()) 565 else: 566 data, status = self.observe_child( 567 process, (ready, event, release, settled), mode, forwarded 568 ) 569 Path(str(prefix) + ".command.json").write_text( 570 json.dumps( 571 { 572 "argv": argv, 573 "cwd": str(self.root), 574 "wrapper_pid": process.pid, 575 "wrapper_exit": status, 576 "owned_lock": data["lock"], 577 "settled": process.poll() is not None, 578 "forwarded_signal": forwarded, 579 } 580 ) 581 ) 582 self.assertFalse(Path(data["lock"]).exists()) 583 if ready.exists(): 584 self.assertNotEqual(data["pid"], process.pid) 585 with self.assertRaises(ProcessLookupError): 586 os.kill(data["pid"], 0) 587 self.assertEqual( 588 self.sentinel.read_bytes(), b"unrelated invocation lock\n" 589 ) 590 finally: 591 self.restore_role(process, mode, xcode, previous_mode, prefix) 592 593 def every_branch(self, mode: str, forwarded: int | None = None) -> None: 594 timeout = limit("native_helper") if mode in ("missing", "not-executable") else 5 595 for operation in self.OPERATIONS: 596 with self.subTest(operation=operation, mode=mode): 597 self.lifecycle(operation, mode, forwarded, launch_timeout=timeout) 598 599 def test_each_physical_branch_success_keeps_then_cleans_owned_lock(self) -> None: 600 self.every_branch("success") 601 602 def test_each_physical_branch_failure_returns_actual_status_and_cleans( 603 self, 604 ) -> None: 605 self.every_branch("failure") 606 607 def test_each_physical_branch_int_forwards_waits_and_cleans(self) -> None: 608 self.every_branch("signal", signal.SIGINT) 609 610 def test_each_physical_branch_term_forwards_waits_and_cleans(self) -> None: 611 self.every_branch("signal", signal.SIGTERM) 612 613 def test_each_physical_branch_preflight_failure_cleans_without_xcode(self) -> None: 614 self.every_branch("preflight") 615 616 def test_each_physical_branch_launch_failure_preserves_status_and_cleans( 617 self, 618 ) -> None: 619 self.every_branch("missing") 620 self.every_branch("not-executable") 621 622 def test_child_signal_termination_is_observed_and_reaped(self) -> None: 623 self.every_branch("self-signal") 624 625 def test_early_signal_cannot_orphan_owned_child(self) -> None: 626 self.every_branch("early", signal.SIGINT) 627 self.every_branch("early", signal.SIGTERM) 628 629 def test_unrelated_lock_file_survives_cleanup(self) -> None: 630 self.every_branch("success") 631 632 633 class XcodeFixtureOwnershipTests(unittest.TestCase): 634 def setUp(self): 635 evidence = os.environ.get("TERA_C138_TEST_EVIDENCE") 636 if evidence: 637 self.root = Path(tempfile.mkdtemp(prefix="owned-xcode-", dir=evidence)) 638 else: 639 temporary = tempfile.TemporaryDirectory() 640 self.addCleanup(temporary.cleanup) 641 self.root = Path(temporary.name).resolve() 642 self.ready = self.root / "ready.json" 643 self.late = self.root / "late" 644 self.sentinel = self.root / "unrelated" 645 self.sentinel.write_bytes(b"unrelated invocation\n") 646 647 def start_owned(self, leader_finish): 648 child = self.root / "child.py" 649 child.write_text( 650 "import json, os, signal, time\nfrom pathlib import Path\n" 651 "signal.signal(signal.SIGTERM, signal.SIG_IGN)\n" 652 "signal.signal(signal.SIGINT, signal.SIG_IGN)\n" 653 f"Path({str(self.ready)!r}).write_text(json.dumps({{'pid': os.getpid(), 'parent': os.getppid(), 'pgid': os.getpgrp()}}))\n" 654 "os.close(1); os.close(2)\n" 655 "time.sleep(8)\n" 656 f"Path({str(self.late)!r}).write_text('actual late writer ran\\n')\n" 657 ) 658 leader = self.root / "leader.py" 659 leader.write_text( 660 "import os, subprocess, sys, time\nfrom pathlib import Path\n" 661 f"subprocess.Popen([sys.executable, {str(child)!r}], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n" 662 f"deadline=time.monotonic()+5\nwhile not Path({str(self.ready)!r}).exists() and time.monotonic()<deadline: time.sleep(.01)\n" 663 + leader_finish 664 ) 665 with ( 666 (self.root / "stdout").open("wb") as stdout, 667 (self.root / "stderr").open("wb") as stderr, 668 ): 669 process = OwnedFixtureProcess( 670 [sys.executable, str(leader)], 671 cwd=self.root, 672 env=os.environ, 673 stdout=stdout, 674 stderr=stderr, 675 record_path=self.root / "ownership.json", 676 ) 677 self.addCleanup(process.close) 678 deadline = time.monotonic() + 5 679 while not self.ready.exists() and time.monotonic() < deadline: 680 time.sleep(0.01) 681 data = json.loads(self.ready.read_text()) 682 self.assertEqual(data["pgid"], process.pid) 683 return process, data 684 685 def assert_settlement(self, process, data): 686 with self.assertRaises(ProcessLookupError): 687 os.kill(data["pid"], 0) 688 with self.assertRaises(ProcessLookupError): 689 os.killpg(process.pid, 0) 690 self.assertFalse(self.late.exists()) 691 self.assertEqual(self.sentinel.read_bytes(), b"unrelated invocation\n") 692 record = json.loads((self.root / "ownership.json").read_text()) 693 self.assertTrue(record["group_absent"]) 694 self.assertTrue(record["wait_reaped"]) 695 self.assertLess(record["descendants_absent_ns"], record["cleanup_ended_ns"]) 696 self.assertLessEqual(record["cleanup_seconds"], 2) 697 self.assertIn(signal.SIGKILL, [row["signal"] for row in record["signals"]]) 698 for observer in record["observations"]: 699 self.assertTrue(observer["wait_reaped"]) 700 self.assertTrue(observer["group_absent"]) 701 process.close() 702 703 def test_exited_leader_keeps_identity_until_ignored_term_child_settles(self): 704 process, data = self.start_owned("sys.exit(7)\n") 705 self.assertEqual(process.wait(timeout=5), 7) 706 os.kill(process.pid, 0) 707 os.kill(data["pid"], 0) 708 process.close() 709 self.assertEqual(process.returncode, 7) 710 self.assert_settlement(process, data) 711 712 def test_closed_stdio_live_leader_and_ignored_term_child_are_owned(self): 713 process, data = self.start_owned("os.close(1); os.close(2)\ntime.sleep(8)\n") 714 self.assertIsNone(process.poll()) 715 process.close() 716 self.assertEqual(process.returncode, -signal.SIGTERM) 717 self.assert_settlement(process, data) 718 719 def test_exited_leader_without_descendants_reaps_actual_status(self): 720 body = self.root / "exit.py" 721 body.write_text("import sys\nsys.exit(7)\n") 722 with ( 723 (self.root / "stdout").open("wb") as stdout, 724 (self.root / "stderr").open("wb") as stderr, 725 ): 726 process = OwnedFixtureProcess( 727 [sys.executable, str(body)], 728 cwd=self.root, 729 env=os.environ, 730 stdout=stdout, 731 stderr=stderr, 732 record_path=self.root / "ownership.json", 733 ) 734 self.addCleanup(process.close) 735 self.assertEqual(process.wait(timeout=5), 7) 736 held = os.waitid(os.P_PID, process.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) 737 self.assertEqual((held.si_pid, held.si_status), (process.pid, 7)) 738 process.close() 739 self.assertEqual(process.returncode, 7) 740 with self.assertRaises(ProcessLookupError): 741 os.killpg(process.pid, 0) 742 record = json.loads((self.root / "ownership.json").read_text()) 743 self.assertTrue(record["wait_reaped"]) 744 self.assertTrue(record["group_absent"]) 745 self.assertEqual(record["signals"], []) 746 self.assertLessEqual(record["cleanup_seconds"], 2) 747 748 def test_timeout_settles_before_missing_role_restore_and_next_subcase(self): 749 fixture = PhysicalXcodeLifecycleTests() 750 fixture.setUp() 751 self.addCleanup(fixture.doCleanups) 752 original = (fixture.tools / "xcrun.body.py").read_text() 753 fixture.executable( 754 "xcrun", 755 "import json, os, signal, time\nfrom pathlib import Path\n" 756 "signal.signal(signal.SIGTERM, signal.SIG_IGN)\n" 757 "signal.signal(signal.SIGINT, signal.SIG_IGN)\n" 758 "Path(os.environ['MOCK_READY']).write_text(json.dumps({'pid': os.getpid(), 'parent': os.getppid(), 'pgid': os.getpgrp()}))\n" 759 "time.sleep(8)\n" 760 "Path(os.environ['MOCK_READY']+'.late').write_text('actual late writer ran\\n')\n" 761 + original, 762 ) 763 with self.assertRaises(subprocess.TimeoutExpired): 764 fixture.lifecycle("physical-app-build", "missing") 765 ready = json.loads((fixture.root / "run-01.ready").read_text()) 766 with self.assertRaises(ProcessLookupError): 767 os.kill(ready["pid"], 0) 768 ownership = json.loads((fixture.root / "run-01.ownership.json").read_text()) 769 restored = json.loads( 770 (fixture.root / "run-01.role-restoration.json").read_text() 771 ) 772 self.assertTrue(ownership["group_absent"]) 773 self.assertLessEqual(ownership["cleanup_seconds"], 2) 774 self.assertLessEqual(ownership["cleanup_ended_ns"], restored["started_ns"]) 775 self.assertTrue(os.access(fixture.tools / "xcodebuild", os.X_OK)) 776 self.assertFalse((fixture.root / "run-01.ready.late").exists()) 777 fixture.executable("xcrun", original) 778 fixture.lifecycle("physical-app-build", "not-executable") 779 self.assertEqual(fixture.sentinel.read_bytes(), b"unrelated invocation lock\n") 780 781 782 if __name__ == "__main__": 783 unittest.main()