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_artifacts.py (12082B)


      1 from __future__ import annotations
      2 
      3 import copy
      4 import hashlib
      5 import os
      6 import plistlib
      7 import sys
      8 import tempfile
      9 import unittest
     10 from pathlib import Path
     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_build as builder  # 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 
     24 
     25 class NativeArtifactTests(unittest.TestCase):
     26     def setUp(self) -> None:
     27         self.temporary = tempfile.TemporaryDirectory()
     28         self.addCleanup(self.temporary.cleanup)
     29         self.root = Path(self.temporary.name).resolve()
     30         for relative in artifacts.expected_paths():
     31             path = self.root / relative
     32             path.parent.mkdir(parents=True, exist_ok=True)
     33             path.write_bytes(b"synthetic verifier fixture; not an executable library\n")
     34         material = b"synthetic complete redistribution verifier fixture\n"
     35         (self.root / notices.ARTIFACT_PATH).write_bytes(material)
     36         self.notice_binding = {
     37             "schema": "tera.redistribution.v1",
     38             "package": "radroots_domain",
     39             "version": "0.1.0-alpha",
     40             "repository": contract.LIB_REMOTE,
     41             "revision": "b" * 40,
     42             "bytes": len(material),
     43             "sha256": hashlib.sha256(material).hexdigest(),
     44             "artifact_path": notices.ARTIFACT_PATH,
     45             "installed_path": notices.INSTALLED_PATH,
     46         }
     47         self.records = {
     48             target: {
     49                 "repository": "https://github.com/radrootslabs/tera",
     50                 "source": {"tree": "a" * 40},
     51                 "foundation": {"repository": contract.LIB_REMOTE, "revision": "b" * 40},
     52                 "redistribution": copy.deepcopy(self.notice_binding),
     53                 "build": {"target": target},
     54             }
     55             for target in artifacts.TARGETS
     56         }
     57         for target, record in self.records.items():
     58             (self.root / "source" / f"{target}.json").write_bytes(
     59                 provenance.encoded(record)
     60             )
     61         self.install_headers()
     62         self.install_framework_info()
     63         symbols = {target: ["ffi_tera_ffi_fixture"] for target in artifacts.TARGETS}
     64         (self.root / "abi_symbols.json").write_bytes(provenance.encoded(symbols))
     65         (self.root / "api/TeraKitBindings.symbols.json").write_bytes(
     66             provenance.encoded(
     67                 {
     68                     "schema": "radroots.swift-api-snapshot.v1",
     69                     "module": {"name": artifacts.MODULE},
     70                     "symbols": [{"synthetic": True}],
     71                 }
     72             )
     73         )
     74         (self.root / artifacts.MANIFEST).write_bytes(
     75             provenance.encoded(artifacts.manifest(self.root, self.records))
     76         )
     77 
     78     def test_framework_metadata_is_independent_of_xcode_library_order(self) -> None:
     79         path = self.root / artifacts.FRAMEWORK / "Info.plist"
     80         original = plistlib.loads(path.read_bytes())
     81         builder.canonicalize_framework_info(path)
     82         expected = path.read_bytes()
     83         original["AvailableLibraries"].reverse()
     84         path.write_bytes(plistlib.dumps(original, sort_keys=False))
     85         builder.canonicalize_framework_info(path)
     86         self.assertEqual(path.read_bytes(), expected)
     87 
     88     def install_headers(self) -> None:
     89         header = b"void ffi_tera_ffi_fixture(void);\n"
     90         modulemap = b'module TeraFFI { header "TeraFFI.h" export * }\n'
     91         for prefix in (
     92             "headers",
     93             "TeraFFI.xcframework/ios-arm64/Headers",
     94             "TeraFFI.xcframework/ios-arm64-simulator/Headers",
     95         ):
     96             (self.root / prefix / "TeraFFI.h").write_bytes(header)
     97             (self.root / prefix / "module.modulemap").write_bytes(modulemap)
     98         (self.root / "generated/TeraFFI.h").write_bytes(header)
     99         (self.root / "generated/TeraFFI.modulemap").write_bytes(modulemap)
    100         (self.root / "generated/TeraKitBindings.swift").write_text("import TeraFFI\n")
    101 
    102     def install_framework_info(self) -> None:
    103         libraries = []
    104         for identifier, variant in (
    105             ("ios-arm64", None),
    106             ("ios-arm64-simulator", "simulator"),
    107         ):
    108             record = {
    109                 "LibraryIdentifier": identifier,
    110                 "SupportedArchitectures": ["arm64"],
    111                 "SupportedPlatform": "ios",
    112                 "LibraryPath": "libtera_ffi.a",
    113                 "HeadersPath": "Headers",
    114             }
    115             if variant:
    116                 record["SupportedPlatformVariant"] = variant
    117             libraries.append(record)
    118         (self.root / "TeraFFI.xcframework/Info.plist").write_bytes(
    119             plistlib.dumps({"AvailableLibraries": libraries})
    120         )
    121 
    122     def test_consistent_fixture_is_checked_without_claiming_build_execution(
    123         self,
    124     ) -> None:
    125         result = artifacts.check(self.root, self.records)
    126         self.assertEqual(result["disposition"], "local_candidate_not_installed")
    127         self.assertEqual(len(result["files"]), len(artifacts.expected_paths()))
    128 
    129     def test_tampered_or_missing_built_library_is_rejected(self) -> None:
    130         path = self.root / "native/aarch64-apple-ios/libtera_ffi.a"
    131         path.write_bytes(b"changed synthetic bytes")
    132         with self.assertRaisesRegex(source.ProvenanceError, "differs from its built"):
    133             artifacts.check(self.root, self.records)
    134         path.unlink()
    135         with self.assertRaisesRegex(source.ProvenanceError, "missing"):
    136             artifacts.check(self.root, self.records)
    137 
    138     def test_complete_notice_is_required_and_source_bound(self) -> None:
    139         path = self.root / notices.ARTIFACT_PATH
    140         original = path.read_bytes()
    141         path.write_bytes(original[:-1])
    142         with self.assertRaisesRegex(source.ProvenanceError, "material differs"):
    143             artifacts.check(self.root, self.records)
    144         path.unlink()
    145         with self.assertRaisesRegex(source.ProvenanceError, "unavailable"):
    146             artifacts.check(self.root, self.records)
    147 
    148     def test_notice_cannot_be_rebound_to_another_target_or_provider(self) -> None:
    149         changed = copy.deepcopy(self.records)
    150         changed[artifacts.TARGETS[1]]["redistribution"]["revision"] = "c" * 40
    151         with self.assertRaisesRegex(source.ProvenanceError, "redistribution tuples"):
    152             artifacts.check(self.root, changed)
    153         changed = copy.deepcopy(self.records)
    154         changed[artifacts.TARGETS[0]]["foundation"]["revision"] = "c" * 40
    155         with self.assertRaisesRegex(contract.PackageContractError, "producer identity"):
    156             artifacts.check(self.root, changed)
    157 
    158     def test_mismatched_generated_and_packaged_headers_are_rejected(self) -> None:
    159         (self.root / "headers/TeraFFI.h").write_text("void other(void);\n")
    160         with self.assertRaisesRegex(source.ProvenanceError, "header differs"):
    161             artifacts.check(self.root, self.records)
    162 
    163     def test_target_source_tuple_mismatch_is_rejected(self) -> None:
    164         records = copy.deepcopy(self.records)
    165         records[artifacts.TARGETS[0]]["build"]["target"] = artifacts.TARGETS[1]
    166         with self.assertRaisesRegex(source.ProvenanceError, "tuples disagree"):
    167             artifacts.check(self.root, records)
    168 
    169     def test_complete_tuple_candidates_coexist_without_cache_cleaning(self) -> None:
    170         original = builder.candidate_path(self.root, self.records)
    171         self.assertEqual(original, builder.candidate_path(self.root, self.records))
    172         original.mkdir(parents=True)
    173         (original / "preserved").write_text("old native tuple")
    174         for section in ("build", "generator"):
    175             changed = copy.deepcopy(self.records)
    176             changed[artifacts.TARGETS[0]].setdefault(section, {})["native"] = {
    177                 "sdk": "changed native tuple"
    178             }
    179             with self.subTest(section=section):
    180                 candidate = builder.candidate_path(self.root, changed)
    181                 self.assertNotEqual(candidate, original)
    182                 self.assertEqual(
    183                     changed[artifacts.TARGETS[0]]["source"]["tree"],
    184                     self.records[artifacts.TARGETS[0]]["source"]["tree"],
    185                 )
    186                 candidate.mkdir()
    187                 self.assertEqual(
    188                     (original / "preserved").read_text(), "old native tuple"
    189                 )
    190 
    191     def test_cross_target_abi_mismatch_is_rejected(self) -> None:
    192         symbols = contract._read_json(self.root / "abi_symbols.json")
    193         symbols[artifacts.TARGETS[0]] = ["ffi_tera_ffi_other"]
    194         (self.root / "abi_symbols.json").write_bytes(provenance.encoded(symbols))
    195         with self.assertRaisesRegex(source.ProvenanceError, "ABI symbols differ"):
    196             artifacts.check(self.root, self.records)
    197 
    198     def test_extra_files_including_nested_provenance_are_rejected(self) -> None:
    199         (self.root / "headers/provenance.json").write_text("{}\n")
    200         with self.assertRaisesRegex(source.ProvenanceError, "inventory differs"):
    201             artifacts.check(self.root, self.records)
    202 
    203     def test_symlink_cannot_supply_artifact_bytes(self) -> None:
    204         path = self.root / "native/aarch64-apple-ios/libtera_ffi.a"
    205         path.unlink()
    206         path.symlink_to(self.root / "native/aarch64-apple-ios-sim/libtera_ffi.a")
    207         with self.assertRaisesRegex(source.ProvenanceError, "symlink"):
    208             artifacts.check(self.root, self.records)
    209 
    210     def test_build_environment_applies_recorded_flags_and_foundation_identity(
    211         self,
    212     ) -> None:
    213         config = source.producer_contract(SCRIPTS.parent)
    214         with patch.dict(os.environ, {"TERA_CONSUMER_REVISION": "f" * 40}):
    215             environment = builder.build_environment(SCRIPTS.parent, self.root, config)
    216         self.assertNotIn("TERA_CONSUMER_REVISION", environment)
    217         self.assertIn("=/tera", environment["CARGO_ENCODED_RUSTFLAGS"])
    218         self.assertEqual(
    219             environment["RADROOTS_LIB_REVISION"],
    220             contract._read_toml(SCRIPTS.parent / "radroots.lib.source-lock.v1.toml")[
    221                 "revision"
    222             ],
    223         )
    224         self.assertEqual(
    225             environment["SOURCE_DATE_EPOCH"], str(config["build"]["source_date_epoch"])
    226         )
    227 
    228     def test_abi_symbol_reader_digest_drift_rejects_before_and_after_use(self) -> None:
    229         import ffi_native as native
    230 
    231         reader = self.root / "reader"
    232         original = b"synthetic symbol reader"
    233         reader.write_bytes(original)
    234         records = copy.deepcopy(self.records)
    235         for record in records.values():
    236             record["build"].update(
    237                 {"symbol_reader_identity": native.file_identity(reader), "native": {}}
    238             )
    239             record["generator"] = {"native": {}}
    240 
    241         def changed_after_run(*args):
    242             reader.write_bytes(b"changed reader")
    243             log = self.root / "symbols.txt"
    244             log.write_text("_ffi_tera_ffi_fixture\n")
    245             return log
    246 
    247         with patch.object(provenance, "symbol_reader", return_value=reader):
    248             reader.write_bytes(b"changed reader")
    249             with patch.object(builder, "run_native") as run:
    250                 with self.assertRaisesRegex(
    251                     source.ProvenanceError, "reader drift before"
    252                 ):
    253                     builder.record_abi(
    254                         SCRIPTS.parent, self.root, self.root, {}, records
    255                     )
    256                 run.assert_not_called()
    257             reader.write_bytes(original)
    258             with patch.object(builder, "run_native", side_effect=changed_after_run):
    259                 with self.assertRaisesRegex(
    260                     source.ProvenanceError, "reader drift after"
    261                 ):
    262                     builder.record_abi(
    263                         SCRIPTS.parent, self.root, self.root, {}, records
    264                     )
    265 
    266 
    267 if __name__ == "__main__":
    268     unittest.main()