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