check_dependency_lock_self_test.py (30170B)
1 """Isolated synthetic regression cases for the dependency lock checker. 2 3 Invoke through ``check_dependency_lock.py --mode baseline --self-test`` so the 4 existing locked script supplies PyYAML. Fixture pins are independent literal 5 oracles. Example archive URLs/digests are test data, never downloaded artifacts. 6 All filesystem fixtures belong to temporary directories and no subprocess runs. 7 """ 8 9 from __future__ import annotations 10 11 from contextlib import redirect_stderr, redirect_stdout 12 from copy import deepcopy 13 from io import StringIO 14 import json 15 from pathlib import Path 16 import sys 17 from tempfile import TemporaryDirectory 18 import unittest 19 20 import yaml 21 22 23 # Keep these acceptance inputs independent from the checker policy constants. 24 PLATFORMS = ("linux-64", "osx-arm64") 25 PINS = { 26 "json": ( 27 "https://github.com/triesap/mojo_json", 28 "56025d73631054d7803143fa5e68c5de578e33f5", 29 ), 30 "morph": ( 31 "https://github.com/triesap/mojo_morph", 32 "ea73f909990f3d3f5d12b786fec2f09e1e09f462", 33 ), 34 "flare": ( 35 "https://github.com/triesap/mojo_flare", 36 "14aa338d8c4f352ebb2d590cddfde0bde5ea1971", 37 ), 38 } 39 SECRET_MARKER = "SYNTHETIC_CREDENTIAL_MUST_NOT_APPEAR" 40 41 42 def archive(name: str, platform: str, version: str = "1.0.0b1") -> dict: 43 return { 44 "conda": f"https://packages.example.invalid/channel/{platform}/{name}-{version}-test_0.conda", 45 "sha256": "a" * 64, 46 "md5": "b" * 32, 47 "depends": [], 48 } 49 50 51 def reference(record: dict) -> dict: 52 kind = "conda" if "conda" in record else "conda_source" 53 return {kind: record[kind]} 54 55 56 def fixture() -> tuple[dict, dict]: 57 manifest = { 58 "workspace": { 59 "name": "dependency_lock_fixture", 60 "version": "0.0.0", 61 "description": "Synthetic lock checker fixture", 62 "authors": ["Fixture Authors"], 63 "channels": ["https://packages.example.invalid/channel/"], 64 "platforms": ["linux-64", "osx-arm64"], 65 "preview": ["pixi-build"], 66 }, 67 "dependencies": { 68 "mojo": "==1.0.0b1", 69 **{name: {"git": repo + ".git", "rev": rev} for name, (repo, rev) in PINS.items()}, 70 }, 71 "tasks": {"fixture": "echo fixture"}, 72 } 73 lock = { 74 "version": 7, 75 "platforms": [{"name": platform} for platform in PLATFORMS], 76 "environments": { 77 "default": { 78 "channels": [{"url": "https://packages.example.invalid/channel/"}], 79 "packages": {platform: [] for platform in PLATFORMS}, 80 } 81 }, 82 "packages": [], 83 } 84 python = archive("mojo-python", "noarch") 85 python["noarch"] = "python" 86 lock["packages"].append(python) 87 for platform_index, platform in enumerate(PLATFORMS): 88 selected = lock["environments"]["default"]["packages"][platform] 89 mojo = archive("mojo", platform) 90 mojo["depends"] = ["mojo-compiler ==1.0.0b1"] 91 compiler = archive("mojo-compiler", platform) 92 compiler["depends"] = ["mojo-python ==1.0.0b1"] 93 lock["packages"].extend((mojo, compiler)) 94 selected.extend(reference(record) for record in (python, mojo, compiler)) 95 for source_index, (name, (repo, rev)) in enumerate(PINS.items(), start=1): 96 variant = f"{source_index * 16 + platform_index:08x}" 97 record = { 98 "conda_source": f"{name}[{variant}] @ git+{repo}?rev={rev}#{rev}", 99 "version": "0.0.0", 100 "build": "test_0", 101 "subdir": platform, 102 "variants": {"target_platform": platform}, 103 "depends": ["mojo ==1.0.0b1"], 104 "build_packages": [reference(compiler)], 105 "host_packages": [reference(python), reference(mojo)], 106 } 107 lock["packages"].append(record) 108 selected.append(reference(record)) 109 native_uuid = archive("libuuid", "linux-64", "2.42") 110 lock["packages"].append(native_uuid) 111 lock["environments"]["default"]["packages"]["linux-64"].append(reference(native_uuid)) 112 return manifest, lock 113 114 115 def toml_value(value: object) -> str: 116 if type(value) is dict: 117 return "{ " + ", ".join(f"{json.dumps(key)} = {toml_value(item)}" for key, item in value.items()) + " }" 118 if type(value) is list: 119 return "[" + ", ".join(toml_value(item) for item in value) + "]" 120 return json.dumps(value, ensure_ascii=False) 121 122 123 def manifest_text(manifest: dict) -> str: 124 lines = [f"{json.dumps(key)} = {toml_value(value)}" for key, value in manifest.items() if type(value) is not dict] 125 for section, table in manifest.items(): 126 if type(table) is dict: 127 lines.append(f"[{json.dumps(section)}]") 128 lines.extend(f"{json.dumps(key)} = {toml_value(value)}" for key, value in table.items()) 129 return "\n".join(lines) + "\n" 130 131 132 def replace_text(value: object, old: str, new: str) -> object: 133 """Change a fixture fact consistently in its records and references.""" 134 if type(value) is str: 135 return value.replace(old, new) 136 if type(value) is list: 137 return [replace_text(item, old, new) for item in value] 138 if type(value) is dict: 139 return {key: replace_text(item, old, new) for key, item in value.items()} 140 return value 141 142 143 class DependencyLockTests(unittest.TestCase): 144 checker = None 145 146 def setUp(self): 147 temporary = TemporaryDirectory(prefix="dependency-lock-test-") 148 self.addCleanup(temporary.cleanup) 149 self.root = Path(temporary.name) 150 self.manifest_path = self.root / "pixi.toml" 151 self.lock_path = self.root / "pixi.lock" 152 self.manifest, self.lock = fixture() 153 self.write_fixture() 154 155 def write_fixture(self): 156 self.manifest_path.write_text(manifest_text(self.manifest), encoding="utf-8") 157 self.lock_path.write_text(yaml.safe_dump(self.lock, sort_keys=False), encoding="utf-8") 158 159 def invoke(self, argv=None): 160 if argv is None: 161 argv = ["--mode", "baseline", "--manifest", str(self.manifest_path), "--lock", str(self.lock_path)] 162 stdout = StringIO() 163 stderr = StringIO() 164 with redirect_stdout(stdout), redirect_stderr(stderr): 165 try: 166 code = self.checker.main(argv) 167 except SystemExit as exc: 168 code = exc.code 169 self.assertIs(type(code), int, "CLI exit must be an integer") 170 output = stdout.getvalue() + stderr.getvalue() 171 self.assertNotIn("Traceback", output) 172 self.assertNotIn(SECRET_MARKER, output, "diagnostics leaked synthetic credentials or untrusted data") 173 return code, stdout.getvalue(), stderr.getvalue() 174 175 def assert_valid(self, *, rewrite=True): 176 if rewrite: 177 self.write_fixture() 178 code, stdout, stderr = self.invoke() 179 self.assertEqual(code, 0, stderr) 180 self.assertEqual(stderr, "") 181 self.assertIn("baseline PASS (YAML v7; 2 platforms; one JSON source;", stdout) 182 self.assertIn("Mojo 1.0.0b1)", stdout) 183 184 def assert_invalid(self, cause: str, *, rewrite=True): 185 if rewrite: 186 self.write_fixture() 187 code, stdout, stderr = self.invoke() 188 self.assertEqual(code, 1, (stdout, stderr)) 189 self.assertTrue(stderr.startswith("dependency lock: FAIL: "), stderr) 190 self.assertIn(cause, stderr) 191 self.assertNotIn("PASS", stdout) 192 return stderr 193 194 def selections(self, platform="linux-64"): 195 return self.lock["environments"]["default"]["packages"][platform] 196 197 def source(self, name="json", platform="linux-64"): 198 return next(record for record in self.lock["packages"] if record.get("conda_source", "").startswith(name + "[") and record["subdir"] == platform) 199 200 def binary(self, name="mojo", platform="linux-64"): 201 prefix = f"https://packages.example.invalid/channel/{platform}/{name}-" 202 return next(record for record in self.lock["packages"] if record.get("conda", "").startswith(prefix) and record["conda"].split("/")[-1].rsplit("-", 2)[0] == name) 203 204 def change_source(self, old: str, new: str): 205 self.lock = replace_text(self.lock, old, new) 206 207 def test_independent_baseline_valid(self): 208 self.assert_valid() 209 210 def test_two_json_platform_variants_are_one_source(self): 211 first = self.source(platform="linux-64")["conda_source"] 212 second = self.source(platform="osx-arm64")["conda_source"] 213 self.assertNotEqual(first, second) 214 self.assertIn("56025d73631054d7803143fa5e68c5de578e33f5", first) 215 self.assert_valid() 216 217 def test_canonical_repository_spellings(self): 218 self.manifest["dependencies"]["json"]["git"] = "https://GITHUB.COM/triesap/mojo_json.git/" 219 self.change_source("git+https://github.com/triesap/mojo_json?", "git+https://GITHUB.COM/triesap/mojo_json.git/?") 220 self.assert_valid() 221 222 def test_frozen_non_json_commit_is_manifest_driven(self): 223 old = self.manifest["dependencies"]["morph"]["rev"] 224 self.manifest["dependencies"]["morph"]["rev"] = "c" * 40 225 self.change_source(old, "c" * 40) 226 self.assert_valid() 227 228 def test_native_libuuid_is_allowed(self): 229 self.assertIn(reference(self.binary("libuuid")), self.selections()) 230 self.assert_valid() 231 232 def test_tar_bz2_package_archive_is_allowed(self): 233 old = self.binary()["conda"] 234 self.change_source(old, old.removesuffix(".conda") + ".tar.bz2") 235 self.assert_valid() 236 237 def test_duplicate_json_record_is_rejected(self): 238 extra = deepcopy(self.source()) 239 extra["conda_source"] = extra["conda_source"].replace("[00000010]", "[000000ff]") 240 self.lock["packages"].append(extra) 241 self.assert_invalid("multiple source records for one runtime package/platform") 242 243 def test_duplicate_exact_package_record_is_rejected(self): 244 self.lock["packages"].append(deepcopy(self.source())) 245 self.assert_invalid("duplicate package record") 246 247 def test_duplicate_json_selection_is_rejected(self): 248 self.selections().append(reference(self.source())) 249 self.assert_invalid("duplicate package reference") 250 251 def test_second_json_repository_is_rejected(self): 252 old = self.source()["conda_source"] 253 self.change_source(old, old.replace("triesap/mojo_json", "other/mojo_json")) 254 self.assert_invalid("Git source/revision differs from its exact manifest pin") 255 256 def test_wrong_json_lock_revision_is_rejected(self): 257 old = self.source()["conda_source"] 258 self.change_source(old, old.replace("56025d73631054d7803143fa5e68c5de578e33f5", "c" * 40)) 259 self.assert_invalid("Git source/revision differs from its exact manifest pin") 260 261 def test_joint_manifest_lock_json_revision_drift_is_rejected(self): 262 old = self.manifest["dependencies"]["json"]["rev"] 263 self.manifest["dependencies"]["json"]["rev"] = "c" * 40 264 self.change_source(old, "c" * 40) 265 self.assert_invalid("JSON revision differs from the independently defined baseline revision") 266 267 def test_joint_manifest_lock_json_repository_drift_is_rejected(self): 268 self.manifest["dependencies"]["json"]["git"] = "https://example.invalid/wrong/json.git" 269 self.change_source("https://github.com/triesap/mojo_json", "https://example.invalid/wrong/json") 270 self.assert_invalid("repository differs from the independently defined baseline source") 271 272 def test_manifest_branch_revision_is_rejected(self): 273 self.manifest["dependencies"]["json"]["rev"] = "main" 274 self.assert_invalid("Git rev must be a full lowercase 40-digit commit") 275 276 def test_manifest_branch_without_rev_is_rejected(self): 277 self.manifest["dependencies"]["json"].pop("rev") 278 self.manifest["dependencies"]["json"]["branch"] = "main" 279 self.assert_invalid("missing required fields") 280 281 def test_manifest_extra_branch_selector_is_rejected(self): 282 self.manifest["dependencies"]["json"]["branch"] = "main" 283 self.assert_invalid("unsupported fields") 284 285 def test_manifest_short_commit_is_rejected(self): 286 self.manifest["dependencies"]["morph"]["rev"] = "abcdef0" 287 self.assert_invalid("Git rev must be a full lowercase 40-digit commit") 288 289 def test_manifest_uppercase_commit_is_rejected(self): 290 self.manifest["dependencies"]["morph"]["rev"] = "A" * 40 291 self.assert_invalid("Git rev must be a full lowercase 40-digit commit") 292 293 def test_lock_branch_source_is_rejected(self): 294 old = self.source("flare")["conda_source"] 295 self.change_source(old, old.replace("?rev=" + PINS["flare"][1], "?branch=main")) 296 self.assert_invalid("branch/tag refs are forbidden") 297 298 def test_lock_short_commit_is_rejected(self): 299 old = self.source("morph")["conda_source"] 300 self.change_source(old, old.replace(PINS["morph"][1], "abcdef0")) 301 self.assert_invalid("Git rev must be a full lowercase 40-digit commit") 302 303 def test_lock_resolved_commit_mismatch_is_rejected(self): 304 old = self.source()["conda_source"] 305 self.change_source(old, old.rsplit("#", 1)[0] + "#" + "c" * 40) 306 self.assert_invalid("resolved Git commit must exactly match rev") 307 308 def test_extra_git_query_does_not_echo_secret(self): 309 old = self.source()["conda_source"] 310 self.change_source(old, old.replace("#", f"&token={SECRET_MARKER}#")) 311 self.assert_invalid("Git source requires only a rev query") 312 313 def test_git_url_credentials_do_not_echo(self): 314 old = self.source()["conda_source"] 315 self.change_source(old, old.replace("https://", f"https://user:{SECRET_MARKER}@")) 316 self.assert_invalid("malformed URL") 317 318 def test_manifest_url_credentials_do_not_echo(self): 319 self.manifest["dependencies"]["json"]["git"] = f"https://user:{SECRET_MARKER}@example.invalid/json.git" 320 self.assert_invalid("malformed URL") 321 322 def test_non_https_git_source_is_rejected(self): 323 old = self.source()["conda_source"] 324 self.change_source(old, old.replace("git+https://", "git+ssh://")) 325 self.assert_invalid("malformed URL") 326 327 def test_source_locator_shape_is_rejected(self): 328 old = self.source()["conda_source"] 329 self.change_source(old, "json @ " + old.split(" @ ", 1)[1]) 330 self.assert_invalid("expected a v7 name[variant] @ git+HTTPS locator") 331 332 def test_unknown_runtime_git_source_is_rejected(self): 333 extra = deepcopy(self.source()) 334 extra["conda_source"] = extra["conda_source"].replace("json[", "other[") 335 self.lock["packages"].append(extra) 336 self.assert_invalid("unsupported runtime Git source") 337 338 def test_runtime_uuid_binary_is_rejected(self): 339 record = archive("uuid", "linux-64", "0.0.0") 340 self.lock["packages"].append(record) 341 self.selections().append(reference(record)) 342 self.assert_invalid("runtime UUID is outside the baseline; native libuuid is a distinct allowed package") 343 344 def test_runtime_uuid_requirement_is_rejected(self): 345 self.source()["depends"].append("uuid >=0.0.0") 346 self.assert_invalid("runtime UUID is outside the baseline; native libuuid is distinct") 347 348 def test_binary_json_cannot_replace_source(self): 349 self.lock["packages"].append(archive("json", "linux-64", "0.0.0")) 350 self.assert_invalid("source-owned runtime package must not be replaced by a binary Conda package") 351 352 def test_manifest_mojo_range_is_rejected(self): 353 self.manifest["dependencies"]["mojo"] = ">=1.0.0b1" 354 self.assert_invalid("baseline requires exact Mojo ==1.0.0b1") 355 356 def test_joint_manifest_lock_mojo_drift_is_rejected(self): 357 self.manifest["dependencies"]["mojo"] = "==9.9.9" 358 self.lock = replace_text(self.lock, "1.0.0b1", "9.9.9") 359 self.assert_invalid("baseline requires exact Mojo ==1.0.0b1") 360 361 def test_all_three_mojo_archive_versions_are_checked(self): 362 for name, platform in (("mojo", "linux-64"), ("mojo-compiler", "osx-arm64"), ("mojo-python", "noarch")): 363 with self.subTest(name=name): 364 self.manifest, self.lock = fixture() 365 old = self.binary(name, platform)["conda"] 366 self.change_source(old, old.replace("1.0.0b1", "9.9.9")) 367 self.assert_invalid("Mojo/compiler/python version differs from the exact baseline root pin") 368 369 def test_unselected_mixed_mojo_record_is_rejected(self): 370 self.lock["packages"].append(archive("mojo", "linux-64", "9.9.9")) 371 self.assert_invalid("Mojo/compiler/python version differs from the exact baseline root pin") 372 373 def test_missing_mojo_family_selection_is_rejected(self): 374 self.selections().remove(reference(self.binary("mojo-compiler"))) 375 self.assert_invalid("missing Mojo, mojo-compiler or mojo-python package") 376 377 def test_wrong_source_mojo_dependency_is_rejected(self): 378 self.source()["depends"] = ["mojo ==9.9.9"] 379 self.assert_invalid("source package must declare the baseline exact Mojo dependency") 380 381 def test_conflicting_source_mojo_dependency_is_rejected(self): 382 self.source()["depends"].append("mojo ==9.9.9") 383 self.assert_invalid("Mojo dependency must exactly match the baseline root pin") 384 385 def test_compiler_python_dependency_mismatch_is_rejected(self): 386 self.binary("mojo-compiler")["depends"] = ["mojo-python ==9.9.9"] 387 self.assert_invalid("Mojo dependency must exactly match the baseline root pin") 388 389 def test_duplicate_mojo_dependency_is_rejected(self): 390 self.source()["depends"].append("mojo ==1.0.0b1") 391 self.assert_invalid("duplicate Mojo dependency") 392 393 def test_missing_source_record_is_rejected(self): 394 self.lock["packages"].remove(self.source()) 395 self.assert_invalid("missing source package/platform records") 396 397 def test_missing_runtime_source_selection_is_rejected(self): 398 self.selections().remove(reference(self.source())) 399 self.assert_invalid("missing required runtime source selection") 400 401 def test_missing_referenced_binary_record_is_rejected(self): 402 self.lock["packages"].remove(self.binary("libuuid")) 403 self.assert_invalid("package reference has no corresponding package record") 404 405 def test_missing_host_reference_record_is_rejected(self): 406 self.source()["host_packages"].append({"conda": "https://packages.example.invalid/channel/linux-64/missing-0.0.0-test_0.conda"}) 407 stderr = self.assert_invalid("package reference has no corresponding package record") 408 self.assertIn("host_packages", stderr) 409 410 def test_missing_build_reference_record_is_rejected(self): 411 self.source()["build_packages"].append({"conda": "https://packages.example.invalid/channel/linux-64/missing-0.0.0-test_0.conda"}) 412 stderr = self.assert_invalid("package reference has no corresponding package record") 413 self.assertIn("build_packages", stderr) 414 415 def test_foreign_platform_reference_is_rejected(self): 416 self.selections().remove(reference(self.binary())) 417 self.selections().append(reference(self.binary(platform="osx-arm64"))) 418 self.assert_invalid("referenced package belongs to another platform") 419 420 def test_mixed_reference_kinds_are_rejected(self): 421 self.selections()[0]["conda_source"] = self.source()["conda_source"] 422 self.assert_invalid("expected exactly one supported package locator") 423 424 def test_source_variant_mismatch_is_rejected(self): 425 self.source()["variants"]["target_platform"] = "osx-arm64" 426 self.assert_invalid("source variant and subdir disagree") 427 428 def test_missing_source_variants_is_rejected(self): 429 self.source().pop("variants") 430 self.assert_invalid("missing required fields") 431 432 def test_missing_lock_platform_is_rejected(self): 433 self.lock["platforms"].pop() 434 self.assert_invalid("baseline requires exactly linux-64 and osx-arm64") 435 436 def test_duplicate_lock_platform_is_rejected(self): 437 self.lock["platforms"][1]["name"] = "linux-64" 438 self.assert_invalid("baseline requires exactly linux-64 and osx-arm64") 439 440 def test_missing_manifest_platform_is_rejected(self): 441 self.manifest["workspace"]["platforms"].pop() 442 self.assert_invalid("manifest.workspace.platforms: baseline requires exactly") 443 444 def test_missing_runtime_platform_mapping_is_rejected(self): 445 self.lock["environments"]["default"]["packages"].pop("osx-arm64") 446 self.assert_invalid("lock default packages: missing required fields") 447 448 def test_extra_environment_is_rejected(self): 449 self.lock["environments"]["other"] = {} 450 self.assert_invalid("lock.environments: unsupported fields") 451 452 def test_missing_default_environment_is_rejected(self): 453 self.lock["environments"] = {} 454 self.assert_invalid("lock.environments: missing required fields") 455 456 def test_empty_graph_is_rejected(self): 457 self.lock["packages"] = [] 458 self.assert_invalid("lock.packages: expected a nonempty list") 459 460 def test_empty_runtime_selection_is_rejected(self): 461 self.lock["environments"]["default"]["packages"]["linux-64"] = [] 462 self.assert_invalid("lock default packages.linux-64: expected a nonempty list") 463 464 def test_unsupported_lock_version_is_rejected(self): 465 self.lock["version"] = 8 466 self.assert_invalid("lock.version: only actual Pixi YAML v7 is supported") 467 468 def test_boolean_lock_version_is_rejected(self): 469 self.lock["version"] = True 470 self.assert_invalid("lock.version: only actual Pixi YAML v7 is supported") 471 472 def test_unknown_lock_field_is_secret_safe(self): 473 self.lock[SECRET_MARKER] = "untrusted value" 474 self.assert_invalid("lock: unsupported fields") 475 476 def test_unknown_manifest_section_is_secret_safe(self): 477 self.manifest[SECRET_MARKER] = {} 478 self.assert_invalid("manifest: unsupported fields") 479 480 def test_unknown_package_field_is_rejected(self): 481 self.binary()["new_source_type"] = "unsupported" 482 self.assert_invalid("unsupported fields") 483 484 def test_incomplete_conda_record_is_rejected(self): 485 self.binary().pop("sha256") 486 self.assert_invalid("missing required fields") 487 488 def test_malformed_archive_digest_is_rejected(self): 489 self.binary()["sha256"] = "not-a-digest" 490 self.assert_invalid("expected a lowercase archive digest") 491 492 def test_conda_url_query_is_secret_safe(self): 493 old = self.binary()["conda"] 494 self.change_source(old, old + f"?token={SECRET_MARKER}") 495 self.assert_invalid("Conda URL must identify a package without query, fragment or escapes") 496 497 def test_duplicate_channel_is_rejected(self): 498 self.lock["environments"]["default"]["channels"].append({"url": "https://packages.example.invalid/channel"}) 499 self.assert_invalid("duplicate channel") 500 501 def test_malformed_yaml_is_secret_safe(self): 502 self.lock_path.write_text(f'bad: ["https://user:{SECRET_MARKER}@example.invalid/"\n', encoding="utf-8") 503 self.assert_invalid("lock YAML: malformed or unsupported document at line", rewrite=False) 504 505 def test_malformed_toml_is_secret_safe(self): 506 self.manifest_path.write_text(f'bad = "https://user:{SECRET_MARKER}@example.invalid/\n', encoding="utf-8") 507 self.assert_invalid("manifest TOML: malformed document", rewrite=False) 508 509 def test_duplicate_yaml_key_is_rejected(self): 510 self.lock_path.write_text("version: 7\nversion: 7\n", encoding="utf-8") 511 self.assert_invalid("lock YAML: duplicate mapping key at line 2", rewrite=False) 512 513 def test_nested_duplicate_yaml_key_is_rejected(self): 514 self.lock_path.write_text("outer:\n nested: 1\n nested: 2\n", encoding="utf-8") 515 self.assert_invalid("duplicate mapping key at line 3", rewrite=False) 516 517 def test_nonstring_yaml_key_is_rejected(self): 518 self.lock_path.write_text("1: value\n", encoding="utf-8") 519 self.assert_invalid("mapping keys must be strings", rewrite=False) 520 521 def test_yaml_anchor_is_rejected(self): 522 self.lock_path.write_text("item: &example {}\n", encoding="utf-8") 523 self.assert_invalid("anchors and aliases are unsupported", rewrite=False) 524 525 def test_yaml_alias_is_rejected_before_resolution(self): 526 self.lock_path.write_text("*missing\n", encoding="utf-8") 527 self.assert_invalid("anchors and aliases are unsupported", rewrite=False) 528 529 def test_explicit_standard_yaml_tag_is_rejected(self): 530 self.lock_path.write_text("!!map {}\n", encoding="utf-8") 531 self.assert_invalid("explicit YAML tags are unsupported", rewrite=False) 532 533 def test_unknown_yaml_tag_is_secret_safe(self): 534 self.lock_path.write_text(f"!{SECRET_MARKER} {{}}\n", encoding="utf-8") 535 self.assert_invalid("explicit YAML tags are unsupported", rewrite=False) 536 537 def test_multiple_yaml_documents_are_rejected(self): 538 self.lock_path.write_text("---\n{}\n---\n{}\n", encoding="utf-8") 539 self.assert_invalid("lock YAML: malformed or unsupported document", rewrite=False) 540 541 def test_scalar_yaml_root_is_rejected(self): 542 self.lock_path.write_text("42\n", encoding="utf-8") 543 self.assert_invalid("lock: expected a mapping", rewrite=False) 544 545 def test_invalid_utf8_lock_is_rejected(self): 546 self.lock_path.write_bytes(b"\xff") 547 self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False) 548 549 def test_invalid_utf8_manifest_is_rejected(self): 550 self.manifest_path.write_bytes(b"\xff") 551 self.assert_invalid("manifest input: cannot read a UTF-8 input", rewrite=False) 552 553 def test_missing_manifest_path_is_secret_safe(self): 554 self.manifest_path = self.root / SECRET_MARKER 555 self.assert_invalid("manifest input: cannot read a UTF-8 input", rewrite=False) 556 557 def test_missing_lock_path_is_secret_safe(self): 558 self.lock_path = self.root / SECRET_MARKER 559 self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False) 560 561 def test_directory_input_is_rejected(self): 562 self.lock_path = self.root 563 self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False) 564 565 def test_cli_requires_explicit_mode(self): 566 code, stdout, stderr = self.invoke([]) 567 self.assertEqual((code, stdout), (2, "")) 568 self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n") 569 570 def test_self_test_also_requires_explicit_mode(self): 571 code, stdout, stderr = self.invoke(["--self-test"]) 572 self.assertEqual((code, stdout), (2, "")) 573 self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n") 574 575 def test_unknown_cli_mode_is_secret_safe(self): 576 code, stdout, stderr = self.invoke(["--mode", SECRET_MARKER]) 577 self.assertEqual((code, stdout), (2, "")) 578 self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n") 579 580 def test_unknown_cli_option_is_secret_safe(self): 581 code, stdout, stderr = self.invoke(["--mode", "baseline", "--" + SECRET_MARKER]) 582 self.assertEqual((code, stdout), (2, "")) 583 self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n") 584 585 def test_cli_help_is_successful_and_describes_mode(self): 586 code, stdout, stderr = self.invoke(["--help"]) 587 self.assertEqual((code, stderr), (0, "")) 588 self.assertIn("--mode {baseline}", stdout) 589 self.assertIn("--self-test", stdout) 590 591 def test_yaml_depth_boundary(self): 592 for depth in (63, 64): 593 with self.subTest(depth=depth): 594 # N-1 sequence containers plus one scalar have depth N. 595 data = "[" * (depth - 1) + "0" + "]" * (depth - 1) 596 parsed = yaml.load(data, Loader=self.checker.StrictLoader) 597 for _ in range(depth - 1): 598 parsed = parsed[0] 599 self.assertEqual(parsed, 0) 600 self.lock_path.write_text("[" * 64 + "0" + "]" * 64, encoding="utf-8") 601 self.assert_invalid("document exceeds supported structural limits", rewrite=False) 602 603 def test_yaml_node_boundary(self): 604 for nodes in (99_999, 100_000): 605 with self.subTest(nodes=nodes): 606 data = "- 0\n" * (nodes - 1) 607 parsed = yaml.load(data, Loader=self.checker.StrictLoader) 608 self.assertEqual(len(parsed), nodes - 1) 609 self.lock_path.write_text("- 0\n" * 100_000, encoding="utf-8") 610 self.assert_invalid("document exceeds supported structural limits", rewrite=False) 611 612 def test_input_byte_boundary(self): 613 for size in (8 * 1024 * 1024 - 1, 8 * 1024 * 1024): 614 with self.subTest(size=size): 615 self.lock_path.write_bytes(b"x" * size) 616 text = self.checker.read_text(self.lock_path, "lock input") 617 self.assertEqual(len(text), size) 618 self.lock_path.write_bytes(b"x" * (8 * 1024 * 1024 + 1)) 619 self.assert_invalid("lock input: input exceeds 8 MiB", rewrite=False) 620 621 def test_manifest_byte_limit_is_enforced(self): 622 self.manifest_path.write_bytes(b"x" * (8 * 1024 * 1024 + 1)) 623 self.assert_invalid("manifest input: input exceeds 8 MiB", rewrite=False) 624 625 626 def run(checker) -> int: 627 """Return nonzero for any failure, error, skip or incomplete execution.""" 628 bound = type("DependencyLockTests", (DependencyLockTests,), {"checker": checker}) 629 suite = unittest.defaultTestLoader.loadTestsFromTestCase(bound) 630 expected = suite.countTestCases() 631 result = unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite) 632 complete = result.testsRun == expected and expected > 0 633 unqualified = result.skipped or result.expectedFailures or result.unexpectedSuccesses 634 if not result.wasSuccessful() or not complete or unqualified: 635 print("dependency lock self-test: FAIL", file=sys.stderr) 636 return 1 637 print(f"dependency lock self-test: PASS ({result.testsRun} tests; zero skips)") 638 return 0 639 640 641 if __name__ == "__main__": 642 raise SystemExit("Run check_dependency_lock.py --mode baseline --self-test")