import io
import json
from pathlib import Path
import subprocess
import tarfile
import tempfile
import unittest
from check_distribution import (
DistributionError, File, check_package, clean_candidate, compare_files, compare_package_metadata,
digest, extract_checked, license_inventory, read_archive, tracked_files, validate,
SOURCE_ROOTS, check_source_roots,
)
from check_installation import check_registry_links
class ArchiveTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.root = Path(self.temporary.name)
def test_registry_links_allow_only_current_active_files(self):
prefix = "https://github.com/MGYamada/Qleisli/blob/"
historical = prefix + "7844a10d63880a2b6984c093e2dc7a75033d1e1e/docs/language-editions.md"
(self.root / "README.md").write_text("current")
self.assertEqual(check_registry_links(self.root,
f"[current]({prefix}v0.2.8/README.md)", "0.2.8"), [])
(self.root / "docs").mkdir()
(self.root / "docs/lean-backend-plan-v0.3.md").write_text("requested plan")
self.assertEqual(check_registry_links(self.root,
f"[plan]({prefix}v0.2.9/docs/lean-backend-plan-v0.3.md)", "0.2.9"), [])
(self.root / "docs-old").mkdir()
(self.root / "docs-old/design.md").write_text("temporary")
for target in ["README.md", prefix + "main/README.md", prefix + "v0.2.8/missing.md",
historical, prefix + "v0.2.8/docs-old/design.md",
historical.replace("language-editions", "unreviewed"),
historical.replace("7844a10d63880a2b6984c093e2dc7a75033d1e1e", "v0.2.7")]:
with self.subTest(target=target), self.assertRaises(ValueError):
check_registry_links(self.root, f"[link]({target})", "0.2.8")
def test_complete_archive_requires_kernel_source_audit_and_process_client(self):
files = {name: File(b"source") for name in SOURCE_ROOTS}
check_source_roots(files)
for name in ["lean-kernel/Audit.lean", "lean-kernel/Main.lean", "lean-kernel/Tests.lean",
"scripts/check_lean_kernel.py", "examples/lean_kernel.rs"]:
with self.subTest(name=name), self.assertRaisesRegex(DistributionError, name):
check_source_roots({key: value for key, value in files.items() if key != name})
def archive(self, entries):
path = self.root / "candidate.tar"
with tarfile.open(path, "w") as archive:
for name, data, mode, kind in entries:
member = tarfile.TarInfo(name)
member.mode, member.type = mode, kind
member.size = len(data) if kind == tarfile.REGTYPE else 0
if kind in {tarfile.SYMTYPE, tarfile.LNKTYPE}:
member.linkname = "../../outside"
archive.addfile(member, io.BytesIO(data) if member.isfile() else None)
return path
def test_preserves_binary_bytes_executable_mode_and_extracts(self):
expected = {"NOTICE": File(b"notice\r\n\x00\xff"), "bin/check": File(b"run\n", 0o755)}
path = self.archive([(name, file.data, file.mode, tarfile.REGTYPE)
for name, file in expected.items()])
actual = read_archive(path, expected=expected)
destination = self.root / "extracted"
extract_checked(actual, destination)
self.assertEqual((destination / "NOTICE").read_bytes(), expected["NOTICE"].data)
self.assertEqual((destination / "bin/check").stat().st_mode & 0o777, 0o755)
def test_missing_or_modified_notice_is_rejected(self):
expected = {"NOTICE": File(b"retain attribution\n"), "src/lib.rs": File(b"code")}
for changed in [{"src/lib.rs": expected["src/lib.rs"]},
dict(expected, NOTICE=File(b"delete attribution\n"))]:
with self.subTest(changed=changed), self.assertRaises(DistributionError):
compare_files(changed, expected)
def test_same_length_byte_corruption_and_mode_change_rejected(self):
expected = {"source.qli": File(b"original", 0o755)}
for data, mode in [(b"modified", 0o755), (b"original", 0o644)]:
path = self.archive([("source.qli", data, mode, tarfile.REGTYPE)])
with self.subTest(data=data, mode=mode), self.assertRaises(DistributionError):
read_archive(path, expected=expected)
def test_traversal_absolute_alias_and_wrong_prefix_rejected(self):
for name in ["../escape", "/escape", "a/../../escape", "a/./file", "a//file", "a\\file",
"C:/escape", "C:escape"]:
path = self.archive([(name, b"bad", 0o644, tarfile.REGTYPE)])
with self.subTest(name=name), self.assertRaises(DistributionError):
read_archive(path)
path = self.archive([("different/file", b"bad", 0o644, tarfile.REGTYPE)])
with self.assertRaises(DistributionError):
read_archive(path, prefix="expected")
for name in ["expected/C:/escape", "expected/C:escape"]:
path = self.archive([(name, b"bad", 0o644, tarfile.REGTYPE)])
with self.subTest(name=name), self.assertRaises(DistributionError):
read_archive(path, prefix="expected")
def test_duplicate_regular_or_directory_entries_rejected(self):
for kind in [tarfile.REGTYPE, tarfile.DIRTYPE]:
path = self.archive([("same", b"first", 0o644, kind),
("same", b"second", 0o644, kind)])
with self.subTest(kind=kind), self.assertRaises(DistributionError):
read_archive(path)
def test_links_special_files_and_file_directory_collisions_rejected(self):
for kind in [tarfile.SYMTYPE, tarfile.LNKTYPE, tarfile.FIFOTYPE, tarfile.CHRTYPE]:
path = self.archive([("entry", b"", 0o644, kind)])
with self.subTest(kind=kind), self.assertRaises(DistributionError):
read_archive(path)
path = self.archive([("parent", b"file", 0o644, tarfile.REGTYPE),
("parent/child", b"bad", 0o644, tarfile.REGTYPE)])
with self.assertRaises(DistributionError):
read_archive(path)
def test_extra_missing_and_wrong_size_archive_files_rejected(self):
expected = {"file": File(b"content")}
for entries in [[], [("extra", b"content", 0o644, tarfile.REGTYPE)],
[("file", b"short", 0o644, tarfile.REGTYPE)]]:
path = self.archive(entries)
with self.subTest(entries=entries), self.assertRaises(DistributionError):
read_archive(path, expected=expected)
def fixture_files():
upstream = b"Upstream permission text\n"
manifest = {"sources": [{"id": "fixture", "files": [
{"local": "upstream/fixture/LICENSE", "sha256": digest(upstream)}]}],
"cases": [{"project": "fixture/case"}]}
files = {name: File(b"notice\n") for name in
["LICENSE", "NOTICE", "CONTRIBUTING.md", "corpus/NOTICE", "corpus/POLICY.md",
"corpus/fixture/case/main.qli", "corpus/fixture/case/kernel.qli",
"corpus/fixture/case/README.md"]}
files["corpus/upstream/fixture/LICENSE"] = File(upstream)
files["corpus/manifest.json"] = File(json.dumps(manifest).encode())
files["Cargo.toml"] = File(b"original manifest")
files["research/semantic-kernel/Cargo.toml"] = File(b"research manifest")
return files
class PackageTests(unittest.TestCase):
def setUp(self):
self.tracked = fixture_files()
self.candidate = {"commit": "1" * 40, "tree": "2" * 40, "clean": True}
self.package = {name: file for name, file in self.tracked.items()
if not name.startswith("research/")}
self.package.update({"Cargo.toml": File(b"normalized manifest"),
"Cargo.toml.orig": self.tracked["Cargo.toml"],
"Cargo.lock": File(b"generated lock"),
".cargo_vcs_info.json": File(json.dumps(
{"git": {"sha1": self.candidate["commit"]}, "path_in_vcs": ""}).encode())})
def test_manifest_drives_counts_and_research_exclusion_is_explicit(self):
record = check_package(self.package, self.tracked, list(self.package), self.candidate)
self.assertEqual(record["upstream_files"], 1)
self.assertEqual(record["translation_files"], 2)
self.assertEqual(record["excluded_tracked_files"], ["research/semantic-kernel/Cargo.toml"])
def test_missing_notice_cannot_be_hidden_by_package_listing(self):
for name in ["NOTICE", "corpus/NOTICE", "corpus/upstream/fixture/LICENSE",
"corpus/fixture/case/main.qli"]:
package = dict(self.package)
del package[name]
with self.subTest(name=name), self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
def test_corrupt_upstream_and_modified_translation_rejected(self):
for name in ["corpus/upstream/fixture/LICENSE", "corpus/fixture/case/kernel.qli"]:
package = dict(self.package, **{name: File(b"changed")})
with self.subTest(name=name), self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
files = fixture_files()
files["corpus/upstream/fixture/LICENSE"] = File(b"corrupt")
with self.assertRaises(DistributionError):
license_inventory(files)
def test_dirty_or_wrong_commit_package_rejected(self):
for vcs in [{"git": {"sha1": "3" * 40}},
{"git": {"sha1": self.candidate["commit"], "dirty": True}}]:
package = dict(self.package)
package[".cargo_vcs_info.json"] = File(json.dumps(vcs).encode())
with self.subTest(vcs=vcs), self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
def test_generated_metadata_mode_and_vcs_subdirectory_rejected(self):
for name in ["Cargo.toml", "Cargo.lock", ".cargo_vcs_info.json", "Cargo.toml.orig"]:
package = dict(self.package)
package[name] = File(package[name].data, 0o777)
with self.subTest(name=name), self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
package = dict(self.package)
package[".cargo_vcs_info.json"] = File(json.dumps(
{"git": {"sha1": self.candidate["commit"]}, "path_in_vcs": "nested"}).encode())
with self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
def test_normalized_package_identity_license_dependencies_cannot_change(self):
original = {"name": "qleisli-core", "version": "0.1.9", "license": "Apache-2.0",
"dependencies": [], "edition": "2024", "rust_version": "1.85"}
compare_package_metadata(original, dict(original, manifest_path="different/path"))
for key, value in [("name", "other"), ("version", "0.2.0"), ("license", "proprietary"),
("dependencies", [{"name": "injected"}]), ("rust_version", "1.99"),
("features", {"default": ["changed"]}),
("readme", "wrong.md"), ("documentation", "https://example.invalid"),
("keywords", ["wrong"]), ("categories", ["wrong"])]:
with self.subTest(key=key), self.assertRaises(DistributionError):
compare_package_metadata(original, dict(original, **{key: value}))
def test_targets_preserve_relative_paths_and_build_options(self):
original = {"manifest_path": "/candidate/Cargo.toml", "targets": [
{"name": "core", "kind": ["lib"], "crate_types": ["lib"], "test": True,
"src_path": "/candidate/src/lib.rs"}]}
packaged = {"manifest_path": "/package/Cargo.toml", "targets": [
dict(original["targets"][0], src_path="/package/src/lib.rs")]}
compare_package_metadata(original, packaged)
for mutation in [{"src_path": "/package/other.rs"}, {"test": False},
{"required-features": ["never-enabled"]}]:
changed = dict(packaged, targets=[dict(packaged["targets"][0], **mutation)])
with self.subTest(mutation=mutation), self.assertRaises(DistributionError):
compare_package_metadata(original, changed)
def test_untracked_content_and_missing_list_entry_rejected(self):
package = dict(self.package, unexpected=File(b"injected"))
with self.assertRaises(DistributionError):
check_package(package, self.tracked, list(package), self.candidate)
with self.assertRaises(DistributionError):
check_package(self.package, self.tracked, ["Cargo.toml"], self.candidate)
class CandidateTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.base = Path(self.temporary.name)
self.root = self.base / "repository"
self.root.mkdir()
self.run_git("init", "-q")
self.run_git("config", "user.name", "Distribution test")
self.run_git("config", "user.email", "distribution-test@example.invalid")
(self.root / "file").write_bytes(b"candidate\r\n")
(self.root / ".gitignore").write_text("ignored\n")
self.run_git("add", ".")
self.run_git("-c", "commit.gpgsign=false", "commit", "-qm", "fixture")
def run_git(self, *args):
return subprocess.check_output(["git", "-C", str(self.root), *args], stderr=subprocess.PIPE)
def test_clean_commit_and_git_archive_keep_exact_bytes(self):
candidate = clean_candidate(self.root)
self.assertTrue(candidate["clean"])
tracked = tracked_files(self.root, candidate["commit"])
self.assertEqual(tracked["file"].data, b"candidate\r\n")
archive = self.base / "source.tar"
archive.write_bytes(self.run_git("-c", "tar.umask=0022", "archive", "--format=tar", "HEAD"))
self.assertEqual(read_archive(archive, expected=tracked), tracked)
def test_unstaged_staged_and_untracked_candidates_rejected(self):
(self.root / "file").write_text("modified")
with self.assertRaises(DistributionError):
clean_candidate(self.root)
self.run_git("add", "file")
with self.assertRaises(DistributionError):
clean_candidate(self.root)
self.run_git("-c", "commit.gpgsign=false", "commit", "-qm", "next")
(self.root / "untracked").write_text("untracked")
with self.assertRaises(DistributionError):
clean_candidate(self.root)
def test_ignored_build_files_are_not_source_archive_contents(self):
(self.root / "ignored").write_text("build output")
candidate = clean_candidate(self.root)
self.assertNotIn("ignored", tracked_files(self.root, candidate["commit"]))
def test_dirty_validation_reports_failure_without_running_builds(self):
(self.root / "untracked").write_text("dirty")
destination = self.base / "report.json"
report = validate(self.root, destination)
self.assertEqual(report["status"], "failed")
self.assertFalse(report["candidate"]["clean"])
self.assertEqual(report["commands"], [])
self.assertEqual(json.loads(destination.read_text()), report)
def test_report_inside_checkout_or_existing_report_rejected(self):
with self.assertRaises(DistributionError):
validate(self.root, self.root / "report.json")
destination = self.base / "report.json"
destination.write_text("keep old record")
with self.assertRaises(DistributionError):
validate(self.root, destination)
self.assertEqual(destination.read_text(), "keep old record")
if __name__ == "__main__":
unittest.main()