| """Negative admission controls against published DSV4.1 source artifacts.""" |
|
|
| import copy |
| import json |
| import shutil |
| import tempfile |
| import unittest |
| from pathlib import Path |
| import dsv41 |
| import manage_dataset |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| class AdmissionTests(unittest.TestCase): |
| def setUp(self): |
| records = json.loads((ROOT / "catalog/fpm.json").read_text())["records"] |
| self.records = [ |
| r for r in records if r["sha256"] in dsv41.REVIEWED_SOURCES |
| ] |
| self.assertTrue(self.records) |
|
|
| def test_every_reviewed_payload(self): |
| for row in self.records: |
| self.assertEqual(dsv41.validate_catalog_record(ROOT, row), 7) |
| profiles = { |
| dsv41.identity(ROOT / r["path"])["execution_profile"] for r in self.records |
| } |
| self.assertEqual(profiles, {"full", "decoder_bounded"}) |
|
|
| def test_native_source_artifact_not_git_revision(self): |
| row = next(copy.deepcopy(r) for r in self.records if dsv41.REVIEWED_SOURCES[r['sha256']]['source_pr'] == 304) |
| for key, value in [('source_revision_kind', 'aisimulate_producer_git_commit'), ('source_kind', 'committed_calibration')]: |
| changed = copy.deepcopy(row) |
| changed[key] = value |
| with self.assertRaises(ValueError): |
| dsv41.validate_catalog_record(ROOT, changed) |
|
|
| def test_manifests_match_published_schemas(self): |
| index = json.loads((ROOT / "catalog/index.json").read_text()) |
| checked = 0 |
| for relative in [*index["configuration_manifests"], *index["history_manifests"]]: |
| manifest = json.loads((ROOT / relative).read_text()) |
| if not manifest["fpm"] or not all(e["sha256"] in dsv41.REVIEWED_SOURCES for e in manifest["fpm"]): |
| continue |
| bundle = json.loads((ROOT / manifest["measurements"]["manifest_path"]).read_text()) |
| self.assertEqual(manage_dataset.schema_violations(ROOT, "configuration_manifest", manifest), [], relative) |
| self.assertEqual(manage_dataset.schema_violations(ROOT, "measurement_manifest", bundle), [], relative) |
| checked += 1 |
| self.assertEqual(checked, 10) |
|
|
| def test_schema_rejects_nonconforming_manifest(self): |
| path = next( |
| ROOT / r["configuration_path"] / "manifest.json" |
| for r in self.records if r["system"] == "h200_sxm" |
| ) |
| manifest = json.loads(path.read_text()) |
| for mutate in ( |
| lambda m: m.update(snapshot_id="native-6f01f78b10be-pr304"), |
| lambda m: m.pop("collected_by"), |
| lambda m: m.pop("producer_revisions"), |
| lambda m: m["provenance"].update(unreviewed_field="x"), |
| ): |
| changed = copy.deepcopy(manifest) |
| mutate(changed) |
| self.assertTrue(manage_dataset.schema_violations(ROOT, "configuration_manifest", changed)) |
|
|
| def test_changed_source_digest(self): |
| row = copy.deepcopy(self.records[0]) |
| row["sha256"] = "0" * 64 |
| with self.assertRaises(ValueError): |
| dsv41.validate_catalog_record(ROOT, row) |
|
|
| def test_wrong_schema_and_topology(self): |
| for key, value in [("schema_version", 6), ("tp", 128)]: |
| row = copy.deepcopy(self.records[0]) |
| row[key] = value |
| with self.assertRaises(ValueError): |
| dsv41.validate_catalog_record(ROOT, row) |
|
|
| def test_execution_profile_cannot_be_swapped(self): |
| row = self.records[0] |
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| for key in ("path", "metadata_path"): |
| dest = root / row[key] |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(ROOT / row[key], dest) |
| dest = root / row["metadata_path"] |
| meta = json.loads(dest.read_text()) |
| meta["configuration_selector"]["execution_profile"] = "another-profile" |
| dest.write_text(json.dumps(meta)) |
| with self.assertRaises(ValueError): |
| dsv41.validate_catalog_record(root, row) |
|
|
| def test_archive_cannot_be_promoted(self): |
| archives = [r for r in self.records if dsv41.REVIEWED_SOURCES[r["sha256"]]["source_pr"] == 158] |
| for record in archives: |
| row = copy.deepcopy(record) |
| row.update(snapshot_status="current", role="primary") |
| with self.assertRaises(ValueError): |
| dsv41.validate_catalog_record(ROOT, row) |
|
|
|
|
|
|
|
|
| class ProducerProvenanceTests(unittest.TestCase): |
| def test_producer_git_package_missing_and_mixed(self): |
| commit = "40c9541bb0bb593f403345efde01eafba436543c" |
| package = "installed:aisimulate==0.12.0:record-sha256:" + "a" * 64 |
| for originals, expected, status in [ |
| ([{"aic_revision": commit}], commit, "recorded"), |
| ([{"aic_revision": package}], None, "unknown"), |
| ([{}], None, "unknown"), |
| ([{"aic_revision": commit}, {}], None, "unknown"), |
| ([{"aic_revision": commit}, {"aic_revision": "b" * 40}], None, "mixed"), |
| ([{"aic_revision": commit}, {"aic_revision": package}], None, "mixed"), |
| ]: |
| identity = dsv41.producer_identity(originals) |
| self.assertEqual(identity["aisim_commit"], expected) |
| self.assertEqual(identity["aisim_commit_status"], status) |
| self.assertEqual(dsv41.producer_identity([{"aic_revision": package}])["producer_revisions"], [package]) |
|
|
| def test_published_snapshot_distinguishes_archive_and_producer(self): |
| index = dsv41.read(ROOT / "catalog/index.json") |
| for path in index["history_manifests"] + index["configuration_manifests"]: |
| manifest = dsv41.read(ROOT / path) |
| if not manifest["fpm"] or not all(e["sha256"] in dsv41.REVIEWED_SOURCES for e in manifest["fpm"]): |
| continue |
| dsv41.validate_snapshot(ROOT, manifest) |
| self.assertNotEqual(manifest["aisim_commit"], manifest["provenance"]["source_revision"]) |
| changed = copy.deepcopy(manifest) |
| changed["aisim_commit"] = manifest["provenance"]["source_revision"] |
| changed["aisim_commit_status"] = "recorded" |
| with self.assertRaisesRegex(ValueError, "Producer identity mismatch"): |
| dsv41.validate_snapshot(ROOT, changed) |
|
|
| def test_runtime_projection_preserves_collection_not_predictions(self): |
| from ingest_dsv41 import collection_projection |
| source = {"collection_provenance": { |
| "runtime": {"image_manifest_digest": "sha256:" + "a" * 64, |
| "model_revision": "b" * 40, "source_qualification_sha256": "c" * 64}, |
| "observed_packages": {"torch": "2.13.0+cu130"}, |
| "selection_policy": "first geometry-qualified fixed attempt by index; no latency selection", |
| "calibration": {"planned_attempts": 1450, "qualified_attempts": 1224, |
| "exact_static_self_queries": 145, "mape_percent": 0.5}, |
| "heldout_validation": {"mape_percent": 1.0}, |
| "prediction_validation": {"predictor_commit": "d" * 40}, |
| }, "private_publication_provenance": { |
| "runtime_pair": {"calibration_runtime_identity": {"model_revision": "b" * 40}}, |
| "selection_policy": "first qualified", "reader": {"head": "d" * 40}, |
| "planned_geometries": 145, |
| }} |
| projected = collection_projection(source) |
| c = projected["collection_provenance"] |
| for key in ("runtime", "observed_packages", "selection_policy"): |
| self.assertEqual(c[key], source["collection_provenance"][key]) |
| self.assertEqual(c["calibration"], {"planned_attempts": 1450, "qualified_attempts": 1224}) |
| self.assertNotIn("prediction_validation", c) |
| self.assertNotIn("heldout_validation", c) |
| self.assertNotIn("reader", projected["private_publication_provenance"]) |
| self.assertEqual(dsv41.recorded_model_revision(projected), "b" * 40) |
| projected["private_publication_provenance"]["runtime_pair"]["calibration_runtime_identity"]["model_revision"] = "c" * 40 |
| with self.assertRaisesRegex(ValueError, "Conflicting recorded model"): |
| dsv41.recorded_model_revision(projected) |
|
|
| def test_published_runtime_provenance(self): |
| records = dsv41.read(ROOT / "catalog/fpm.json")["records"] |
| for row in records: |
| if dsv41.REVIEWED_SOURCES.get(row["sha256"],{}).get("source_pr") != 232: |
| continue |
| meta = dsv41.read(ROOT / row["metadata_path"]) |
| self.assertEqual(row["model_revision"], "fb2764a5cf321eaa5070ca8f9e892818f477c16d") |
| collection = meta.get("collection_provenance") |
| if collection: |
| self.assertTrue(collection["runtime"]["image_manifest_digest"].startswith("sha256:")) |
| self.assertTrue(collection["runtime"]["source_qualification_sha256"]) |
| self.assertEqual(collection["observed_packages"]["nvidia-nccl-cu13"], "2.30.7") |
| self.assertEqual(collection["calibration"]["planned_attempts"], 1450) |
| self.assertGreater(collection["calibration"]["qualified_attempts"], 0) |
| self.assertIn("first geometry-qualified", collection["selection_policy"]) |
| else: |
| publication = meta["private_publication_provenance"] |
| self.assertEqual(publication["planned_geometries"], 145) |
| self.assertTrue(publication["runtime_pair"]["calibration_runtime_identity"]["image_manifest_digest"]) |
| self.assertIn("first geometry-qualified", publication["selection_policy"]) |
| serialized = json.dumps(meta) |
| for forbidden in ('"mape_percent"', '"prediction_validation"', '"predicted_geometries"', '"exact_static_self_queries"'): |
| self.assertNotIn(forbidden, serialized) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
