commit ba42e6ce35c94810874a8ae8be32e4d2aea523a0
parent 2f3805dd0a98d27a1ddd6cd34d461ba2a2716aa2
Author: triesap <tyson@radroots.org>
Date: Wed, 28 Oct 2026 03:27:54 +0000
hyf: self-test the dependency lock checker
- Add ninety synthetic acceptance and rejection tests with independent pins
- Exercise parser limits, source drift and secret-safe diagnostics
- Wire the locked self-test into repository test and release aggregates
- Verify the real graph and nonzero failure propagation through the entry point
Diffstat:
3 files changed, 650 insertions(+), 0 deletions(-)
diff --git a/pixi.toml b/pixi.toml
@@ -42,6 +42,7 @@ check-build = "mkdir -p .pixi/build && mojo build -I src src/main.mojo -o .pixi/
check-format = "sh tools/check_format.sh"
check-format-self-test = "sh tools/check_format.sh --self-test"
check-dependency-lock = "uv run --locked --script tools/check_dependency_lock.py --mode baseline"
+check-dependency-lock-self-test = "uv run --locked --script tools/check_dependency_lock.py --mode baseline --self-test"
check-release = { depends-on = [
"test",
"check-build",
@@ -56,6 +57,8 @@ test-runtime-contract = { depends-on = [
"test-stdio",
] }
test = { depends-on = [
+ "check-dependency-lock",
+ "check-dependency-lock-self-test",
"test-unit",
"test-harness",
"test-harness-runner-exit",
diff --git a/tools/check_dependency_lock.py b/tools/check_dependency_lock.py
@@ -353,7 +353,12 @@ def main(argv: list[str] | None = None) -> int:
parser.add_argument("--mode", choices=("baseline",), required=True, help="explicitly select the existing graph policy")
parser.add_argument("--manifest", type=Path, default=Path("pixi.toml"), help="manifest input (default: pixi.toml)")
parser.add_argument("--lock", type=Path, default=Path("pixi.lock"), help="lock input (default: pixi.lock)")
+ parser.add_argument("--self-test", action="store_true", help="run isolated synthetic baseline acceptance and rejection cases")
args = parser.parse_args(argv)
+ if args.self_test:
+ from check_dependency_lock_self_test import run
+
+ return run(sys.modules[__name__])
try:
try:
manifest = tomllib.loads(read_text(args.manifest, "manifest input"))
diff --git a/tools/check_dependency_lock_self_test.py b/tools/check_dependency_lock_self_test.py
@@ -0,0 +1,642 @@
+"""Isolated synthetic regression cases for the dependency lock checker.
+
+Invoke through ``check_dependency_lock.py --mode baseline --self-test`` so the
+existing locked script supplies PyYAML. Fixture pins are independent literal
+oracles. Example archive URLs/digests are test data, never downloaded artifacts.
+All filesystem fixtures belong to temporary directories and no subprocess runs.
+"""
+
+from __future__ import annotations
+
+from contextlib import redirect_stderr, redirect_stdout
+from copy import deepcopy
+from io import StringIO
+import json
+from pathlib import Path
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+
+import yaml
+
+
+# Keep these acceptance inputs independent from the checker policy constants.
+PLATFORMS = ("linux-64", "osx-arm64")
+PINS = {
+ "json": (
+ "https://github.com/triesap/mojo_json",
+ "56025d73631054d7803143fa5e68c5de578e33f5",
+ ),
+ "morph": (
+ "https://github.com/triesap/mojo_morph",
+ "ea73f909990f3d3f5d12b786fec2f09e1e09f462",
+ ),
+ "flare": (
+ "https://github.com/triesap/mojo_flare",
+ "14aa338d8c4f352ebb2d590cddfde0bde5ea1971",
+ ),
+}
+SECRET_MARKER = "SYNTHETIC_CREDENTIAL_MUST_NOT_APPEAR"
+
+
+def archive(name: str, platform: str, version: str = "1.0.0b1") -> dict:
+ return {
+ "conda": f"https://packages.example.invalid/channel/{platform}/{name}-{version}-test_0.conda",
+ "sha256": "a" * 64,
+ "md5": "b" * 32,
+ "depends": [],
+ }
+
+
+def reference(record: dict) -> dict:
+ kind = "conda" if "conda" in record else "conda_source"
+ return {kind: record[kind]}
+
+
+def fixture() -> tuple[dict, dict]:
+ manifest = {
+ "workspace": {
+ "name": "dependency_lock_fixture",
+ "version": "0.0.0",
+ "description": "Synthetic lock checker fixture",
+ "authors": ["Fixture Authors"],
+ "channels": ["https://packages.example.invalid/channel/"],
+ "platforms": ["linux-64", "osx-arm64"],
+ "preview": ["pixi-build"],
+ },
+ "dependencies": {
+ "mojo": "==1.0.0b1",
+ **{name: {"git": repo + ".git", "rev": rev} for name, (repo, rev) in PINS.items()},
+ },
+ "tasks": {"fixture": "echo fixture"},
+ }
+ lock = {
+ "version": 7,
+ "platforms": [{"name": platform} for platform in PLATFORMS],
+ "environments": {
+ "default": {
+ "channels": [{"url": "https://packages.example.invalid/channel/"}],
+ "packages": {platform: [] for platform in PLATFORMS},
+ }
+ },
+ "packages": [],
+ }
+ python = archive("mojo-python", "noarch")
+ python["noarch"] = "python"
+ lock["packages"].append(python)
+ for platform_index, platform in enumerate(PLATFORMS):
+ selected = lock["environments"]["default"]["packages"][platform]
+ mojo = archive("mojo", platform)
+ mojo["depends"] = ["mojo-compiler ==1.0.0b1"]
+ compiler = archive("mojo-compiler", platform)
+ compiler["depends"] = ["mojo-python ==1.0.0b1"]
+ lock["packages"].extend((mojo, compiler))
+ selected.extend(reference(record) for record in (python, mojo, compiler))
+ for source_index, (name, (repo, rev)) in enumerate(PINS.items(), start=1):
+ variant = f"{source_index * 16 + platform_index:08x}"
+ record = {
+ "conda_source": f"{name}[{variant}] @ git+{repo}?rev={rev}#{rev}",
+ "version": "0.0.0",
+ "build": "test_0",
+ "subdir": platform,
+ "variants": {"target_platform": platform},
+ "depends": ["mojo ==1.0.0b1"],
+ "build_packages": [reference(compiler)],
+ "host_packages": [reference(python), reference(mojo)],
+ }
+ lock["packages"].append(record)
+ selected.append(reference(record))
+ native_uuid = archive("libuuid", "linux-64", "2.42")
+ lock["packages"].append(native_uuid)
+ lock["environments"]["default"]["packages"]["linux-64"].append(reference(native_uuid))
+ return manifest, lock
+
+
+def toml_value(value: object) -> str:
+ if type(value) is dict:
+ return "{ " + ", ".join(f"{json.dumps(key)} = {toml_value(item)}" for key, item in value.items()) + " }"
+ if type(value) is list:
+ return "[" + ", ".join(toml_value(item) for item in value) + "]"
+ return json.dumps(value, ensure_ascii=False)
+
+
+def manifest_text(manifest: dict) -> str:
+ lines = [f"{json.dumps(key)} = {toml_value(value)}" for key, value in manifest.items() if type(value) is not dict]
+ for section, table in manifest.items():
+ if type(table) is dict:
+ lines.append(f"[{json.dumps(section)}]")
+ lines.extend(f"{json.dumps(key)} = {toml_value(value)}" for key, value in table.items())
+ return "\n".join(lines) + "\n"
+
+
+def replace_text(value: object, old: str, new: str) -> object:
+ """Change a fixture fact consistently in its records and references."""
+ if type(value) is str:
+ return value.replace(old, new)
+ if type(value) is list:
+ return [replace_text(item, old, new) for item in value]
+ if type(value) is dict:
+ return {key: replace_text(item, old, new) for key, item in value.items()}
+ return value
+
+
+class DependencyLockTests(unittest.TestCase):
+ checker = None
+
+ def setUp(self):
+ temporary = TemporaryDirectory(prefix="dependency-lock-test-")
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name)
+ self.manifest_path = self.root / "pixi.toml"
+ self.lock_path = self.root / "pixi.lock"
+ self.manifest, self.lock = fixture()
+ self.write_fixture()
+
+ def write_fixture(self):
+ self.manifest_path.write_text(manifest_text(self.manifest), encoding="utf-8")
+ self.lock_path.write_text(yaml.safe_dump(self.lock, sort_keys=False), encoding="utf-8")
+
+ def invoke(self, argv=None):
+ if argv is None:
+ argv = ["--mode", "baseline", "--manifest", str(self.manifest_path), "--lock", str(self.lock_path)]
+ stdout = StringIO()
+ stderr = StringIO()
+ with redirect_stdout(stdout), redirect_stderr(stderr):
+ try:
+ code = self.checker.main(argv)
+ except SystemExit as exc:
+ code = exc.code
+ self.assertIs(type(code), int, "CLI exit must be an integer")
+ output = stdout.getvalue() + stderr.getvalue()
+ self.assertNotIn("Traceback", output)
+ self.assertNotIn(SECRET_MARKER, output, "diagnostics leaked synthetic credentials or untrusted data")
+ return code, stdout.getvalue(), stderr.getvalue()
+
+ def assert_valid(self, *, rewrite=True):
+ if rewrite:
+ self.write_fixture()
+ code, stdout, stderr = self.invoke()
+ self.assertEqual(code, 0, stderr)
+ self.assertEqual(stderr, "")
+ self.assertIn("baseline PASS (YAML v7; 2 platforms; one JSON source;", stdout)
+ self.assertIn("Mojo 1.0.0b1)", stdout)
+
+ def assert_invalid(self, cause: str, *, rewrite=True):
+ if rewrite:
+ self.write_fixture()
+ code, stdout, stderr = self.invoke()
+ self.assertEqual(code, 1, (stdout, stderr))
+ self.assertTrue(stderr.startswith("dependency lock: FAIL: "), stderr)
+ self.assertIn(cause, stderr)
+ self.assertNotIn("PASS", stdout)
+ return stderr
+
+ def selections(self, platform="linux-64"):
+ return self.lock["environments"]["default"]["packages"][platform]
+
+ def source(self, name="json", platform="linux-64"):
+ return next(record for record in self.lock["packages"] if record.get("conda_source", "").startswith(name + "[") and record["subdir"] == platform)
+
+ def binary(self, name="mojo", platform="linux-64"):
+ prefix = f"https://packages.example.invalid/channel/{platform}/{name}-"
+ return next(record for record in self.lock["packages"] if record.get("conda", "").startswith(prefix) and record["conda"].split("/")[-1].rsplit("-", 2)[0] == name)
+
+ def change_source(self, old: str, new: str):
+ self.lock = replace_text(self.lock, old, new)
+
+ def test_independent_baseline_valid(self):
+ self.assert_valid()
+
+ def test_two_json_platform_variants_are_one_source(self):
+ first = self.source(platform="linux-64")["conda_source"]
+ second = self.source(platform="osx-arm64")["conda_source"]
+ self.assertNotEqual(first, second)
+ self.assertIn("56025d73631054d7803143fa5e68c5de578e33f5", first)
+ self.assert_valid()
+
+ def test_canonical_repository_spellings(self):
+ self.manifest["dependencies"]["json"]["git"] = "https://GITHUB.COM/triesap/mojo_json.git/"
+ self.change_source("git+https://github.com/triesap/mojo_json?", "git+https://GITHUB.COM/triesap/mojo_json.git/?")
+ self.assert_valid()
+
+ def test_frozen_non_json_commit_is_manifest_driven(self):
+ old = self.manifest["dependencies"]["morph"]["rev"]
+ self.manifest["dependencies"]["morph"]["rev"] = "c" * 40
+ self.change_source(old, "c" * 40)
+ self.assert_valid()
+
+ def test_native_libuuid_is_allowed(self):
+ self.assertIn(reference(self.binary("libuuid")), self.selections())
+ self.assert_valid()
+
+ def test_tar_bz2_package_archive_is_allowed(self):
+ old = self.binary()["conda"]
+ self.change_source(old, old.removesuffix(".conda") + ".tar.bz2")
+ self.assert_valid()
+
+ def test_duplicate_json_record_is_rejected(self):
+ extra = deepcopy(self.source())
+ extra["conda_source"] = extra["conda_source"].replace("[00000010]", "[000000ff]")
+ self.lock["packages"].append(extra)
+ self.assert_invalid("multiple source records for one runtime package/platform")
+
+ def test_duplicate_exact_package_record_is_rejected(self):
+ self.lock["packages"].append(deepcopy(self.source()))
+ self.assert_invalid("duplicate package record")
+
+ def test_duplicate_json_selection_is_rejected(self):
+ self.selections().append(reference(self.source()))
+ self.assert_invalid("duplicate package reference")
+
+ def test_second_json_repository_is_rejected(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.replace("triesap/mojo_json", "other/mojo_json"))
+ self.assert_invalid("Git source/revision differs from its exact manifest pin")
+
+ def test_wrong_json_lock_revision_is_rejected(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.replace("56025d73631054d7803143fa5e68c5de578e33f5", "c" * 40))
+ self.assert_invalid("Git source/revision differs from its exact manifest pin")
+
+ def test_joint_manifest_lock_json_revision_drift_is_rejected(self):
+ old = self.manifest["dependencies"]["json"]["rev"]
+ self.manifest["dependencies"]["json"]["rev"] = "c" * 40
+ self.change_source(old, "c" * 40)
+ self.assert_invalid("JSON revision differs from the independently defined baseline revision")
+
+ def test_joint_manifest_lock_json_repository_drift_is_rejected(self):
+ self.manifest["dependencies"]["json"]["git"] = "https://example.invalid/wrong/json.git"
+ self.change_source("https://github.com/triesap/mojo_json", "https://example.invalid/wrong/json")
+ self.assert_invalid("repository differs from the independently defined baseline source")
+
+ def test_manifest_branch_revision_is_rejected(self):
+ self.manifest["dependencies"]["json"]["rev"] = "main"
+ self.assert_invalid("Git rev must be a full lowercase 40-digit commit")
+
+ def test_manifest_branch_without_rev_is_rejected(self):
+ self.manifest["dependencies"]["json"].pop("rev")
+ self.manifest["dependencies"]["json"]["branch"] = "main"
+ self.assert_invalid("missing required fields")
+
+ def test_manifest_extra_branch_selector_is_rejected(self):
+ self.manifest["dependencies"]["json"]["branch"] = "main"
+ self.assert_invalid("unsupported fields")
+
+ def test_manifest_short_commit_is_rejected(self):
+ self.manifest["dependencies"]["morph"]["rev"] = "abcdef0"
+ self.assert_invalid("Git rev must be a full lowercase 40-digit commit")
+
+ def test_manifest_uppercase_commit_is_rejected(self):
+ self.manifest["dependencies"]["morph"]["rev"] = "A" * 40
+ self.assert_invalid("Git rev must be a full lowercase 40-digit commit")
+
+ def test_lock_branch_source_is_rejected(self):
+ old = self.source("flare")["conda_source"]
+ self.change_source(old, old.replace("?rev=" + PINS["flare"][1], "?branch=main"))
+ self.assert_invalid("branch/tag refs are forbidden")
+
+ def test_lock_short_commit_is_rejected(self):
+ old = self.source("morph")["conda_source"]
+ self.change_source(old, old.replace(PINS["morph"][1], "abcdef0"))
+ self.assert_invalid("Git rev must be a full lowercase 40-digit commit")
+
+ def test_lock_resolved_commit_mismatch_is_rejected(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.rsplit("#", 1)[0] + "#" + "c" * 40)
+ self.assert_invalid("resolved Git commit must exactly match rev")
+
+ def test_extra_git_query_does_not_echo_secret(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.replace("#", f"&token={SECRET_MARKER}#"))
+ self.assert_invalid("Git source requires only a rev query")
+
+ def test_git_url_credentials_do_not_echo(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.replace("https://", f"https://user:{SECRET_MARKER}@"))
+ self.assert_invalid("malformed URL")
+
+ def test_manifest_url_credentials_do_not_echo(self):
+ self.manifest["dependencies"]["json"]["git"] = f"https://user:{SECRET_MARKER}@example.invalid/json.git"
+ self.assert_invalid("malformed URL")
+
+ def test_non_https_git_source_is_rejected(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, old.replace("git+https://", "git+ssh://"))
+ self.assert_invalid("malformed URL")
+
+ def test_source_locator_shape_is_rejected(self):
+ old = self.source()["conda_source"]
+ self.change_source(old, "json @ " + old.split(" @ ", 1)[1])
+ self.assert_invalid("expected a v7 name[variant] @ git+HTTPS locator")
+
+ def test_unknown_runtime_git_source_is_rejected(self):
+ extra = deepcopy(self.source())
+ extra["conda_source"] = extra["conda_source"].replace("json[", "other[")
+ self.lock["packages"].append(extra)
+ self.assert_invalid("unsupported runtime Git source")
+
+ def test_runtime_uuid_binary_is_rejected(self):
+ record = archive("uuid", "linux-64", "0.0.0")
+ self.lock["packages"].append(record)
+ self.selections().append(reference(record))
+ self.assert_invalid("runtime UUID is outside the baseline; native libuuid is a distinct allowed package")
+
+ def test_runtime_uuid_requirement_is_rejected(self):
+ self.source()["depends"].append("uuid >=0.0.0")
+ self.assert_invalid("runtime UUID is outside the baseline; native libuuid is distinct")
+
+ def test_binary_json_cannot_replace_source(self):
+ self.lock["packages"].append(archive("json", "linux-64", "0.0.0"))
+ self.assert_invalid("source-owned runtime package must not be replaced by a binary Conda package")
+
+ def test_manifest_mojo_range_is_rejected(self):
+ self.manifest["dependencies"]["mojo"] = ">=1.0.0b1"
+ self.assert_invalid("baseline requires exact Mojo ==1.0.0b1")
+
+ def test_joint_manifest_lock_mojo_drift_is_rejected(self):
+ self.manifest["dependencies"]["mojo"] = "==9.9.9"
+ self.lock = replace_text(self.lock, "1.0.0b1", "9.9.9")
+ self.assert_invalid("baseline requires exact Mojo ==1.0.0b1")
+
+ def test_all_three_mojo_archive_versions_are_checked(self):
+ for name, platform in (("mojo", "linux-64"), ("mojo-compiler", "osx-arm64"), ("mojo-python", "noarch")):
+ with self.subTest(name=name):
+ self.manifest, self.lock = fixture()
+ old = self.binary(name, platform)["conda"]
+ self.change_source(old, old.replace("1.0.0b1", "9.9.9"))
+ self.assert_invalid("Mojo/compiler/python version differs from the exact baseline root pin")
+
+ def test_unselected_mixed_mojo_record_is_rejected(self):
+ self.lock["packages"].append(archive("mojo", "linux-64", "9.9.9"))
+ self.assert_invalid("Mojo/compiler/python version differs from the exact baseline root pin")
+
+ def test_missing_mojo_family_selection_is_rejected(self):
+ self.selections().remove(reference(self.binary("mojo-compiler")))
+ self.assert_invalid("missing Mojo, mojo-compiler or mojo-python package")
+
+ def test_wrong_source_mojo_dependency_is_rejected(self):
+ self.source()["depends"] = ["mojo ==9.9.9"]
+ self.assert_invalid("source package must declare the baseline exact Mojo dependency")
+
+ def test_conflicting_source_mojo_dependency_is_rejected(self):
+ self.source()["depends"].append("mojo ==9.9.9")
+ self.assert_invalid("Mojo dependency must exactly match the baseline root pin")
+
+ def test_compiler_python_dependency_mismatch_is_rejected(self):
+ self.binary("mojo-compiler")["depends"] = ["mojo-python ==9.9.9"]
+ self.assert_invalid("Mojo dependency must exactly match the baseline root pin")
+
+ def test_duplicate_mojo_dependency_is_rejected(self):
+ self.source()["depends"].append("mojo ==1.0.0b1")
+ self.assert_invalid("duplicate Mojo dependency")
+
+ def test_missing_source_record_is_rejected(self):
+ self.lock["packages"].remove(self.source())
+ self.assert_invalid("missing source package/platform records")
+
+ def test_missing_runtime_source_selection_is_rejected(self):
+ self.selections().remove(reference(self.source()))
+ self.assert_invalid("missing required runtime source selection")
+
+ def test_missing_referenced_binary_record_is_rejected(self):
+ self.lock["packages"].remove(self.binary("libuuid"))
+ self.assert_invalid("package reference has no corresponding package record")
+
+ def test_missing_host_reference_record_is_rejected(self):
+ self.source()["host_packages"].append({"conda": "https://packages.example.invalid/channel/linux-64/missing-0.0.0-test_0.conda"})
+ stderr = self.assert_invalid("package reference has no corresponding package record")
+ self.assertIn("host_packages", stderr)
+
+ def test_missing_build_reference_record_is_rejected(self):
+ self.source()["build_packages"].append({"conda": "https://packages.example.invalid/channel/linux-64/missing-0.0.0-test_0.conda"})
+ stderr = self.assert_invalid("package reference has no corresponding package record")
+ self.assertIn("build_packages", stderr)
+
+ def test_foreign_platform_reference_is_rejected(self):
+ self.selections().remove(reference(self.binary()))
+ self.selections().append(reference(self.binary(platform="osx-arm64")))
+ self.assert_invalid("referenced package belongs to another platform")
+
+ def test_mixed_reference_kinds_are_rejected(self):
+ self.selections()[0]["conda_source"] = self.source()["conda_source"]
+ self.assert_invalid("expected exactly one supported package locator")
+
+ def test_source_variant_mismatch_is_rejected(self):
+ self.source()["variants"]["target_platform"] = "osx-arm64"
+ self.assert_invalid("source variant and subdir disagree")
+
+ def test_missing_source_variants_is_rejected(self):
+ self.source().pop("variants")
+ self.assert_invalid("missing required fields")
+
+ def test_missing_lock_platform_is_rejected(self):
+ self.lock["platforms"].pop()
+ self.assert_invalid("baseline requires exactly linux-64 and osx-arm64")
+
+ def test_duplicate_lock_platform_is_rejected(self):
+ self.lock["platforms"][1]["name"] = "linux-64"
+ self.assert_invalid("baseline requires exactly linux-64 and osx-arm64")
+
+ def test_missing_manifest_platform_is_rejected(self):
+ self.manifest["workspace"]["platforms"].pop()
+ self.assert_invalid("manifest.workspace.platforms: baseline requires exactly")
+
+ def test_missing_runtime_platform_mapping_is_rejected(self):
+ self.lock["environments"]["default"]["packages"].pop("osx-arm64")
+ self.assert_invalid("lock default packages: missing required fields")
+
+ def test_extra_environment_is_rejected(self):
+ self.lock["environments"]["other"] = {}
+ self.assert_invalid("lock.environments: unsupported fields")
+
+ def test_missing_default_environment_is_rejected(self):
+ self.lock["environments"] = {}
+ self.assert_invalid("lock.environments: missing required fields")
+
+ def test_empty_graph_is_rejected(self):
+ self.lock["packages"] = []
+ self.assert_invalid("lock.packages: expected a nonempty list")
+
+ def test_empty_runtime_selection_is_rejected(self):
+ self.lock["environments"]["default"]["packages"]["linux-64"] = []
+ self.assert_invalid("lock default packages.linux-64: expected a nonempty list")
+
+ def test_unsupported_lock_version_is_rejected(self):
+ self.lock["version"] = 8
+ self.assert_invalid("lock.version: only actual Pixi YAML v7 is supported")
+
+ def test_boolean_lock_version_is_rejected(self):
+ self.lock["version"] = True
+ self.assert_invalid("lock.version: only actual Pixi YAML v7 is supported")
+
+ def test_unknown_lock_field_is_secret_safe(self):
+ self.lock[SECRET_MARKER] = "untrusted value"
+ self.assert_invalid("lock: unsupported fields")
+
+ def test_unknown_manifest_section_is_secret_safe(self):
+ self.manifest[SECRET_MARKER] = {}
+ self.assert_invalid("manifest: unsupported fields")
+
+ def test_unknown_package_field_is_rejected(self):
+ self.binary()["new_source_type"] = "unsupported"
+ self.assert_invalid("unsupported fields")
+
+ def test_incomplete_conda_record_is_rejected(self):
+ self.binary().pop("sha256")
+ self.assert_invalid("missing required fields")
+
+ def test_malformed_archive_digest_is_rejected(self):
+ self.binary()["sha256"] = "not-a-digest"
+ self.assert_invalid("expected a lowercase archive digest")
+
+ def test_conda_url_query_is_secret_safe(self):
+ old = self.binary()["conda"]
+ self.change_source(old, old + f"?token={SECRET_MARKER}")
+ self.assert_invalid("Conda URL must identify a package without query, fragment or escapes")
+
+ def test_duplicate_channel_is_rejected(self):
+ self.lock["environments"]["default"]["channels"].append({"url": "https://packages.example.invalid/channel"})
+ self.assert_invalid("duplicate channel")
+
+ def test_malformed_yaml_is_secret_safe(self):
+ self.lock_path.write_text(f'bad: ["https://user:{SECRET_MARKER}@example.invalid/"\n', encoding="utf-8")
+ self.assert_invalid("lock YAML: malformed or unsupported document at line", rewrite=False)
+
+ def test_malformed_toml_is_secret_safe(self):
+ self.manifest_path.write_text(f'bad = "https://user:{SECRET_MARKER}@example.invalid/\n', encoding="utf-8")
+ self.assert_invalid("manifest TOML: malformed document", rewrite=False)
+
+ def test_duplicate_yaml_key_is_rejected(self):
+ self.lock_path.write_text("version: 7\nversion: 7\n", encoding="utf-8")
+ self.assert_invalid("lock YAML: duplicate mapping key at line 2", rewrite=False)
+
+ def test_nested_duplicate_yaml_key_is_rejected(self):
+ self.lock_path.write_text("outer:\n nested: 1\n nested: 2\n", encoding="utf-8")
+ self.assert_invalid("duplicate mapping key at line 3", rewrite=False)
+
+ def test_nonstring_yaml_key_is_rejected(self):
+ self.lock_path.write_text("1: value\n", encoding="utf-8")
+ self.assert_invalid("mapping keys must be strings", rewrite=False)
+
+ def test_yaml_anchor_is_rejected(self):
+ self.lock_path.write_text("item: &example {}\n", encoding="utf-8")
+ self.assert_invalid("anchors and aliases are unsupported", rewrite=False)
+
+ def test_yaml_alias_is_rejected_before_resolution(self):
+ self.lock_path.write_text("*missing\n", encoding="utf-8")
+ self.assert_invalid("anchors and aliases are unsupported", rewrite=False)
+
+ def test_explicit_standard_yaml_tag_is_rejected(self):
+ self.lock_path.write_text("!!map {}\n", encoding="utf-8")
+ self.assert_invalid("explicit YAML tags are unsupported", rewrite=False)
+
+ def test_unknown_yaml_tag_is_secret_safe(self):
+ self.lock_path.write_text(f"!{SECRET_MARKER} {{}}\n", encoding="utf-8")
+ self.assert_invalid("explicit YAML tags are unsupported", rewrite=False)
+
+ def test_multiple_yaml_documents_are_rejected(self):
+ self.lock_path.write_text("---\n{}\n---\n{}\n", encoding="utf-8")
+ self.assert_invalid("lock YAML: malformed or unsupported document", rewrite=False)
+
+ def test_scalar_yaml_root_is_rejected(self):
+ self.lock_path.write_text("42\n", encoding="utf-8")
+ self.assert_invalid("lock: expected a mapping", rewrite=False)
+
+ def test_invalid_utf8_lock_is_rejected(self):
+ self.lock_path.write_bytes(b"\xff")
+ self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False)
+
+ def test_invalid_utf8_manifest_is_rejected(self):
+ self.manifest_path.write_bytes(b"\xff")
+ self.assert_invalid("manifest input: cannot read a UTF-8 input", rewrite=False)
+
+ def test_missing_manifest_path_is_secret_safe(self):
+ self.manifest_path = self.root / SECRET_MARKER
+ self.assert_invalid("manifest input: cannot read a UTF-8 input", rewrite=False)
+
+ def test_missing_lock_path_is_secret_safe(self):
+ self.lock_path = self.root / SECRET_MARKER
+ self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False)
+
+ def test_directory_input_is_rejected(self):
+ self.lock_path = self.root
+ self.assert_invalid("lock input: cannot read a UTF-8 input", rewrite=False)
+
+ def test_cli_requires_explicit_mode(self):
+ code, stdout, stderr = self.invoke([])
+ self.assertEqual((code, stdout), (2, ""))
+ self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n")
+
+ def test_self_test_also_requires_explicit_mode(self):
+ code, stdout, stderr = self.invoke(["--self-test"])
+ self.assertEqual((code, stdout), (2, ""))
+ self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n")
+
+ def test_unknown_cli_mode_is_secret_safe(self):
+ code, stdout, stderr = self.invoke(["--mode", SECRET_MARKER])
+ self.assertEqual((code, stdout), (2, ""))
+ self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n")
+
+ def test_unknown_cli_option_is_secret_safe(self):
+ code, stdout, stderr = self.invoke(["--mode", "baseline", "--" + SECRET_MARKER])
+ self.assertEqual((code, stdout), (2, ""))
+ self.assertEqual(stderr, "dependency lock: invalid command line; use --help\n")
+
+ def test_cli_help_is_successful_and_describes_mode(self):
+ code, stdout, stderr = self.invoke(["--help"])
+ self.assertEqual((code, stderr), (0, ""))
+ self.assertIn("--mode {baseline}", stdout)
+ self.assertIn("--self-test", stdout)
+
+ def test_yaml_depth_boundary(self):
+ for depth in (63, 64):
+ with self.subTest(depth=depth):
+ # N-1 sequence containers plus one scalar have depth N.
+ data = "[" * (depth - 1) + "0" + "]" * (depth - 1)
+ parsed = yaml.load(data, Loader=self.checker.StrictLoader)
+ for _ in range(depth - 1):
+ parsed = parsed[0]
+ self.assertEqual(parsed, 0)
+ self.lock_path.write_text("[" * 64 + "0" + "]" * 64, encoding="utf-8")
+ self.assert_invalid("document exceeds supported structural limits", rewrite=False)
+
+ def test_yaml_node_boundary(self):
+ for nodes in (99_999, 100_000):
+ with self.subTest(nodes=nodes):
+ data = "- 0\n" * (nodes - 1)
+ parsed = yaml.load(data, Loader=self.checker.StrictLoader)
+ self.assertEqual(len(parsed), nodes - 1)
+ self.lock_path.write_text("- 0\n" * 100_000, encoding="utf-8")
+ self.assert_invalid("document exceeds supported structural limits", rewrite=False)
+
+ def test_input_byte_boundary(self):
+ for size in (8 * 1024 * 1024 - 1, 8 * 1024 * 1024):
+ with self.subTest(size=size):
+ self.lock_path.write_bytes(b"x" * size)
+ text = self.checker.read_text(self.lock_path, "lock input")
+ self.assertEqual(len(text), size)
+ self.lock_path.write_bytes(b"x" * (8 * 1024 * 1024 + 1))
+ self.assert_invalid("lock input: input exceeds 8 MiB", rewrite=False)
+
+ def test_manifest_byte_limit_is_enforced(self):
+ self.manifest_path.write_bytes(b"x" * (8 * 1024 * 1024 + 1))
+ self.assert_invalid("manifest input: input exceeds 8 MiB", rewrite=False)
+
+
+def run(checker) -> int:
+ """Return nonzero for any failure, error, skip or incomplete execution."""
+ bound = type("DependencyLockTests", (DependencyLockTests,), {"checker": checker})
+ suite = unittest.defaultTestLoader.loadTestsFromTestCase(bound)
+ expected = suite.countTestCases()
+ result = unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)
+ complete = result.testsRun == expected and expected > 0
+ unqualified = result.skipped or result.expectedFailures or result.unexpectedSuccesses
+ if not result.wasSuccessful() or not complete or unqualified:
+ print("dependency lock self-test: FAIL", file=sys.stderr)
+ return 1
+ print(f"dependency lock self-test: PASS ({result.testsRun} tests; zero skips)")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit("Run check_dependency_lock.py --mode baseline --self-test")