Seal AO interface failure and verified isolated postprocessing diagnosis

registry/phase4ao-conditioning-interface/source-snapshot/test_conditioning_preflight_prepare.py

@@ -0,0 +1,109 @@
+"""CPU-only coordinator contract tests; no real brain/input sampling."""
+import ast
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+import conditioning_preflight_prepare as P
+import conditioning_preflight_workflow as W
+
+
+class CoordinatorTests(unittest.TestCase):
+    def test_npz_exclusive_roundtrip(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / 'x.npz'
+            a = np.asarray([0, 3], np.int32)
+            P.save_npz(path, tick=a)
+            self.assertEqual(W.npz(path)['tick'].tobytes(), a.tobytes())
+            with self.assertRaises(FileExistsError): P.save_npz(path, tick=a)
+
+    def test_exact_pins_and_mutation(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / 'input'
+            p.write_bytes(b'original')
+            pins = {str(p): P.digest(p)}
+            P.verify_pins(pins)
+            p.write_bytes(b'changed')
+            with self.assertRaisesRegex(ValueError, 'Pinned file'): P.verify_pins(pins)
+
+    def test_rows_exact_unique(self):
+        row = dict(row_id='D1--reference--epoch-000')
+        self.assertEqual(W.row_by({'plan': {'calls': [row]}}, row['row_id']), row)
+        for rows in ([], [row, row]):
+            with self.assertRaises(ValueError): W.row_by({'plan': {'calls': rows}}, row['row_id'])
+
+    def test_locations_reject_path_traversal(self):
+        for value in ('../x', '/x', 'a/b', 'a\\b', '', None):
+            with self.assertRaises(ValueError): W.locations(value)
+
+    def test_plan_descriptor_avoids_huge_payload_duplication(self):
+        value = dict(full_trial_plan={'large': [1]}, payload_sha256='x', calls=[{'row_id': 'a'}])
+        self.assertEqual(P.plan_descriptor(value), {'calls': [{'row_id': 'a'}]})
+        self.assertIn('full_trial_plan', value)
+
+    def test_original_AST_rejects_unanchored_bytes(self):
+        with self.assertRaisesRegex(ValueError, 'L source changed'):
+            W.original_sampler_nodes(b'def run_rates(): pass')
+
+    def test_original_AST_if_local_frozen_source_available(self):
+        # Both repository checkout and local source mirror are supported; this
+        # test never reads historical dynamics or executes the extracted code.
+        candidates = [Path(__file__).resolve().parents[1] / 'phase4l.py',
+                      Path(__file__).resolve().parents[1] / 'models/male-cns-lif/phase4l.py']
+        source = next((p for p in candidates if p.is_file()), None)
+        self.assertIsNotNone(source, 'Original L source required for actual AST extraction test')
+        nodes = W.original_sampler_nodes(source.read_bytes())
+        self.assertEqual(len(nodes), 4)
+        self.assertNotIn('reset', ast.unparse(ast.Module(body=nodes, type_ignores=[])))
+
+    def test_registration_external_hash_rejection_before_parse(self):
+        with tempfile.TemporaryDirectory() as d:
+            exp = Path(d); (exp / 'protocol').mkdir()
+            P.save(exp / 'protocol/preregistered.json', {'fake': True})
+            with patch.object(P, 'EXP', exp):
+                with self.assertRaisesRegex(ValueError, 'external anchor'):
+                    P.read_registration('0' * 64)
+
+    def test_initial_overlay_has_no_parent_process_lookup(self):
+        expected = dict(overlay_file='/immutable/zero.npz', overlay_manifest='/immutable/zero.json')
+        self.assertIs(W.before_overlay({'initial_overlay': expected}, 'unused', {'previous_delta_row_id': None}), expected)
+
+    def test_wrong_parent_arm_rejected_before_runtime_read(self):
+        parent = dict(row_id='parent', arm='D0', diagnostic_mode='light', input_epoch_index=0)
+        child = dict(previous_delta_row_id='parent', arm='D1', diagnostic_mode='light', input_epoch_index=1)
+        with self.assertRaisesRegex(ValueError, 'cross-epoch'):
+            W.before_overlay({'plan': {'calls': [parent]}}, 'unused', child)
+
+    def test_budget_refuses_overrun_without_delete(self):
+        with tempfile.TemporaryDirectory() as d:
+            exp = Path(d); p = exp / 'keep'
+            p.write_bytes(b'1234')
+            with patch.object(W, 'EXP', exp):
+                with self.assertRaisesRegex(ValueError, 'Resource cap'):
+                    W.budget({'budget': {'output_budget_bytes': 1, 'minimum_free_reserve_bytes': 1}})
+            self.assertEqual(p.read_bytes(), b'1234')
+
+    def test_partial_log_is_not_retried(self):
+        with tempfile.TemporaryDirectory() as d:
+            exp = Path(d); (exp / 'logs').mkdir()
+            (exp / 'logs/input-generation.stdout.log').write_bytes(b'partial')
+            with patch.object(W, 'EXP', exp), patch.object(W.subprocess, 'run') as run:
+                with self.assertRaisesRegex(ValueError, 'never retry'): W.child_process({}, 'sha', 'materialize')
+                run.assert_not_called()
+
+    def test_admission_blocks_stopped_complete_or_sealed(self):
+        with tempfile.TemporaryDirectory() as d:
+            exp = Path(d); (exp / 'audit').mkdir()
+            with patch.object(W, 'EXP', exp):
+                W.admission()
+                for name in ('audit/stopped.json', 'audit/execution-complete.json', 'manifest.json'):
+                    p = exp / name; p.write_bytes(b'{}')
+                    with self.assertRaisesRegex(ValueError, 'Stopped/completed'): W.admission()
+                    p.unlink()
+
+
+if __name__ == '__main__':
+    unittest.main()