| """Public artifact contract: sanitized scalars only, no private material.""" |
| import hashlib |
| import json |
| from pathlib import Path |
| import subprocess |
| import sys |
| import tempfile |
| import unittest |
|
|
| HERE = Path(__file__).resolve().parent |
| ROOT = HERE.parent |
| EXPORT = HERE / "export_evidence.py" |
| EVIDENCE = ROOT / "results" / "processed" / "evidence.json" |
|
|
|
|
| class EvidenceExportTests(unittest.TestCase): |
| def setUp(self): |
| self.assertIsNotNone(EXPORT.exists() and EXPORT, "export script missing") |
| self.document = json.loads(EVIDENCE.read_text()) |
| self.raw = EVIDENCE.read_text() |
|
|
| def test_no_private_paths_credentials_or_prompts_escape(self): |
| for marker in ("/Users/", "/Volumes/", "sk-", "hf_", "Bearer ", "api-key", |
| "api_key", "BEGIN PRIVATE", "ssh-rsa"): |
| self.assertNotIn(marker, self.raw, f"leaked {marker}") |
| |
| longest = max((len(v) for v in self.document["checkpoint"]["quantized_rows_verified"]), default=0) |
| self.assertLess(longest, 200) |
|
|
| def test_qualification_flags_are_explicitly_negative(self): |
| q = self.document["qualification"] |
| self.assertFalse(q["minimum_20_tps_met"]) |
| self.assertFalse(q["actual_near_limit_context_met"]) |
| self.assertFalse(q["peer_review_claimed"]) |
| self.assertFalse(q["ranked_intelligence_claimed"]) |
|
|
| def test_every_numeric_metric_is_finite_and_every_flag_boolean(self): |
| def walk(node, path="root"): |
| if isinstance(node, dict): |
| for key, value in node.items(): |
| walk(value, f"{path}.{key}") |
| elif isinstance(node, list): |
| for i, value in enumerate(node): |
| walk(value, f"{path}[{i}]") |
| elif isinstance(node, float): |
| self.assertFalse(node != node or node in (float("inf"), float("-inf")), path) |
| walk(self.document) |
|
|
| def test_failed_and_timed_out_runs_are_retained_not_dropped(self): |
| repairs = self.document["speculative_repairs"] |
| self.assertEqual(len(repairs), 2) |
| for run in repairs: |
| self.assertTrue(run["timed_out"]) |
| self.assertFalse(run["completed"]) |
| self.assertFalse(run["independent_gate_pass"]) |
| self.assertIsNot(run["elapsed_s"], None) |
|
|
| def test_all_four_synthetic_conditions_and_parity_are_present(self): |
| conditions = self.document["synthetic_conditions"] |
| self.assertEqual(len(conditions), 4) |
| for condition in conditions: |
| self.assertTrue(condition["greedy_token_parity"]) |
| self.assertEqual(len(condition["trials"]), 4) |
| labels = [trial["label"] for trial in condition["trials"]] |
| self.assertEqual(sum("plain" in x for x in labels), 2) |
| self.assertGreaterEqual(sum(("dflash" in x) or ("mtp" in x) for x in labels), 2) |
|
|
| def test_memory_policy_records_refusal_then_success_at_same_input(self): |
| policy = self.document["memory_policy"] |
| self.assertFalse(policy["refusal_before_switch"]["completed"]) |
| self.assertTrue(policy["after_supported_switch_off"]["completed"]) |
| self.assertFalse(policy["after_supported_switch_off"]["prompt_reduced"]) |
| self.assertEqual(policy["effective_child_setting"][0]["system_memory_guard"], "0") |
|
|
| def test_protocol_matrix_covers_both_endpoints_and_three_dialects(self): |
| matrix = self.document["protocol_matrix"] |
| for kind in ("non_streaming", "streaming"): |
| rows = matrix[kind] |
| self.assertEqual(len(rows), 6, kind) |
| self.assertEqual({r["endpoint"] for r in rows}, {"native", "magpie"}) |
| self.assertEqual({r["protocol"] for r in rows}, {"chat", "responses", "anthropic"}) |
| self.assertTrue(all(r["passed"] for r in rows), kind) |
|
|
| def test_export_refuses_when_a_private_marker_would_escape(self): |
| fable_root = ROOT.parent.parent / "fable" |
| real_local = ROOT.parent.parent / "coder390" / "mlx-native" / "raw" |
| real_guard = fable_root / "memory-guard-fix" / "raw" |
| with tempfile.TemporaryDirectory() as temp: |
| fake = Path(temp) / "poisoned" |
| fake.mkdir() |
| |
| for source in (fable_root / "deployment" / "raw").glob("*.json"): |
| (fake / source.name).write_bytes(source.read_bytes()) |
| |
| |
| doc = json.loads((fake / "final-cutover-audit.json").read_text()) |
| doc["runtime_profile"] = "/Users/someone/private" |
| (fake / "final-cutover-audit.json").write_text(json.dumps(doc)) |
| code = EXPORT.read_text().replace( |
| 'LOCAL = ROOT / "coder390" / "mlx-native" / "raw"', |
| f'LOCAL = Path({str(real_local)!r})', |
| ).replace( |
| 'FABLE = ROOT / "fable" / "deployment" / "raw"', |
| f'FABLE = Path({str(fake)!r})', |
| ).replace( |
| 'GUARD = ROOT / "fable" / "memory-guard-fix" / "raw"', |
| f'GUARD = Path({str(real_guard)!r})', |
| ) |
| script = Path(temp) / "export.py" |
| script.write_text(code) |
| result = subprocess.run([sys.executable, str(script), str(Path(temp) / "out.json")], |
| capture_output=True, text=True) |
| self.assertNotEqual(result.returncode, 0, "poisoned export succeeded") |
| self.assertIn("private marker", (result.stdout + result.stderr).lower()) |
| self.assertFalse((Path(temp) / "out.json").exists()) |
|
|
|
|
| class ChecksumTests(unittest.TestCase): |
| def test_manifest_matches_files(self): |
| manifest = ROOT / "SHA256SUMS" |
| self.assertTrue(manifest.exists(), "SHA256SUMS missing") |
| for line in manifest.read_text().splitlines(): |
| if not line.strip(): |
| continue |
| digest, name = line.split(" ", 1) |
| path = ROOT / name |
| if not path.exists(): |
| self.fail(f"manifest lists missing file: {name}") |
| self.assertEqual(hashlib.sha256(path.read_bytes()).hexdigest(), digest, name) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
