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_package_contract.py (12319B)


      1 from __future__ import annotations
      2 
      3 import copy
      4 import hashlib
      5 import json
      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 package_contract as contract  # noqa: E402
     18 
     19 
     20 class PackageContractTests(unittest.TestCase):
     21     def test_cargo_metadata_has_separate_bounded_inspection(self) -> None:
     22         root = SCRIPTS.parent
     23 
     24         def emit(payload: bytes):
     25             def run(*args, **kwargs):
     26                 del args
     27                 kwargs["stdout"].write(payload)
     28                 return contract.subprocess.CompletedProcess([], 0)
     29 
     30             return run
     31 
     32         accepted = b'{"workspace_members":[]}' + b" " * contract.MAX_CONTRACT_BYTES
     33         with patch.object(contract.subprocess, "run", side_effect=emit(accepted)):
     34             self.assertEqual(
     35                 contract._cargo_workspace(root, resolved=True),
     36                 {"workspace_members": []},
     37             )
     38         for payload in (b"invalid", b" " * (contract.MAX_CARGO_METADATA_BYTES + 1)):
     39             with (
     40                 self.subTest(size=len(payload)),
     41                 patch.object(contract.subprocess, "run", side_effect=emit(payload)),
     42                 self.assertRaises(contract.PackageContractError),
     43             ):
     44                 contract._cargo_workspace(root, resolved=True)
     45 
     46     def workspace(self, root: Path, member: str = "core/crates/tera_core") -> dict:
     47         return {
     48             "workspace_root": str(root),
     49             "workspace_members": ["app"],
     50             "packages": [
     51                 {
     52                     "id": "app",
     53                     "manifest_path": str(root / member / "Cargo.toml"),
     54                     "dependencies": [],
     55                 }
     56             ],
     57         }
     58 
     59     def test_application_workspace_accepts_owned_rust(self) -> None:
     60         root = SCRIPTS.parent.resolve()
     61         for member in ("core/crates/tera_core", "core/crates/tera_ffi"):
     62             contract._validate_app_workspace(self.workspace(root, member), root)
     63 
     64     def test_application_workspace_rejects_hidden_sibling_dependency(self) -> None:
     65         root = SCRIPTS.parent.resolve()
     66         document = self.workspace(root)
     67         document["packages"][0]["dependencies"] = [
     68             {"path": str(root.parent / "lib/crates/storage")}
     69         ]
     70         with self.assertRaisesRegex(contract.PackageContractError, "escapes"):
     71             contract._validate_app_workspace(document, root)
     72 
     73     def test_mobile_defaults_exclude_wasm_and_execute_owned_runtime(self) -> None:
     74         root = SCRIPTS.parent.resolve()
     75         document = self.workspace(root)
     76         names = ("tera_core", "tera_ffi", "tera_wasm")
     77         document["packages"] = [
     78             {
     79                 "id": name,
     80                 "manifest_path": str(root / "core/crates" / name / "Cargo.toml"),
     81                 "dependencies": [],
     82             }
     83             for name in names
     84         ]
     85         document["workspace_members"] = list(names)
     86         document["workspace_default_members"] = ["tera_core", "tera_ffi"]
     87         contract._validate_app_workspace(document, root)
     88         for defaults in (None, list(names), [], ["tera_core"], ["tera_ffi"]):
     89             with self.subTest(defaults=defaults):
     90                 document["workspace_default_members"] = defaults
     91                 with self.assertRaisesRegex(
     92                     contract.PackageContractError, "mobile defaults"
     93                 ):
     94                     contract._validate_app_workspace(document, root)
     95 
     96     def test_application_workspace_rejects_foreign_member_root(self) -> None:
     97         root = SCRIPTS.parent.resolve()
     98         with self.assertRaisesRegex(contract.PackageContractError, "owned root"):
     99             contract._validate_app_workspace(
    100                 self.workspace(root, "crates/source_lock"), root
    101             )
    102 
    103     def test_application_workspace_rejects_implicit_parent_workspace(self) -> None:
    104         root = SCRIPTS.parent.resolve()
    105         document = self.workspace(root)
    106         document["workspace_root"] = str(root.parent)
    107         with self.assertRaisesRegex(contract.PackageContractError, "workspace root"):
    108             contract._validate_app_workspace(document, root)
    109 
    110     def test_application_workspace_rejects_symlink_escape(self) -> None:
    111         with tempfile.TemporaryDirectory() as directory:
    112             root = Path(directory).resolve()
    113             (root / "core").symlink_to(root.parent, target_is_directory=True)
    114             with self.assertRaisesRegex(contract.PackageContractError, "escapes"):
    115                 contract._validate_app_workspace(self.workspace(root), root)
    116 
    117     def test_forbidden_roots_still_rejected(self) -> None:
    118         with tempfile.TemporaryDirectory() as directory:
    119             root = Path(directory)
    120             for name in ("docs", ".github", ".act"):
    121                 with self.subTest(name=name):
    122                     forbidden = root / name
    123                     forbidden.mkdir()
    124                     with self.assertRaisesRegex(
    125                         contract.PackageContractError, "forbidden"
    126                     ):
    127                         contract._verify_repository_layout(root)
    128                     forbidden.rmdir()
    129 
    130     def test_current_package_contract_is_structurally_exact(self) -> None:
    131         version, revision = contract.verify(SCRIPTS.parent)
    132         self.assertEqual(version, "0.1.0-alpha")
    133         self.assertRegex(revision, r"^[0-9a-f]{40}$")
    134 
    135     def test_compatibility_baseline_rejects_bundle_or_custody_rename(self) -> None:
    136         root = SCRIPTS.parent
    137         base = contract.parse_xcconfig_assignments(
    138             (root / "Tera/Config/Base.xcconfig").read_text()
    139         )
    140         debug = contract.parse_xcconfig_assignments(
    141             (root / "Tera/Config/Debug.xcconfig").read_text()
    142         )
    143         for key in (
    144             "PRODUCT_BUNDLE_IDENTIFIER",
    145             "TERA_IOS_KEYCHAIN_SERVICE_PREFIX",
    146         ):
    147             with self.subTest(key=key):
    148                 changed = {**debug, key: "org.tera.accidental-rename"}
    149                 with self.assertRaisesRegex(
    150                     contract.PackageContractError, "identity compatibility"
    151                 ):
    152                     contract._verify_installation_compatibility(root, base, changed)
    153 
    154     def test_comment_token_does_not_define_xcconfig_field(self) -> None:
    155         values = contract.parse_xcconfig_assignments(
    156             "// TERA_IOS_RUNTIME_MODE = production\n"
    157         )
    158         self.assertNotIn("TERA_IOS_RUNTIME_MODE", values)
    159 
    160     def test_dead_metadata_text_does_not_define_cargo_repository(self) -> None:
    161         document = {
    162             "workspace": {
    163                 "package": {},
    164                 "metadata": {
    165                     "example": 'repository = "https://github.com/radrootslabs/tera"'
    166                 },
    167             }
    168         }
    169         package = contract._mapping(document["workspace"]["package"], "package")
    170         with self.assertRaisesRegex(contract.PackageContractError, "differs"):
    171             contract._exact(
    172                 package.get("repository"),
    173                 "https://github.com/radrootslabs/tera",
    174                 "Cargo repository",
    175             )
    176 
    177     def test_plist_value_token_does_not_define_required_key(self) -> None:
    178         document = plistlib.loads(
    179             plistlib.dumps(
    180                 {
    181                     "Comment": (
    182                         "NSCameraUsageDescription NSFaceIDUsageDescription "
    183                         "NSLocalNetworkUsageDescription"
    184                     ),
    185                     "NSAppTransportSecurity": {"NSAllowsLocalNetworking": True},
    186                 }
    187             )
    188         )
    189         with self.assertRaisesRegex(contract.PackageContractError, "purpose"):
    190             contract._validate_app_plist(document)
    191 
    192     def test_duplicate_xcconfig_assignment_is_rejected(self) -> None:
    193         with self.assertRaisesRegex(contract.PackageContractError, "duplicated"):
    194             contract.parse_xcconfig_assignments("FIELD = one\nFIELD = two\n")
    195 
    196     def test_package_lock_rejects_pin_drift(self) -> None:
    197         document = json.loads(
    198             (SCRIPTS.parent / "Package.resolved").read_text(encoding="utf-8")
    199         )
    200         apple_revision = next(
    201             pin["state"]["revision"]
    202             for pin in document["pins"]
    203             if pin["location"] == contract.APPLE_KIT_REMOTE
    204         )
    205         drifted = copy.deepcopy(document)
    206         drifted["pins"][0]["state"]["revision"] = "f" * 40
    207         with self.assertRaises(contract.PackageContractError):
    208             contract.validate_resolved(drifted, apple_revision)
    209 
    210     def test_project_package_comment_does_not_define_entry(self) -> None:
    211         with self.assertRaisesRegex(contract.PackageContractError, "absent"):
    212             contract.parse_project_package(
    213                 "packages:\n#   RadrootsKit:\n#     url: "
    214                 + contract.APPLE_KIT_REMOTE
    215                 + "\n",
    216                 "RadrootsKit",
    217             )
    218 
    219     def test_project_package_dead_section_does_not_define_entry(self) -> None:
    220         with self.assertRaisesRegex(contract.PackageContractError, "absent"):
    221             contract.parse_project_package(
    222                 "packages:\n  TeraApp:\n    path: .\n"
    223                 "targets:\n  RadrootsKit:\n    url: "
    224                 + contract.APPLE_KIT_REMOTE
    225                 + "\n",
    226                 "RadrootsKit",
    227             )
    228 
    229 
    230 class ProducerEpochTests(unittest.TestCase):
    231     def setUp(self) -> None:
    232         temporary = tempfile.TemporaryDirectory()
    233         self.addCleanup(temporary.cleanup)
    234         self.root = Path(temporary.name)
    235         (self.root / "TeraFFI").mkdir()
    236         self.foundation = {
    237             "repository": contract.LIB_REMOTE,
    238             "revision": "a" * 40,
    239             "version": "0.1.0",
    240         }
    241         self.manifest = b'{"synthetic": "installed manifest"}\n'
    242         (self.root / "TeraFFI/provenance.json").write_bytes(self.manifest)
    243 
    244     def fixture(self, canonical: object, installed: object) -> None:
    245         field = (
    246             ""
    247             if canonical is None
    248             else f"source_date_epoch = {json.dumps(canonical)}\n"
    249         )
    250         (self.root / "TeraFFI/producer.toml").write_text("[build]\n" + field)
    251         values = {
    252             "schema": "tera.installed-source.v2",
    253             "repository": contract._read_toml(SCRIPTS.parent / "TeraFFI/producer.toml")[
    254                 "repository"
    255             ],
    256             "source_tree": "b" * 40,
    257             "manifest_sha256": hashlib.sha256(self.manifest).hexdigest(),
    258         }
    259         if installed is not None:
    260             values["source_date_epoch"] = installed
    261         text = "".join(
    262             f"{key} = {json.dumps(value)}\n" for key, value in values.items()
    263         )
    264         text += "\n[foundation]\n" + "".join(
    265             f"{key} = {json.dumps(value)}\n" for key, value in self.foundation.items()
    266         )
    267         (self.root / "TeraFFI/source.lock").write_text(text)
    268 
    269     def test_installed_epoch_matches_coherent_canonical_producer_update(self) -> None:
    270         for epoch in (1787871027, 12345, 1):
    271             with self.subTest(epoch=epoch):
    272                 self.fixture(epoch, epoch)
    273                 contract._verify_owned_source_lock(self.root, self.foundation)
    274 
    275     def test_canonical_epoch_missing_and_invalid_values_reject(self) -> None:
    276         for epoch in (None, "1787871027", 0, -1, True):
    277             with self.subTest(epoch=epoch):
    278                 self.fixture(epoch, 1787871027)
    279                 with self.assertRaises(contract.PackageContractError):
    280                     contract._verify_owned_source_lock(self.root, self.foundation)
    281 
    282     def test_installed_epoch_mismatch_and_invalid_values_reject(self) -> None:
    283         for canonical, epoch in (
    284             (1787871027, 12345),
    285             (1787871027, None),
    286             (1787871027, "1787871027"),
    287             (1787871027, 0),
    288             (1787871027, -1),
    289             (1, True),
    290         ):
    291             with self.subTest(canonical=canonical, epoch=epoch):
    292                 self.fixture(canonical, epoch)
    293                 with self.assertRaises(contract.PackageContractError):
    294                     contract._verify_owned_source_lock(self.root, self.foundation)
    295 
    296 
    297 if __name__ == "__main__":
    298     unittest.main()