test: admit full uniform full9 DFG qualification from pinned pilot

tests/validation/experimental_full9/test_dfg_full.py

@@ -0,0 +1,97 @@
+"""CPU-only full admission and unchanged observer tests; fixture receipts are synthetic."""
+from copy import deepcopy
+import json
+from pathlib import Path
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import run_dfg_full as f
+import test_dfg as pilot_tests
+
+
+def fixture(path):
+    cfg, body, parameters, manifest, _ = f.configuration(f.pilot.ROOT)
+    import run_refined_dfg as runner
+    _, periodic = runner.helpers(f.pilot.ROOT)
+    expected, result = pilot_tests.receipt()
+    checkout = dict(checkout_revision='c0be841b2e6e1ccba3b8343cecd3cee2fe0ed14f', checkout_dirty=False)
+    result.update(checkout=checkout, startup_seconds=3.3353, step_seconds=3.6794, wall_seconds=8.)
+    preflight = dict(**expected, checkout=checkout, config=cfg, body=body, parameters=parameters,
+                     source=manifest, max_steps=40000, cap_tstar=5., observation_width_tstar=.5,
+                     gates=periodic.GATES, reference_gates=periodic.REFERENCE_GATES)
+    ready = dict(**expected, checkout=checkout, case='uniform', mode='pilot', step=4000,
+                 tstar=.5, runner_sha256=runner.runner_hash(),
+                 all_runtime_and_observation_paths_exercised=True,
+                 calibration_batches_seconds=result['calibration_batches_seconds'])
+    (path/'uniform').mkdir(exist_ok=True)
+    for name, data in [('result.json', result), ('preflight.json', preflight), ('uniform/ready.json', ready)]:
+        (path/name).write_text(json.dumps(data))
+    return cfg, body, parameters, manifest
+
+
+def test_admission_rejects_mismatches():
+    with TemporaryDirectory() as temp:
+        path = Path(temp); args = fixture(path)
+        receipt = f.admit_pilot(path, *args)
+        assert abs(receipt['step_force_scaled_seconds'] - 220.764) < 1e-10
+        cases = [('result.json', 'collision', 'MRT'),
+                 ('result.json', 'step_seconds', float('nan')),
+                 ('result.json', 'healthy', False),
+                 ('uniform/ready.json', 'step', 160),
+                 ('uniform/ready.json', 'runner_sha256', 'wrong'),
+                 ('preflight.json', 'body', {'objects': []}),
+                 ('preflight.json', 'gates', {}),
+                 ('preflight.json', 'source', {})]
+        for filename, key, value in cases:
+            fixture(path)
+            target = path/filename; data=json.loads(target.read_text()); data[key]=value
+            target.write_text(json.dumps(data))
+            with unittest.TestCase().assertRaises(ValueError): f.admit_pilot(path, *args)
+        fixture(path); (path/'uniform/ready.json').unlink()
+        with unittest.TestCase().assertRaises(FileNotFoundError): f.admit_pilot(path, *args)
+
+
+def test_full_requires_health_periodicity_and_reference():
+    good = dict(case='uniform', mode='full', steps=2400000, executed_steps=2400000,
+                healthy=True, periodic=True, reference_comparison=dict(reference_agreement=True))
+    assert f.qualified(good)
+    for key, value in [('healthy', False), ('periodic', False), ('steps', 40000),
+                       ('executed_steps', 2399900), ('mode', 'pilot'), ('case', 'refined'),
+                       ('reference_comparison', {}),
+                       ('reference_comparison', dict(reference_agreement=False))]:
+        bad=deepcopy(good); bad[key]=value; assert not f.qualified(bad)
+
+
+def test_preflight_preserves_physics_and_gates():
+    with TemporaryDirectory() as temp:
+        root=Path(temp); incoming=root/'pilot'; incoming.mkdir(); cfg, body, params, _=fixture(incoming)
+        output=root/'full'
+        subprocess.run([sys.executable, str(Path(f.__file__)), '--pilot-results', str(incoming),
+                        '--output', str(output)], check=True)
+        data=json.loads((output/'preflight.json').read_text())
+        assert data['config']==cfg and data['body']==body and data['parameters']==params
+        assert data['max_steps']==2400000 and data['cap_tstar']==300 and data['wall_seconds']==720
+        assert not data['accuracy_qualified'] and not data['executed']
+        assert data['numerical_source_commit']=='926ca27407c26ca11283282a6e53249925725376'
+        assert 'restart' in data['initialization']
+
+
+def test_old_files_and_late_observer_unchanged():
+    root=f.pilot.ROOT
+    for name in ['tests/validation/run_refined_dfg.py',
+                 'tests/validation/experimental_full9/run_dfg.py',
+                 'tests/validation/experimental_full9/dfg_source_manifest.json',
+                 'tests/validation/periodic.py']:
+        old=subprocess.check_output(['git','-C',str(root),'show','c0be841:'+name])
+        assert old==(root/name).read_bytes()
+    source=(root/'tests/validation/run_refined_dfg.py').read_text()
+    assert 'begin * SPEED / p["diameter"] >= 240' in source
+    assert 'cap = 5.0 if a.mode == "pilot" else 300.0' in source
+
+
+if __name__ == '__main__':
+    result=unittest.TextTestRunner(verbosity=2).run(unittest.TestSuite(
+        unittest.FunctionTestCase(fn) for name,fn in sorted(globals().items()) if name.startswith('test_')))
+    raise SystemExit(not result.wasSuccessful())