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_app_source.py (15101B)


      1 """Real Git and descriptor-relative authored-app capture controls."""
      2 
      3 from __future__ import annotations
      4 
      5 import json
      6 import os
      7 import subprocess
      8 import sys
      9 import tempfile
     10 import time
     11 import unittest
     12 from pathlib import Path
     13 from unittest.mock import patch
     14 
     15 SCRIPTS = Path(__file__).resolve().parent
     16 if str(SCRIPTS) not in sys.path:
     17     sys.path.insert(0, str(SCRIPTS))
     18 
     19 import app_source as app  # noqa: E402
     20 import ffi_source as source  # noqa: E402
     21 
     22 
     23 class AppSourceTests(unittest.TestCase):
     24     def setUp(self) -> None:
     25         evidence = os.environ.get("TERA_C138_TEST_EVIDENCE")
     26         if evidence:
     27             self.root = Path(tempfile.mkdtemp(prefix="app-", dir=evidence))
     28         else:
     29             temporary = tempfile.TemporaryDirectory()
     30             self.addCleanup(temporary.cleanup)
     31             self.root = Path(temporary.name).resolve()
     32         self.git("init", "--quiet")
     33         self.write("Package.swift", "// fixture package\n")
     34         self.write("project.yml", "name: Tera\n")
     35         self.write(
     36             "Tera/Runtime/TeraGeneratedBody.swift", "private func body() -> Int { 1 }\n"
     37         )
     38         self.write("Tera/Resources/message.txt", "resource one\n")
     39         self.write("Tera/Config/Debug.xcconfig", "VALUE = one\n")
     40         self.git("add", ".")
     41 
     42     def write(self, relative: str, text: str | bytes) -> None:
     43         path = self.root / relative
     44         path.parent.mkdir(parents=True, exist_ok=True)
     45         path.write_bytes(text.encode() if isinstance(text, str) else text)
     46 
     47     def git(self, *arguments: str) -> str:
     48         return subprocess.check_output(
     49             ["git", *arguments], cwd=self.root, stderr=subprocess.DEVNULL, text=True
     50         ).strip()
     51 
     52     def snapshot(self) -> dict:
     53         return app.capture(self.root)
     54 
     55     def test_unchanged_staged_source_reproduces_projected_git_tree(self) -> None:
     56         first = self.snapshot()
     57         self.assertEqual(first, self.snapshot())
     58         self.assertEqual(first["tree"], self.git("write-tree"))
     59         self.assertEqual(json.loads(app.encoded(first)), first)
     60 
     61     def test_authored_runtime_generated_prefix_is_included(self) -> None:
     62         self.assertIn("Tera/Runtime/TeraGeneratedBody.swift", self.snapshot()["files"])
     63 
     64     def test_intent_to_add_empty_and_nonempty_inputs_reject(self) -> None:
     65         for body in (b"", b"private func intent() {}\n"):
     66             with self.subTest(empty=not body):
     67                 self.write("Tera/intent.swift", body)
     68                 self.git("add", "--intent-to-add", "Tera/intent.swift")
     69                 with self.assertRaises(source.ProvenanceError):
     70                     self.snapshot()
     71                 self.git("update-index", "--force-remove", "Tera/intent.swift")
     72                 (self.root / "Tera/intent.swift").unlink()
     73 
     74     def test_coherent_staging_of_empty_and_nonempty_inputs_matches_git_tree(
     75         self,
     76     ) -> None:
     77         for body in (b"", b"private func staged() {}\n"):
     78             with self.subTest(empty=not body):
     79                 self.write("Tera/staged.swift", body)
     80                 self.git("add", "--intent-to-add", "Tera/staged.swift")
     81                 self.git("add", "Tera/staged.swift")
     82                 self.assertEqual(self.snapshot()["tree"], self.git("write-tree"))
     83 
     84     def test_private_body_resource_and_configuration_edits_change_identity(
     85         self,
     86     ) -> None:
     87         for relative in (
     88             "Tera/Runtime/TeraGeneratedBody.swift",
     89             "Tera/Resources/message.txt",
     90             "Tera/Config/Debug.xcconfig",
     91             "Package.swift",
     92             "project.yml",
     93         ):
     94             with self.subTest(relative=relative):
     95                 before = self.snapshot()
     96                 self.write(
     97                     relative, (self.root / relative).read_bytes() + b"// changed\n"
     98                 )
     99                 self.git("add", relative)
    100                 self.assertNotEqual(before["tree"], self.snapshot()["tree"])
    101 
    102     def test_staged_addition_and_removal_change_identity(self) -> None:
    103         before = self.snapshot()
    104         self.write("Tera/Runtime/Added.swift", "private func added() {}\n")
    105         self.git("add", "Tera")
    106         added = self.snapshot()
    107         self.assertNotEqual(before["tree"], added["tree"])
    108         self.git("rm", "-f", "Tera/Runtime/Added.swift")
    109         self.assertEqual(before, self.snapshot())
    110 
    111     def test_generated_outputs_are_excluded_without_evidence_cycle(self) -> None:
    112         before = self.snapshot()
    113         for relative in (
    114             "Tera/Generated/Bindings.swift",
    115             "Tera/Frameworks/Fixture.a",
    116             "TeraFFI/provenance.json",
    117             "TeraFFI/source/native.json",
    118             "api/TeraApp.symbols.json",
    119             "Tera.xcodeproj/project.pbxproj",
    120             "release/provenance.json",
    121         ):
    122             self.write(relative, "generated fixture\n")
    123         self.git("add", ".")
    124         self.assertEqual(before, self.snapshot())
    125         self.write("Tera/Generated/Ignored.swift", "untracked excluded binding\n")
    126         self.assertEqual(before, self.snapshot())
    127 
    128     def test_unstaged_untracked_ignored_and_missing_inputs_reject(self) -> None:
    129         body = self.root / "Tera/Runtime/TeraGeneratedBody.swift"
    130         original = body.read_bytes()
    131         body.write_bytes(original + b"// unstaged\n")
    132         with self.assertRaisesRegex(source.ProvenanceError, "differs from staged"):
    133             self.snapshot()
    134         body.write_bytes(original)
    135         extra = self.root / "Tera/extra.swift"
    136         extra.write_text("untracked\n")
    137         with self.assertRaisesRegex(source.ProvenanceError, "untracked or ignored"):
    138             self.snapshot()
    139         extra.unlink()
    140         self.write(".gitignore", "Tera/ignored.swift\n")
    141         self.write("Tera/ignored.swift", "ignored\n")
    142         with self.assertRaisesRegex(source.ProvenanceError, "untracked or ignored"):
    143             self.snapshot()
    144         (self.root / "Tera/ignored.swift").unlink()
    145         self.git("rm", "-f", "Package.swift")
    146         with self.assertRaisesRegex(source.ProvenanceError, "missing from index"):
    147             self.snapshot()
    148 
    149     def test_unreadable_input_rejects(self) -> None:
    150         path = self.root / "Tera/Resources/message.txt"
    151         path.chmod(0)
    152         self.addCleanup(path.chmod, 0o644)
    153         with self.assertRaisesRegex(source.ProvenanceError, "read"):
    154             self.snapshot()
    155 
    156     def test_symlink_and_directory_replacement_reject_before_foreign_read(self) -> None:
    157         body = self.root / "Tera/Runtime/TeraGeneratedBody.swift"
    158         original = body.read_bytes()
    159         foreign = self.root / "foreign"
    160         foreign.mkdir()
    161         (foreign / body.name).write_bytes(b"FOREIGN_BODY_SENTINEL")
    162         body.unlink()
    163         body.symlink_to(foreign / body.name)
    164         with self.assertRaisesRegex(source.ProvenanceError, "safely read"):
    165             self.snapshot()
    166         body.unlink()
    167         body.write_bytes(original)
    168         opening = os.open
    169         observed = []
    170         reading = os.read
    171         replaced = False
    172 
    173         def replace_directory(name, flags, *args, **kwargs):
    174             nonlocal replaced
    175             descriptor = opening(name, flags, *args, **kwargs)
    176             if name == "Runtime" and not replaced:
    177                 replaced = True
    178                 (self.root / "Tera/Runtime").rename(self.root / "preserved-runtime")
    179                 (self.root / "Tera/Runtime").symlink_to(
    180                     foreign, target_is_directory=True
    181                 )
    182             return descriptor
    183 
    184         def observe_read(descriptor, size):
    185             data = reading(descriptor, size)
    186             observed.append(data)
    187             return data
    188 
    189         with (
    190             patch.object(os, "open", side_effect=replace_directory),
    191             patch.object(os, "read", side_effect=observe_read),
    192         ):
    193             with self.assertRaises(source.ProvenanceError):
    194                 self.snapshot()
    195         self.assertTrue(replaced)
    196         self.assertNotIn(b"FOREIGN_BODY_SENTINEL", b"".join(observed))
    197 
    198     def test_scoped_index_and_member_drift_reject(self) -> None:
    199         reading = app.read_authored_source
    200         for mutation in ("index", "untracked", "ignored", "worktree"):
    201             with self.subTest(mutation=mutation):
    202                 changed = False
    203                 relative = "Tera/Resources/message.txt"
    204                 original = (self.root / relative).read_bytes()
    205 
    206                 def change_after_read(root, path, deadline):
    207                     nonlocal changed
    208                     result = reading(root, path, deadline)
    209                     if not changed:
    210                         changed = True
    211                         if mutation == "index":
    212                             self.write(relative, "new staged resource\n")
    213                             self.git("add", relative)
    214                         elif mutation in ("untracked", "ignored"):
    215                             self.write(
    216                                 ".gitignore",
    217                                 "Tera/drift.swift\n" if mutation == "ignored" else "",
    218                             )
    219                             self.write("Tera/drift.swift", "new authored member\n")
    220                         else:
    221                             self.write("Package.swift", "// unstaged drift\n")
    222                     return result
    223 
    224                 with patch.object(
    225                     app, "read_authored_source", side_effect=change_after_read
    226                 ):
    227                     with self.assertRaises(source.ProvenanceError):
    228                         self.snapshot()
    229                 self.write(relative, original)
    230                 self.write("Package.swift", "// fixture package\n")
    231                 (self.root / "Tera/drift.swift").unlink(missing_ok=True)
    232                 self.git("add", "Package.swift", relative)
    233 
    234     def test_mode_conflict_and_unsupported_index_entries_reject(self) -> None:
    235         relative = "Tera/Runtime/TeraGeneratedBody.swift"
    236         path = self.root / relative
    237         path.chmod(0o755)
    238         with self.assertRaisesRegex(source.ProvenanceError, "differs from staged"):
    239             self.snapshot()
    240         path.chmod(0o644)
    241         blob = self.git("rev-parse", ":" + relative)
    242         self.git("update-index", "--force-remove", relative)
    243         row = f"100644 {blob} 1\t{relative}\n".encode()
    244         subprocess.run(
    245             ["git", "update-index", "--index-info"],
    246             input=row,
    247             cwd=self.root,
    248             check=True,
    249             capture_output=True,
    250         )
    251         with self.assertRaisesRegex(source.ProvenanceError, "unresolved"):
    252             self.snapshot()
    253         self.git("add", relative)
    254         path.unlink()
    255         path.symlink_to("../Resources/message.txt")
    256         self.git("add", relative)
    257         with self.assertRaisesRegex(source.ProvenanceError, "unsupported mode"):
    258             self.snapshot()
    259 
    260     def test_git_selection_overrides_cannot_substitute_app_index(self) -> None:
    261         for name in (*app.GIT_OVERRIDES, "GIT_CONFIG_KEY_0", "GIT_CONFIG_VALUE_0"):
    262             with self.subTest(name=name), patch.dict(os.environ, {name: ""}):
    263                 with self.assertRaisesRegex(
    264                     source.ProvenanceError, "selection override"
    265                 ):
    266                     self.snapshot()
    267 
    268     def test_entry_and_file_bounds_accept_exact_and_reject_one_over(self) -> None:
    269         self.assertEqual(app.MAX_INPUTS, 2048)
    270         self.assertEqual(app.MAX_BYTES, 2 * 1024 * 1024)
    271         self.write("Tera/Resources/message.txt", b"x" * app.MAX_BYTES)
    272         self.git("add", "Tera/Resources/message.txt")
    273         self.assertEqual(
    274             self.snapshot()["files"]["Tera/Resources/message.txt"]["bytes"],
    275             app.MAX_BYTES,
    276         )
    277         self.write("Tera/Resources/message.txt", b"x" * (app.MAX_BYTES + 1))
    278         with self.assertRaisesRegex(source.ProvenanceError, "byte bound"):
    279             self.snapshot()
    280         self.write("Tera/Resources/message.txt", "bounded\n")
    281         for index in range(app.MAX_INPUTS - 5):
    282             self.write(f"Tera/Resources/member-{index:04}.txt", "x")
    283         self.git("add", "Tera")
    284         deadline = time.monotonic() + app.MAX_SECONDS
    285         self.assertEqual(
    286             app.scoped_inventory(self.root, deadline).count(b"\0"), app.MAX_INPUTS
    287         )
    288         self.write("Tera/Resources/one-over.txt", "x")
    289         self.git("add", "Tera")
    290         with self.assertRaisesRegex(source.ProvenanceError, "inventory exceeds bounds"):
    291             self.snapshot()
    292 
    293     def test_deadline_and_encoded_record_bounds_reject(self) -> None:
    294         self.assertEqual(app.MAX_SECONDS, 120)
    295         with self.assertRaisesRegex(source.ProvenanceError, "deadline"):
    296             app.scoped_inventory(self.root, time.monotonic() - 1)
    297         value = {"value": "x" * (app.MAX_BYTES - len(app.encoded({"value": ""})))}
    298         self.assertEqual(len(app.encoded(value)), app.MAX_BYTES)
    299         value["value"] += "x"
    300         with self.assertRaisesRegex(source.ProvenanceError, "record exceeds"):
    301             app.encoded(value)
    302         command = app.git
    303         timeouts = []
    304 
    305         def slow_command(root, argv, deadline):
    306             timeouts.append(app.remaining(deadline))
    307             result = command(root, argv, deadline)
    308             time.sleep(0.02)
    309             return result
    310 
    311         with (
    312             patch.object(app, "MAX_SECONDS", 0.03),
    313             patch.object(app, "git", side_effect=slow_command),
    314         ):
    315             with self.assertRaisesRegex(source.ProvenanceError, "deadline"):
    316                 self.snapshot()
    317         self.assertGreaterEqual(len(timeouts), 1)
    318         self.assertTrue(all(value <= 0.03 for value in timeouts))
    319 
    320     def test_git_output_is_bounded_and_owned_process_is_reaped(self) -> None:
    321         tool = self.root / "git"
    322         pid_file = self.root / "git-child.pid"
    323         for size, admitted in ((app.MAX_BYTES, True), (app.MAX_BYTES + 1, False)):
    324             tool.write_text(
    325                 f"#!{sys.executable}\nimport os, sys\nfrom pathlib import Path\n"
    326                 f"Path({str(pid_file)!r}).write_text(str(os.getpid()))\n"
    327                 f"sys.stdout.buffer.write(b'x' * {size})\n"
    328             )
    329             tool.chmod(0o700)
    330             with patch.dict(os.environ, {"PATH": str(self.root)}):
    331                 if admitted:
    332                     self.assertEqual(
    333                         len(
    334                             app.git(
    335                                 self.root,
    336                                 ["--version"],
    337                                 time.monotonic() + app.MAX_SECONDS,
    338                             )
    339                         ),
    340                         size,
    341                     )
    342                 else:
    343                     with self.assertRaisesRegex(
    344                         source.ProvenanceError, "output exceeds byte bound"
    345                     ):
    346                         app.git(
    347                             self.root, ["--version"], time.monotonic() + app.MAX_SECONDS
    348                         )
    349             with self.assertRaises(ProcessLookupError):
    350                 os.kill(int(pid_file.read_text()), 0)
    351 
    352 
    353 if __name__ == "__main__":
    354     unittest.main()