tools/test_workflow_subsets.py

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