"""Selection-unit tests. The real datasets loading test is explicit and optional. Run: python -m unittest discover -s tools -p test_workflow_subsets.py -v """ import copy import importlib.util import io import json import os from pathlib import Path import shutil import tempfile import unittest from unittest import mock import yaml import build_workflow_subsets as build HEADER = [ "file_name", "record_id", "work_id", "recording_start_local", "recording_start_basis", "documented_finish_date", "documented_finish_time", "finish_label_scope", "collection_tier", "is_canonical", "acquisition_protocol_version", "date", "time", "tool", "medium", "support", "dimensions", "duration_seconds", "width_px", "height_px", "orientation", "encoded_frame_rate", "video_codec", "pixel_format", "container", "has_audio", "hub_xet_hash", "original_filename", "provenance_status", "legacy_provenance_path", "legacy_related_references", "evidence_method", "provenance_reference_duration_delta_seconds", "size_bytes", "notes", ] NUMERIC = {"duration_seconds": "float64", "width_px": "int64", "height_px": "int64", "encoded_frame_rate": "float64", "provenance_reference_duration_delta_seconds": "float64", "size_bytes": "int64"} FEATURES = [{"name": "video" if field == "file_name" else field, "dtype": "video" if field == "file_name" else "bool" if field in {"is_canonical", "has_audio"} else NUMERIC.get(field, "large_string")} for field in HEADER] def row(number, protocol="standard-2025-07-13", tier="standard"): r = {field: "" for field in HEADER} r.update(file_name=f"Standard_Time_Lapses/fixture-{number}.mp4", record_id=f"tla-{number:016x}", collection_tier=tier, is_canonical="true", acquisition_protocol_version=protocol, recording_start_basis="not_in_timing_snapshot", width_px="3840", height_px="2160", duration_seconds="11.500000", encoded_frame_rate="30.000000", has_audio="False", size_bytes="123456", hub_xet_hash=f"{number:064x}", notes='preserve "quotes", comma; and\na newline') if tier == "pre_standard": r.update(file_name=f"fixture-{number}.mp4", is_canonical="false", acquisition_protocol_version="") return r def sample_rows(): a, b, c = row(1), row(2, "standard-2026-08-27"), row(3, "standard-2026-08-27") b.update(recording_start_local="2026-09-18T20:48:03-04:00", recording_start_basis="device_filename_interpreted_in_declared_timezone") c.update(recording_start_basis="unknown") return [a, b, c] def fixture(root, rows=None, indent=2): rows = copy.deepcopy(sample_rows() if rows is None else rows) (root / "Pre_Standard_Time_Lapses").mkdir(parents=True) (root / "metadata.csv").write_bytes(build.csv_bytes(HEADER, rows)) (root / build.PRE_SOURCE).write_bytes(build.csv_bytes(HEADER, [row(100, tier="pre_standard")])) canonical = {"config_name": "canonical", "default": True, "features": copy.deepcopy(FEATURES), "data_files": [{"split": "archive", "path": ["metadata.csv", "Standard_Time_Lapses/*.mp4"]}]} pre = {"config_name": "pre_standard", "features": copy.deepcopy(FEATURES), "data_files": [{"split": "archive", "path": [build.PRE_SOURCE, "Pre_Standard_Time_Lapses/*.mp4"]}]} metadata = {"license": "cc-by-nc-4.0", "pretty_name": "Fixture, not a repository snapshot", "dataset_info": [{"config_name": "canonical", "features": copy.deepcopy(FEATURES), "splits": [{"name": "archive", "num_examples": len(rows)}]}, {"config_name": "pre_standard", "features": copy.deepcopy(FEATURES), "splits": [{"name": "archive", "num_examples": 1}]}], "configs": [canonical, pre], "tags": ["fixture"]} header_text = yaml.safe_dump(metadata, sort_keys=False, allow_unicode=True, indent=indent) body = ("# Test fixture\n\nThe Hub exposes two configurations, both using the split name `archive`:\n\n" "Existing text, documentation, and semantics must remain here.\n\n## Browse and load\n\n" "Existing loading instructions remain here.\n") (root / "README.md").write_text("---\n" + header_text + "---\n" + body, encoding="utf-8", newline="\n") # No real videos: decode-disabled native tests must never open these stubs. for r in rows + [row(100, tier="pre_standard")]: p = root / (r["file_name"] if r["collection_tier"] == "standard" else "Pre_Standard_Time_Lapses/" + r["file_name"]) p.parent.mkdir(parents=True, exist_ok=True) p.write_bytes(b"test-only LFS-like pointer; not media\n") return metadata class WorkflowSubsetTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory() self.root = Path(self.temp.name) self.original_card = fixture(self.root) def tearDown(self): self.temp.cleanup() def plan(self): return build.make_plan(self.root) def mutate(self, operation, pre=False): path = self.root / (build.PRE_SOURCE if pre else build.SOURCE) fields, rows = build.read_table(path.read_bytes(), str(path)) operation(rows) path.write_bytes(build.csv_bytes(fields, rows)) def test_exact_disjoint_exhaustive_partition(self): _, out, report = self.plan() a = build.read_table(out["Workflow_Subsets/standard_earlier.csv"], "a")[1] b = build.read_table(out["Workflow_Subsets/standard_individual_recordings.csv"], "b")[1] self.assertEqual(a, sample_rows()[:1]) self.assertEqual(b, sample_rows()[1:]) self.assertEqual(report["standard_rows"], 3) self.assertEqual(report["pre_standard_rows"], 1) def test_all_35_columns_and_values_preserved(self): _, out, _ = self.plan() expected = {r["record_id"]: r for r in sample_rows()} for name in build.SUBSETS: fields, rows = build.read_table(out[f"Workflow_Subsets/{name}.csv"], name) self.assertEqual(fields, HEADER) for r in rows: self.assertEqual(r, expected[r["record_id"]]) def test_unknown_start_and_work_id_are_not_excluded(self): _, out, _ = self.plan() rows = build.read_table(out["Workflow_Subsets/standard_individual_recordings.csv"], "view")[1] unknown = next(r for r in rows if r["record_id"] == "tla-0000000000000003") self.assertEqual(unknown["recording_start_local"], "") self.assertEqual(unknown["recording_start_basis"], "unknown") self.assertEqual(unknown["work_id"], "") def test_date_and_rec_suffix_do_not_classify(self): def change(rows): rows[0]["file_name"] = "Standard_Time_Lapses/2099-01-01.Rec99.mp4" rows[0]["date"] = "2099-01-01" rows[1]["file_name"] = "Standard_Time_Lapses/2000-01-01.mp4" rows[1]["date"] = "2000-01-01" self.mutate(change) _, outputs, _ = self.plan() earlier = build.read_table(outputs["Workflow_Subsets/standard_earlier.csv"], "a")[1] self.assertEqual(earlier[0]["record_id"], "tla-0000000000000001") def test_unknown_protocol_rejected(self): self.mutate(lambda rows: rows[1].update(acquisition_protocol_version="new-unreviewed-protocol")) with self.assertRaisesRegex(build.ContractError, "Unrecognized"): self.plan() def test_blank_protocol_rejected(self): self.mutate(lambda rows: rows[1].update(acquisition_protocol_version="")) with self.assertRaisesRegex(build.ContractError, "Unrecognized"): self.plan() def test_duplicate_id_rejected(self): self.mutate(lambda rows: rows[1].update(record_id=rows[0]["record_id"])) with self.assertRaisesRegex(build.ContractError, "Duplicate record"): self.plan() def test_cross_tier_id_collision_rejected(self): self.mutate(lambda rows: rows[0].update(record_id="tla-0000000000000001"), pre=True) with self.assertRaisesRegex(build.ContractError, "Duplicate record"): self.plan() def test_duplicate_media_path_rejected(self): self.mutate(lambda rows: rows[1].update(file_name=rows[0]["file_name"])) with self.assertRaisesRegex(build.ContractError, "Duplicate media"): self.plan() def test_wrong_tier_rejected(self): self.mutate(lambda rows: rows[0].update(collection_tier="pre_standard")) with self.assertRaisesRegex(build.ContractError, "Wrong collection"): self.plan() def test_noncanonical_standard_rejected(self): self.mutate(lambda rows: rows[0].update(is_canonical="false")) with self.assertRaisesRegex(build.ContractError, "Wrong canonical"): self.plan() def test_pre_standard_protocol_rejected(self): self.mutate(lambda rows: rows[0].update(acquisition_protocol_version="standard-2025-07-13"), pre=True) with self.assertRaisesRegex(build.ContractError, "Pre-Standard record"): self.plan() def test_traversal_and_glob_paths_rejected(self): for bad in ["../outside.mp4", "Standard_Time_Lapses/../outside.mp4", "Standard_Time_Lapses/*.mp4"]: with self.subTest(path=bad): source = (self.root / build.SOURCE).read_bytes() self.mutate(lambda rows: rows[0].update(file_name=bad)) with self.assertRaises(build.ContractError): self.plan() (self.root / build.SOURCE).write_bytes(source) def test_malformed_csv_rejected(self): path = self.root / build.SOURCE path.write_bytes(path.read_bytes() + b"malformed,short,row\n") with self.assertRaisesRegex(build.ContractError, "malformed CSV"): self.plan() def test_duplicate_csv_columns_rejected(self): with self.assertRaisesRegex(build.ContractError, "duplicate CSV"): build.read_table(b"a,a\n1,2\n", "bad") def test_existing_configs_and_default_preserved(self): _, out, _ = self.plan() card = build.card_data(build.split_card(out["README.md"].decode())[0]) for key in ["configs", "dataset_info"]: self.assertEqual(card[key][:2], self.original_card[key]) self.assertTrue(card["configs"][0]["default"]) self.assertFalse(any(entry.get("default") for entry in card["configs"][2:])) self.assertEqual(card["license"], self.original_card["license"]) self.assertEqual(card["tags"], ["fixture"]) def test_exact_media_lists_and_native_predicates(self): _, out, _ = self.plan() card = build.card_data(build.split_card(out["README.md"].decode())[0]) configs = build.named_entries(card, "configs") for name, protocol in build.SUBSETS.items(): cfg = configs[name] rows = build.read_table(out[f"Workflow_Subsets/{name}.csv"], name)[1] self.assertEqual(cfg["data_files"], [{"split": "archive", "path": ["metadata.csv"] + [r["file_name"] for r in rows]}]) self.assertEqual(cfg["filters"], [["acquisition_protocol_version", "=", protocol]]) self.assertEqual(cfg["features"], FEATURES) self.assertNotIn("*", str(cfg["data_files"])) def test_no_train_test_partition_created(self): _, out, _ = self.plan() card = build.card_data(build.split_card(out["README.md"].decode())[0]) for cfg in card["configs"]: self.assertEqual([r["split"] for r in cfg["data_files"]], ["archive"]) def test_rebuild_is_byte_idempotent(self): before, outputs, _ = self.plan() build.install_plan(self.root, before, outputs) _, again, _ = self.plan() self.assertEqual(outputs, again) build.install_plan(self.root, {p: (self.root / p).read_bytes() for p in before}, again) self.assertEqual({p: (self.root / p).read_bytes() for p in outputs}, outputs) def test_source_indexes_and_unrelated_evidence_untouched(self): evidence = self.root / "Standard_Time_Lapses/Provenance/frozen.json" evidence.parent.mkdir(parents=True, exist_ok=True) evidence.write_bytes(b'{"keep":"unchanged"}\n') before, outputs, _ = self.plan() build.install_plan(self.root, before, outputs) self.assertEqual((self.root / build.SOURCE).read_bytes(), before[build.SOURCE]) self.assertEqual((self.root / build.PRE_SOURCE).read_bytes(), before[build.PRE_SOURCE]) self.assertEqual(evidence.read_bytes(), b'{"keep":"unchanged"}\n') def test_missing_or_changed_source_rejected_before_write(self): before, outputs, _ = self.plan() original_readme = (self.root / "README.md").read_bytes() (self.root / build.SOURCE).write_bytes(before[build.SOURCE] + b"\n") with self.assertRaisesRegex(build.ContractError, "Concurrent source"): build.install_plan(self.root, before, outputs) self.assertEqual((self.root / "README.md").read_bytes(), original_readme) self.assertFalse((self.root / "Workflow_Subsets").exists()) def test_write_failure_rolls_back_completed_replacements(self): before, outputs, _ = self.plan() original_replace = build.os.replace calls = [0] def fail_second(source, dest): calls[0] += 1 if calls[0] == 2: raise OSError("simulated disk failure") original_replace(source, dest) with mock.patch.object(build.os, "replace", side_effect=fail_second): with self.assertRaisesRegex(OSError, "disk failure"): build.install_plan(self.root, before, outputs) self.assertEqual((self.root / "README.md").read_bytes(), before["README.md"]) self.assertFalse((self.root / "Workflow_Subsets/standard_earlier.csv").exists()) def test_unmanaged_output_not_overwritten(self): path = self.root / "Workflow_Subsets/standard_earlier.csv" path.parent.mkdir() path.write_bytes(b"unrelated existing data") with self.assertRaisesRegex(build.ContractError, "unmanaged output"): self.plan() def test_duplicate_yaml_key_rejected(self): path = self.root / "README.md" path.write_text(path.read_text().replace("license: cc-by-nc-4.0", "license: cc-by-nc-4.0\nlicense: other"), encoding="utf-8", newline="\n") with self.assertRaisesRegex(build.ContractError, "Duplicate YAML"): self.plan() def test_damaged_marker_rejected(self): sources, outputs, _ = self.plan() build.install_plan(self.root, sources, outputs) path = self.root / "README.md" path.write_text(path.read_text().replace("# END generated workflow-subsets configs", "# damaged"), encoding="utf-8", newline="\n") with self.assertRaisesRegex(build.ContractError, "Damaged"): self.plan() def test_source_count_mismatch_requires_normal_ingest_completion(self): self.mutate(lambda rows: rows.append(row(4, "standard-2026-08-27"))) with self.assertRaisesRegex(build.ContractError, "stale"): self.plan() def test_growth_updates_all_generated_views(self): sources, outputs, _ = self.plan() build.install_plan(self.root, sources, outputs) self.mutate(lambda rows: rows.append(row(4, "standard-2026-08-27"))) # Normal ingestion has also updated the existing canonical count. p = self.root / "README.md" p.write_text(p.read_text().replace("num_examples: 3", "num_examples: 4", 1), encoding="utf-8", newline="\n") _, new_outputs, report = self.plan() self.assertEqual(report["subsets"]["standard_individual_recordings"]["rows"], 3) self.assertEqual(len(build.read_table(new_outputs["Workflow_Subsets/standard_individual_recordings.csv"], "b")[1]), 3) def test_false_old_configuration_count_removed(self): _, out, _ = self.plan() text = out["README.md"].decode() self.assertNotIn("The Hub exposes two configurations", text) self.assertIn("Their totals must not be added", text) self.assertIn("Existing loading instructions remain here.", text) def test_csv_exports_are_not_extra_native_input_files(self): _, out, _ = self.plan() card = build.card_data(build.split_card(out["README.md"].decode())[0]) for cfg in card["configs"]: self.assertNotIn("Workflow_Subsets/", str(cfg["data_files"])) def test_symlink_output_cannot_escape_checkout(self): with tempfile.TemporaryDirectory() as outside: link = self.root / "Workflow_Subsets" if os.name == "nt": # Junctions exercise real path redirection without requiring # Windows Developer Mode or symbolic-link administrator rights. import _winapi _winapi.CreateJunction(outside, str(link)) else: link.symlink_to(outside, target_is_directory=True) with self.assertRaisesRegex(build.ContractError, "escapes checkout"): self.plan() def test_required_native_check_reports_missing_dependency(self): real_import = __import__ def unavailable(name, *args, **kwargs): if name == "datasets": raise ImportError("fixture missing dependency") return real_import(name, *args, **kwargs) with mock.patch("builtins.__import__", side_effect=unavailable): with self.assertRaisesRegex(build.ContractError, "Native loading NOT tested"): build.check_native_loading(self.root) @unittest.skipUnless(importlib.util.find_spec("datasets") is not None, "datasets is not installed; native loading NOT verified") def test_native_named_configuration_loading_without_video_reads(self): sources, outputs, _ = self.plan() build.install_plan(self.root, sources, outputs) result = build.check_native_loading(self.root) self.assertEqual(result["status"], "passed") self.assertEqual(result["video_payload_reads"], 0) class RepositoryWorkflowViewTests(unittest.TestCase): @unittest.skipUnless( (Path(__file__).resolve().parents[1] / "metadata.csv").is_file() and importlib.util.find_spec("datasets") is not None, "Full repository and datasets are required; native repository loading NOT run", ) def test_native_current_repository_configurations_without_video_reads(self): root = Path(__file__).resolve().parents[1] result = build.check_native_loading(root) self.assertEqual(result["status"], "passed") self.assertEqual(result["video_payload_reads"], 0) @unittest.skipUnless((Path(__file__).resolve().parents[1] / "metadata.csv").is_file(), "Full repository indexes are not mounted; repository-state check NOT run") def test_generated_views_match_current_repository(self): root = Path(__file__).resolve().parents[1] build.validate_source_contract(root) _, outputs, _ = build.make_plan(root) for relative, expected in outputs.items(): with self.subTest(path=relative): self.assertTrue((root / relative).is_file(), "Generated output missing") self.assertEqual((root / relative).read_bytes(), expected, "Run the workflow subset generator after the usual ingest projections") if __name__ == "__main__": unittest.main()