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_kotlin_smoke.py (13269B)


      1 from __future__ import annotations
      2 
      3 import contextlib
      4 import copy
      5 import io
      6 import os
      7 import sys
      8 import tempfile
      9 import unittest
     10 import xml.etree.ElementTree as ET
     11 from pathlib import Path
     12 from unittest.mock import patch
     13 
     14 SCRIPTS = Path(__file__).resolve().parent
     15 if str(SCRIPTS) not in sys.path:
     16     sys.path.insert(0, str(SCRIPTS))
     17 
     18 import ffi_artifacts as artifacts  # noqa: E402
     19 import ffi_build as builder  # noqa: E402
     20 import ffi_provenance as provenance  # noqa: E402
     21 import ffi_source as source  # noqa: E402
     22 import kotlin_smoke as smoke  # noqa: E402
     23 import package_contract as contract  # noqa: E402
     24 
     25 
     26 class KotlinSmokeTests(unittest.TestCase):
     27     def setUp(self) -> None:
     28         temporary = tempfile.TemporaryDirectory()
     29         self.addCleanup(temporary.cleanup)
     30         self.root = Path(temporary.name).resolve()
     31         self.path = self.root / "TEST-smoke.xml"
     32         self.suite = ET.Element(
     33             "testsuite", tests="19", failures="0", errors="0", skipped="0"
     34         )
     35         for identity in sorted(smoke.EXPECTED_CASES):
     36             name, case = identity.split("/")
     37             ET.SubElement(self.suite, "testcase", classname=name, name=case)
     38 
     39     def write(self) -> None:
     40         self.path.write_bytes(ET.tostring(self.suite))
     41 
     42     def test_only_complete_executed_inventory_is_green(self) -> None:
     43         self.write()
     44         result = smoke.test_results(self.root)
     45         self.assertEqual(result["passed"], 19)
     46         self.assertEqual((result["failed"], result["skipped"]), (0, 0))
     47 
     48     def test_empty_and_missing_results_cannot_pass(self) -> None:
     49         with self.assertRaises(source.ProvenanceError):
     50             smoke.test_results(self.root)
     51         self.suite.clear()
     52         self.suite.attrib.update(tests="0", failures="0", errors="0", skipped="0")
     53         self.write()
     54         with self.assertRaises(source.ProvenanceError):
     55             smoke.test_results(self.root)
     56 
     57     def test_failed_skipped_or_error_results_cannot_pass(self) -> None:
     58         for key in ("failures", "errors", "skipped"):
     59             with self.subTest(key=key):
     60                 self.suite.set(key, "1")
     61                 self.write()
     62                 with self.assertRaises(source.ProvenanceError):
     63                     smoke.test_results(self.root)
     64                 self.suite.set(key, "0")
     65 
     66     def test_case_failures_cannot_hide_behind_zero_suite_totals(self) -> None:
     67         ET.SubElement(self.suite.find("testcase"), "failure")
     68         self.write()
     69         with self.assertRaises(source.ProvenanceError):
     70             smoke.test_results(self.root)
     71 
     72     def test_renamed_duplicate_or_missing_cases_cannot_pass(self) -> None:
     73         cases = self.suite.findall("testcase")
     74         cases[-1].attrib = cases[0].attrib.copy()
     75         self.write()
     76         with self.assertRaises(source.ProvenanceError):
     77             smoke.test_results(self.root)
     78         self.suite.remove(cases[-1])
     79         self.suite.set("tests", "15")
     80         self.write()
     81         with self.assertRaises(source.ProvenanceError):
     82             smoke.test_results(self.root)
     83 
     84     def test_result_symlinks_are_rejected(self) -> None:
     85         self.write()
     86         alias = self.root / "TEST-alias.xml"
     87         alias.symlink_to(self.path)
     88         with self.assertRaises(source.ProvenanceError):
     89             smoke.test_results(self.root)
     90 
     91     def test_output_requires_extbuild_and_cannot_enter_source(self) -> None:
     92         with patch.dict(os.environ, {}, clear=True):
     93             with self.assertRaises(source.ProvenanceError):
     94                 smoke.output_root(self.root)
     95         with patch.dict(
     96             os.environ,
     97             {"EXT_BUILD_RUN_ACTIVE": "1", "EXT_BUILD_PROJECT_DIR": str(self.root)},
     98         ):
     99             with self.assertRaises(source.ProvenanceError):
    100                 smoke.output_root(self.root)
    101 
    102 
    103 class KotlinNativeInputTests(unittest.TestCase):
    104     """Real cache/record bytes with only installed admission substituted."""
    105 
    106     def setUp(self) -> None:
    107         temporary = tempfile.TemporaryDirectory()
    108         self.addCleanup(temporary.cleanup)
    109         self.directory = Path(temporary.name).resolve()
    110         self.root = self.directory / "capsule"
    111         self.project = self.directory / "external"
    112         self.output = self.project / "target/kotlin_smoke"
    113         self.records = {
    114             target: {
    115                 "repository": "https://example.invalid/tera",
    116                 "source": {"tree": "a" * 40, "files": []},
    117                 "foundation": {"fixture": "synthetic admitted source tuple"},
    118                 "build": {"target": target, "native": {"sdk_sha256": "b" * 64}},
    119                 "generator": {"native": {"sdk_sha256": "c" * 64}},
    120             }
    121             for target in artifacts.TARGETS
    122         }
    123         self.write_records(self.records)
    124         self.base, self.manifest = self.write_candidate(
    125             self.records, b"current synthetic library; not executable\n"
    126         )
    127 
    128     def write_records(self, records: dict) -> None:
    129         directory = self.root / "TeraFFI/source"
    130         directory.mkdir(parents=True, exist_ok=True)
    131         for target, record in records.items():
    132             (directory / f"{target}.json").write_bytes(provenance.encoded(record))
    133 
    134     def write_candidate(self, records: dict, contents: bytes) -> tuple[Path, dict]:
    135         base = builder.candidate_path(self.project, records)
    136         library = base / smoke.LIBRARY
    137         library.parent.mkdir(parents=True, exist_ok=True)
    138         library.write_bytes(contents)
    139         files = [artifacts.file_record(base, smoke.LIBRARY)]
    140         for target, record in records.items():
    141             relative = f"source/{target}.json"
    142             path = base / relative
    143             path.parent.mkdir(exist_ok=True)
    144             path.write_bytes(provenance.encoded(record))
    145             files.append(artifacts.file_record(base, relative))
    146         return base, {
    147             "candidate": {
    148                 "source": {
    149                     "repository": records[smoke.HOST]["repository"],
    150                     "tree": records[smoke.HOST]["source"]["tree"],
    151                 },
    152                 "files": files,
    153             }
    154         }
    155 
    156     def native_input(
    157         self, manifest: dict | None = None, *, after_admission: dict | None = None
    158     ) -> tuple[dict, Path, dict]:
    159         def admit(root: Path) -> dict:
    160             self.assertEqual(root, self.root)
    161             if after_admission is not None:
    162                 self.write_records(after_admission)
    163             return manifest or self.manifest
    164 
    165         with (
    166             patch.object(smoke.installed, "check", side_effect=admit) as admission,
    167             patch.object(
    168                 provenance, "capture", side_effect=AssertionError("ambient recapture")
    169             ),
    170             patch.object(
    171                 builder,
    172                 "capture_sources",
    173                 side_effect=AssertionError("ambient recapture"),
    174             ),
    175         ):
    176             result = smoke.native_input(self.root, self.output)
    177         admission.assert_called_once_with(self.root)
    178         return result
    179 
    180     def test_current_tuple_wins_over_preserved_legacy_and_old_tuple(self) -> None:
    181         legacy = self.project / "target/tera_ffi/candidates" / ("a" * 40)
    182         library = legacy / smoke.LIBRARY
    183         library.parent.mkdir(parents=True)
    184         library.write_bytes(b"preserved legacy library")
    185         previous = copy.deepcopy(self.records)
    186         previous[smoke.HOST]["build"]["native"]["sdk_sha256"] = "d" * 64
    187         old_base, _ = self.write_candidate(previous, b"preserved old tuple library")
    188         candidate, native, record = self.native_input()
    189         self.assertEqual(candidate, self.manifest["candidate"])
    190         self.assertEqual(native, self.base / smoke.LIBRARY)
    191         self.assertIn(record, candidate["files"])
    192         self.assertEqual(library.read_bytes(), b"preserved legacy library")
    193         self.assertEqual(
    194             (old_base / smoke.LIBRARY).read_bytes(), b"preserved old tuple library"
    195         )
    196 
    197     def test_every_target_build_and_generator_tuple_changes_cache_identity(
    198         self,
    199     ) -> None:
    200         original = (self.base / smoke.LIBRARY).read_bytes()
    201         for target in artifacts.TARGETS:
    202             for section in ("build", "generator"):
    203                 with self.subTest(target=target, section=section):
    204                     changed = copy.deepcopy(self.records)
    205                     changed[target][section]["native"]["sdk_sha256"] = "e" * 64
    206                     self.write_records(changed)
    207                     base, manifest = self.write_candidate(
    208                         changed, f"synthetic {target} {section} tuple".encode()
    209                     )
    210                     self.assertNotEqual(base, self.base)
    211                     self.assertEqual(
    212                         changed[target]["source"], self.records[target]["source"]
    213                     )
    214                     _, native, _ = self.native_input(manifest)
    215                     self.assertEqual(native, base / smoke.LIBRARY)
    216                     self.assertEqual((self.base / smoke.LIBRARY).read_bytes(), original)
    217 
    218     def test_record_change_after_installed_check_cannot_select_another_native_tuple(
    219         self,
    220     ) -> None:
    221         contents = (self.base / smoke.LIBRARY).read_bytes()
    222         for target in artifacts.TARGETS:
    223             for section in ("build", "generator"):
    224                 with self.subTest(target=target, section=section):
    225                     changed = copy.deepcopy(self.records)
    226                     changed[target][section]["native"]["sdk_sha256"] = "f" * 64
    227                     alternate, manifest = self.write_candidate(changed, contents)
    228                     self.assertNotEqual(alternate, self.base)
    229                     self.assertEqual(
    230                         manifest["candidate"]["source"],
    231                         self.manifest["candidate"]["source"],
    232                     )
    233                     self.assertEqual(
    234                         artifacts.file_record(alternate, smoke.LIBRARY),
    235                         artifacts.file_record(self.base, smoke.LIBRARY),
    236                     )
    237                     with self.assertRaisesRegex(
    238                         source.ProvenanceError, "source record does not match"
    239                     ):
    240                         self.native_input(after_admission=changed)
    241 
    242     def test_each_missing_malformed_or_symlink_record_rejects_without_fallback(
    243         self,
    244     ) -> None:
    245         legacy = self.project / "target/tera_ffi/candidates" / ("a" * 40)
    246         library = legacy / smoke.LIBRARY
    247         library.parent.mkdir(parents=True)
    248         library.write_bytes((self.base / smoke.LIBRARY).read_bytes())
    249         for target in artifacts.TARGETS:
    250             path = self.root / "TeraFFI/source" / f"{target}.json"
    251             original = path.read_bytes()
    252             for kind in ("missing", "malformed", "symlink"):
    253                 with self.subTest(target=target, kind=kind):
    254                     path.unlink()
    255                     if kind == "malformed":
    256                         path.write_bytes(b"{malformed synthetic record")
    257                     elif kind == "symlink":
    258                         actual = self.directory / "synthetic-record.json"
    259                         actual.write_bytes(original)
    260                         path.symlink_to(actual)
    261                     try:
    262                         with self.assertRaises(contract.PackageContractError):
    263                             self.native_input()
    264                     finally:
    265                         if path.exists() or path.is_symlink():
    266                             path.unlink()
    267                         path.write_bytes(original)
    268 
    269     def test_wrong_native_bytes_are_rejected(self) -> None:
    270         (self.base / smoke.LIBRARY).write_bytes(b"different native tuple bytes")
    271         with self.assertRaisesRegex(source.ProvenanceError, "does not match"):
    272             self.native_input()
    273 
    274     def test_candidate_symlink_is_rejected(self) -> None:
    275         destination = self.base.with_name("preserved-synthetic-candidate")
    276         self.base.rename(destination)
    277         self.base.symlink_to(destination, target_is_directory=True)
    278         with self.assertRaisesRegex(
    279             source.ProvenanceError, "candidate contains a symlink"
    280         ):
    281             self.native_input()
    282 
    283     def test_library_symlink_is_rejected(self) -> None:
    284         library = self.base / smoke.LIBRARY
    285         actual = self.directory / "synthetic-library"
    286         library.rename(actual)
    287         library.symlink_to(actual)
    288         with self.assertRaisesRegex(source.ProvenanceError, "path contains a symlink"):
    289             self.native_input()
    290 
    291     def test_contract_rejection_returns_safe_cli_failure(self) -> None:
    292         output = io.StringIO()
    293         with (
    294             patch.object(sys, "argv", ["kotlin_smoke.py", "verify"]),
    295             patch.object(
    296                 smoke,
    297                 "run",
    298                 side_effect=contract.PackageContractError(
    299                     "required JSON contract is malformed"
    300                 ),
    301             ),
    302             contextlib.redirect_stderr(output),
    303         ):
    304             self.assertEqual(smoke.main(), 1)
    305         self.assertEqual(
    306             output.getvalue(),
    307             "Kotlin binding smoke failed: required JSON contract is malformed\n",
    308         )
    309 
    310 
    311 if __name__ == "__main__":
    312     unittest.main()