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