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