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