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_ffi_installed.py (9766B)


      1 from __future__ import annotations
      2 
      3 import copy
      4 import json
      5 import shutil
      6 import sys
      7 import tempfile
      8 import unittest
      9 from pathlib import Path
     10 from contextlib import ExitStack
     11 from unittest.mock import patch
     12 
     13 SCRIPTS = Path(__file__).resolve().parent
     14 if str(SCRIPTS) not in sys.path:
     15     sys.path.insert(0, str(SCRIPTS))
     16 
     17 import ffi_artifacts as artifacts  # noqa: E402
     18 import ffi_installed as installed  # noqa: E402
     19 import ffi_provenance as provenance  # noqa: E402
     20 import ffi_source as source  # noqa: E402
     21 import ffi_notices as notices  # noqa: E402
     22 import package_contract as contract  # noqa: E402
     23 import test_ffi_artifacts as fixtures  # noqa: E402
     24 
     25 
     26 class InstalledArtifactTests(unittest.TestCase):
     27     def setUp(self) -> None:
     28         fixture = fixtures.NativeArtifactTests()
     29         fixture.setUp()
     30         self.addCleanup(fixture.doCleanups)
     31         temporary = tempfile.TemporaryDirectory()
     32         self.addCleanup(temporary.cleanup)
     33         self.root = Path(temporary.name).resolve()
     34         self.manifest = installed.installed_manifest(
     35             artifacts.check(fixture.root, fixture.records)
     36         )
     37         for relative, destination in installed.installed_paths().items():
     38             path = self.root / destination
     39             path.parent.mkdir(parents=True, exist_ok=True)
     40             shutil.copyfile(fixture.root / relative, path)
     41         (self.root / installed.MANIFEST).write_bytes(provenance.encoded(self.manifest))
     42 
     43     def epoch_fixture(self, epoch: int) -> ExitStack:
     44         """Substitute native-source admission only; verify real fixture lock bytes."""
     45         config = source.producer_contract(SCRIPTS.parent)
     46         foundation = contract._read_toml(SCRIPTS.parent / config["foundation_lock"])
     47         binding = {
     48             **self.manifest["candidate"]["redistribution"],
     49             "repository": foundation["repository"],
     50             "revision": foundation["revision"],
     51         }
     52         snapshot = {"tree": self.manifest["candidate"]["source"]["tree"]}
     53         (self.root / "TeraFFI/producer.toml").write_text(
     54             f"[build]\nsource_date_epoch = {epoch}\n"
     55         )
     56         (self.root / config["foundation_lock"]).write_bytes(
     57             (SCRIPTS.parent / config["foundation_lock"]).read_bytes()
     58         )
     59         for target in artifacts.TARGETS:
     60             record = {
     61                 "source": snapshot,
     62                 "foundation": foundation,
     63                 "redistribution": binding,
     64                 "build": {"target": target, "source_date_epoch": epoch},
     65             }
     66             (self.root / "TeraFFI/source" / f"{target}.json").write_bytes(
     67                 provenance.encoded(record)
     68             )
     69         candidate = copy.deepcopy(self.manifest["candidate"])
     70         candidate["redistribution"] = binding
     71         paths = installed.installed_paths()
     72         for index, item in enumerate(candidate["files"]):
     73             if item["path"].startswith("source/"):
     74                 candidate["files"][index] = {
     75                     **artifacts.file_record(self.root, paths[item["path"]]),
     76                     "path": item["path"],
     77                 }
     78         self.manifest = installed.installed_manifest(candidate)
     79         (self.root / installed.MANIFEST).write_bytes(provenance.encoded(self.manifest))
     80         (self.root / installed.LOCK).write_bytes(
     81             installed.encoded_lock(self.manifest, foundation, epoch)
     82         )
     83 
     84         def admitted_producer(root: Path) -> dict:
     85             value = contract.producer_source_epoch(root)
     86             return {
     87                 **config,
     88                 "build": {**config["build"], "source_date_epoch": value},
     89                 "redistribution": {
     90                     **config["redistribution"],
     91                     "sha256": binding["sha256"],
     92                 },
     93             }
     94 
     95         stack = ExitStack()
     96         stack.enter_context(
     97             patch.object(source, "producer_contract", side_effect=admitted_producer)
     98         )
     99         stack.enter_context(
    100             patch.object(source, "source_snapshot", return_value=snapshot)
    101         )
    102         return stack
    103 
    104     def test_coherent_alternate_epoch_preserves_installed_manifest_contract(
    105         self,
    106     ) -> None:
    107         for epoch in (1787871027, 12345, 1):
    108             with self.subTest(epoch=epoch), self.epoch_fixture(epoch):
    109                 self.assertEqual(installed.check(self.root), self.manifest)
    110 
    111     def test_changed_or_invalid_installed_epoch_rejects(self) -> None:
    112         with self.epoch_fixture(1):
    113             path = self.root / installed.LOCK
    114             before = path.read_bytes()
    115             for epoch in (None, "1", 0, -1, True, 2):
    116                 with self.subTest(epoch=epoch):
    117                     replacement = (
    118                         b""
    119                         if epoch is None
    120                         else f"source_date_epoch = {json.dumps(epoch)}\n".encode()
    121                     )
    122                     path.write_bytes(
    123                         before.replace(b"source_date_epoch = 1\n", replacement)
    124                     )
    125                     with self.assertRaisesRegex(
    126                         source.ProvenanceError, "lock is stale"
    127                     ):
    128                         installed.check(self.root)
    129 
    130     def test_installed_inventory_retains_exact_candidate_file_identities(self) -> None:
    131         installed.verify_files(self.root, self.manifest)
    132         self.assertEqual(len(self.manifest["files"]), 14)
    133         self.assertIn(
    134             notices.INSTALLED_PATH, {item["path"] for item in self.manifest["files"]}
    135         )
    136         self.assertEqual(
    137             self.manifest["disposition"], "local_installed_not_release_qualified"
    138         )
    139 
    140     def test_missing_or_tampered_installed_library_is_rejected(self) -> None:
    141         library = (
    142             self.root / "Tera/Frameworks/TeraFFI.xcframework/ios-arm64/libtera_ffi.a"
    143         )
    144         library.write_bytes(b"tampered synthetic verifier fixture")
    145         with self.assertRaisesRegex(source.ProvenanceError, "bytes are stale"):
    146             installed.verify_files(self.root, self.manifest)
    147         library.unlink()
    148         with self.assertRaisesRegex(source.ProvenanceError, "missing"):
    149             installed.verify_files(self.root, self.manifest)
    150 
    151     def test_missing_or_truncated_notice_is_rejected(self) -> None:
    152         path = self.root / notices.INSTALLED_PATH
    153         path.write_bytes(path.read_bytes()[:-1])
    154         with self.assertRaisesRegex(source.ProvenanceError, "material differs"):
    155             installed.verify_files(self.root, self.manifest)
    156         path.unlink()
    157         with self.assertRaisesRegex(source.ProvenanceError, "unavailable"):
    158             installed.verify_files(self.root, self.manifest)
    159 
    160     def test_extra_generated_source_cannot_survive_an_install(self) -> None:
    161         (self.root / "Tera/Generated/LegacyBindings.swift").write_text("// synthetic\n")
    162         with self.assertRaisesRegex(source.ProvenanceError, "inventory differs"):
    163             installed.verify_files(self.root, self.manifest)
    164 
    165     def test_manifest_cannot_substitute_an_installed_file_hash(self) -> None:
    166         changed = copy.deepcopy(self.manifest)
    167         changed["files"][0]["sha256"] = "f" * 64
    168         with self.assertRaisesRegex(source.ProvenanceError, "manifest differs"):
    169             installed.verify_files(self.root, changed)
    170 
    171     def test_symlinked_installed_source_is_rejected(self) -> None:
    172         path = self.root / "Tera/Generated/TeraKitBindings.swift"
    173         path.unlink()
    174         path.symlink_to(self.root / installed.MANIFEST)
    175         with self.assertRaisesRegex(source.ProvenanceError, "symlink"):
    176             installed.verify_files(self.root, self.manifest)
    177 
    178     def test_symlinked_parent_is_rejected_before_any_installation_swap(self) -> None:
    179         with tempfile.TemporaryDirectory() as temporary:
    180             outside = Path(temporary) / "Tera"
    181             (self.root / "Tera").rename(outside)
    182             (self.root / "Tera").symlink_to(outside, target_is_directory=True)
    183             original = (outside / "Generated/TeraKitBindings.swift").read_bytes()
    184             previous = self.root / "previous-unused"
    185             with self.assertRaisesRegex(
    186                 source.ProvenanceError, "path contains a symlink"
    187             ):
    188                 installed.replace_installation(
    189                     self.root, self.root / "stage-unused", previous
    190                 )
    191             self.assertFalse(previous.exists())
    192             self.assertEqual(
    193                 (outside / "Generated/TeraKitBindings.swift").read_bytes(), original
    194             )
    195 
    196     def test_failed_final_source_check_restores_the_prior_installation(self) -> None:
    197         retained_resource = self.root / "Tera/Resources/retained.txt"
    198         retained_resource.write_bytes(b"unrelated application resource")
    199         staging = self.root / "stage"
    200         previous = self.root / "previous"
    201         before = {
    202             p.relative_to(self.root): p.read_bytes()
    203             for p in self.root.rglob("*")
    204             if p.is_file()
    205         }
    206         for relative, data in before.items():
    207             path = staging / relative
    208             path.parent.mkdir(parents=True, exist_ok=True)
    209             path.write_bytes(data + b"new synthetic generation")
    210         (staging / installed.LOCK).write_text("new lock\n")
    211         with patch.object(
    212             installed, "check", side_effect=source.ProvenanceError("source changed")
    213         ):
    214             with self.assertRaisesRegex(source.ProvenanceError, "source changed"):
    215                 installed.replace_installation(self.root, staging, previous)
    216         for relative, data in before.items():
    217             self.assertEqual((self.root / relative).read_bytes(), data)
    218         self.assertFalse((self.root / installed.LOCK).exists())
    219 
    220 
    221 if __name__ == "__main__":
    222     unittest.main()