#!/usr/bin/env python3 """Self-contained tests for exact-revision validation-file binding.""" from __future__ import annotations import csv import hashlib import importlib.util import json import subprocess import sys import tempfile import threading import unittest from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from types import ModuleType TOOLS = Path(__file__).resolve().parent REVISION = "a" * 40 OTHER_REVISION = "b" * 40 PAYLOAD = b"file_name,record_id\nexample.mp4,tla-0123456789abcdef\n" def load_module(name: str, path: Path) -> ModuleType: spec = importlib.util.spec_from_file_location(name, path) if spec is None or spec.loader is None: raise RuntimeError(f"unable to load {path}") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module capture = load_module("capture_hub_inventory", TOOLS / "capture_hub_inventory.py") relationships = load_module( "validate_fragment_relationships", TOOLS / "validate_fragment_relationships.py", ) class FixtureHandler(BaseHTTPRequestHandler): protocol_version = "HTTP/1.1" def do_GET(self) -> None: # noqa: N802 if self.headers.get("Accept-Encoding") != "identity": self.send_error(400, "identity content encoding required") return if self.path == "/resolve": self.send_response(302) self.send_header("Location", f"http://127.0.0.1:{self.server.server_port}/payload") self.send_header("X-Repo-Commit", REVISION) self.send_header("Content-Length", "0") self.end_headers() return if self.path == "/wrong-commit": self.send_response(200) self.send_header("X-Repo-Commit", OTHER_REVISION) self.send_header("Content-Length", str(len(PAYLOAD))) self.end_headers() self.wfile.write(PAYLOAD) return if self.path == "/payload": self.send_response(200) self.send_header("Content-Encoding", "identity") self.send_header("Content-Length", str(len(PAYLOAD))) self.end_headers() self.wfile.write(PAYLOAD) return self.send_error(404) def log_message(self, format: str, *args: object) -> None: del format, args class InventoryBindingTests(unittest.TestCase): @classmethod def setUpClass(cls) -> None: cls.server = ThreadingHTTPServer(("127.0.0.1", 0), FixtureHandler) cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True) cls.thread.start() cls.base_url = f"http://127.0.0.1:{cls.server.server_port}" @classmethod def tearDownClass(cls) -> None: cls.server.shutdown() cls.server.server_close() cls.thread.join(timeout=5) def test_capture_records_exact_byte_receipt_across_redirect(self) -> None: receipt = capture.read_validation_file( f"{self.base_url}/resolve", REVISION, timeout=5, retries=0, max_bytes=1024, ) self.assertEqual(set(receipt), {"sha256", "size", "repoCommit"}) self.assertEqual(receipt["size"], len(PAYLOAD)) self.assertEqual(receipt["repoCommit"], REVISION) def test_capture_rejects_wrong_commit_and_oversize_body(self) -> None: with self.assertRaises(RuntimeError): capture.read_validation_file( f"{self.base_url}/wrong-commit", REVISION, timeout=5, retries=0, max_bytes=1024, ) with self.assertRaises(RuntimeError): capture.read_validation_file( f"{self.base_url}/resolve", REVISION, timeout=5, retries=0, max_bytes=len(PAYLOAD) - 1, ) def test_validator_requires_matching_hash_size_and_commit(self) -> None: receipt = capture.read_validation_file( f"{self.base_url}/resolve", REVISION, timeout=5, retries=0, max_bytes=1024, ) inventory = {"validationFiles": {"metadata.csv": receipt}} with tempfile.TemporaryDirectory(prefix="tla-binding-test-") as temp_dir: metadata = Path(temp_dir) / "metadata.csv" metadata.write_bytes(PAYLOAD) errors: list[str] = [] relationships.validate_pinned_metadata( inventory, metadata, REVISION, errors, ) self.assertEqual(errors, []) metadata.write_bytes(PAYLOAD + b"tampered") errors = [] relationships.validate_pinned_metadata( inventory, metadata, REVISION, errors, ) self.assertTrue(any("differs" in error for error in errors)) errors = [] relationships.validate_pinned_metadata( inventory, metadata, OTHER_REVISION, errors, ) self.assertTrue(any("source_hub_revision" in error for error in errors)) def test_validator_requires_top_level_inventory_revision(self) -> None: errors: list[str] = [] relationships.validate_inventory_revision( {"sha": REVISION}, REVISION, errors, ) self.assertEqual(errors, []) relationships.validate_inventory_revision( {"sha": OTHER_REVISION}, REVISION, errors, ) self.assertTrue(any("inventory commit" in error for error in errors)) def test_full_relationship_validator_accepts_only_bound_metadata(self) -> None: metadata_fields = ["file_name", "record_id", "hub_xet_hash"] metadata_rows: list[dict[str, str]] = [] relationship_rows: list[dict[str, str]] = [] canonical_by_set: dict[str, list[str]] = {} record_counter = 1 for group_index, cardinality in enumerate((2, 2, 2, 6, 10), start=1): set_label = ( f"2026-08-{20 + group_index:02d}.000{group_index}." "BallpointPen.Ink.Paper.9x12" ) canonical_by_set[set_label] = [] for position in range(1, cardinality + 1): record_id = f"tla-{record_counter:016x}" record_counter += 1 file_path = ( f"Standard_Time_Lapses/{set_label}.Rec{position:02d}.mp4" ) xet_hash = hashlib.sha256( f"fixture-xet:{file_path}".encode("utf-8") ).hexdigest() metadata_rows.append( { "file_name": file_path, "record_id": record_id, "hub_xet_hash": xet_hash, } ) canonical_by_set[set_label].append(record_id) relationship_rows.append( { "fragment_set_label": set_label, "object_role": "canonical_fragment", "record_id": record_id, "file_path": file_path, "sha256": hashlib.sha256( f"fixture-sha:{file_path}".encode("utf-8") ).hexdigest(), "hub_xet_hash": xet_hash, "size_bytes": str(1000 + record_counter), "sequence_position": str(position), "sequence_count": str(cardinality), "sequence_completeness": "owner_confirmed_complete", "source_record_ids": "", "derivative_coverage": "", "evidence_state": ( "owner-confirmed; boundary-frame-verified; " "checksum-computed; media-probed; demux-verified; " "sampled-decode-verified" ), "source_hub_revision": REVISION, "notes": "", } ) set_labels = list(canonical_by_set) derivative_specs = [ (set_labels[0], canonical_by_set[set_labels[0]], "complete_sequence"), (set_labels[1], canonical_by_set[set_labels[1]], "complete_sequence"), (set_labels[2], canonical_by_set[set_labels[2]][1:2], "partial_sequence"), (set_labels[2], canonical_by_set[set_labels[2]][1:2], "partial_sequence"), (set_labels[1], canonical_by_set[set_labels[1]], "complete_sequence"), ] for derivative_index, (set_label, source_ids, coverage) in enumerate( derivative_specs, start=1, ): file_path = ( "Standard_Time_Lapses/Provenance/2026-08-27/InShot/" f"fixture-{derivative_index}.mp4" ) relationship_rows.append( { "fragment_set_label": set_label, "object_role": "noncanonical_inshot_derivative", "record_id": "", "file_path": file_path, "sha256": hashlib.sha256( f"fixture-sha:{file_path}".encode("utf-8") ).hexdigest(), "hub_xet_hash": hashlib.sha256( f"fixture-xet:{file_path}".encode("utf-8") ).hexdigest(), "size_bytes": str(2000 + derivative_index), "sequence_position": "", "sequence_count": str(len(canonical_by_set[set_label])), "sequence_completeness": "owner_confirmed_complete", "source_record_ids": ";".join(source_ids), "derivative_coverage": coverage, "evidence_state": ( "sampled-frame-verified; duration-arithmetic-verified; " "checksum-computed; media-probed; demux-verified; " "sampled-decode-verified" ), "source_hub_revision": REVISION, "notes": "", } ) self.assertEqual(len(metadata_rows), 22) self.assertEqual(len(relationship_rows), 27) with tempfile.TemporaryDirectory(prefix="tla-validator-test-") as temp_dir: temp = Path(temp_dir) metadata_path = temp / "metadata.csv" relationships_path = temp / "relationships.csv" inventory_path = temp / "inventory.json" with metadata_path.open("w", encoding="utf-8", newline="") as handle: writer = csv.DictWriter( handle, fieldnames=metadata_fields, lineterminator="\n", ) writer.writeheader() writer.writerows(metadata_rows) with relationships_path.open("w", encoding="utf-8", newline="") as handle: writer = csv.DictWriter( handle, fieldnames=relationships.FIELDS, lineterminator="\n", ) writer.writeheader() writer.writerows(relationship_rows) metadata_bytes = metadata_path.read_bytes() inventory = { "sha": REVISION, "siblings": [ { "rfilename": row["file_path"], "size": int(row["size_bytes"]), "lfs": { "size": int(row["size_bytes"]), "sha256": row["sha256"], }, "xetHash": row["hub_xet_hash"], "repoCommit": REVISION, } for row in relationship_rows ], "validationFiles": { "metadata.csv": { "sha256": hashlib.sha256(metadata_bytes).hexdigest(), "size": len(metadata_bytes), "repoCommit": REVISION, } }, } inventory_path.write_text( json.dumps(inventory), encoding="utf-8", ) command = [ sys.executable, str(TOOLS / "validate_fragment_relationships.py"), "--relationships", str(relationships_path), "--metadata", str(metadata_path), "--repo-inventory-json", str(inventory_path), ] completed = subprocess.run( command, check=False, capture_output=True, text=True, encoding="utf-8", ) self.assertEqual(completed.returncode, 0, completed.stdout + completed.stderr) metadata_path.write_bytes(metadata_bytes + b"\n") completed = subprocess.run( command, check=False, capture_output=True, text=True, encoding="utf-8", ) self.assertNotEqual(completed.returncode, 0) self.assertIn("differs from the pinned repository", completed.stdout) if __name__ == "__main__": unittest.main()