hyf

Context-aware query service for Radroots
git clone https://radroots.dev/git/hyf.git
Log | Files | Refs | README | LICENSE

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