Add bounded same-state update validation and functional gates

2026-09-30 19:49:02 +08:00
parent b33e7ea047
commit d54f0b3ef1
31 changed files with 7951 additions and 0 deletions
@@ -0,0 +1,103 @@
+"""Pure authority construction tests; synthetic files, no graph or GPU claims."""
+import copy
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import execution_authority as A
+
+
+class AuthorityTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp=tempfile.TemporaryDirectory();self.root=Path(self.tmp.name).resolve()
+        self.case=self.root/'case';self.parent=self.root/'parent';self.update=self.root/'update'
+        for p in (self.case,self.parent,self.update):p.mkdir()
+        self.write(self.parent/'checkpoint-manifest.json',{'fixture':True})
+        self.write(self.parent/'summary.json',{'steps':1200,'effective_weights_raw_sha256':'a'*64,'diagnostic_mode':'reference'})
+        self.write(self.case/'spec.json',{'steps':1000,'global_tick_offset':1200,
+                   'parent_checkpoint_manifest_sha256':A.digest(self.parent/'checkpoint-manifest.json')})
+        (self.case/'requests.npz').write_bytes(b'synthetic-file-not-a-real-npz')
+        (self.parent/'state.npz').write_bytes(b'synthetic-state-not-a-real-npz')
+        self.before=dict(overlay_file=str(self.root/'before.npz'),overlay_manifest=str(self.root/'before.json'))
+        self.after=dict(overlay_file=str(self.root/'after.npz'),overlay_manifest=str(self.root/'after.json'))
+        for p in (*self.before.values(),*self.after.values()):Path(p).write_bytes(b'fixture')
+        self.epoch=self.root/'epoch.json';self.cpu=self.root/'cpu.json'
+        self.write(self.epoch,{});self.write(self.cpu,{})
+        for n in ('chain-receipt.json','update-receipt.json','delta-after.npz','overlay-manifest.json'):
+            (self.update/n).write_bytes(b'fixture')
+
+    def tearDown(self):self.tmp.cleanup()
+
+    def write(self,path,value):path.write_text(json.dumps(value),encoding='utf-8')
+
+    def make(self,**changes):
+        kw=dict(boundary_id='fixture',registration_sha256='c'*64,case=self.case,parent=self.parent,
+            transition='epoch_update',input_policy='empty_idle',mode='light',before_overlay=self.before,
+            after_overlay=self.after,source_files={'fixture':A.pin(self.cpu)},frozen_inputs={str(self.epoch):A.digest(self.epoch)},
+            epoch=self.epoch,update_dir=self.update,cpu_receipt=self.cpu)
+        kw.update(changes)
+        # Hash computation is stubbed only here: no effective-weight verification claim.
+        with patch.object(A,'effective_hash',side_effect=['a'*64,'b'*64] if kw['transition']=='epoch_update' else ['a'*64]*2):
+            return A.boundary_authority(**kw)
+
+    def test_exact_boundary_fields_and_live_payload_pins(self):
+        value=self.make()
+        self.assertEqual(value['global_tick_offset'],1200)
+        self.assertEqual(value['parent']['checkpoint_manifest_sha256'],A.digest(self.parent/'checkpoint-manifest.json'))
+        self.assertEqual(value['update']['files']['delta-after.npz'],A.pin(self.update/'delta-after.npz'))
+        self.assertEqual(value['expected_effective_weight_after_sha256'],'b'*64)
+
+    def test_changed_clock_or_parent_rejected(self):
+        original=A.read(self.case/'spec.json')
+        for key,value in (('global_tick_offset',1199),('parent_checkpoint_manifest_sha256','0'*64)):
+            spec={**original,key:value};self.write(self.case/'spec.json',spec)
+            with self.subTest(key=key),self.assertRaises(ValueError):self.make()
+
+    def test_later_parent_uses_absolute_next_tick(self):
+        summary=A.read(self.parent/'summary.json');summary['global_next_tick']=11200
+        self.write(self.parent/'summary.json',summary)
+        spec=A.read(self.case/'spec.json');spec['global_tick_offset']=11200;self.write(self.case/'spec.json',spec)
+        value=self.make(transition='idle',epoch=None,update_dir=None,cpu_receipt=None)
+        self.assertEqual(value['global_tick_offset'],11200);self.assertIsNone(value['update'])
+
+    def test_epoch_update_requires_all_evidence(self):
+        for name in ('epoch','update_dir','cpu_receipt'):
+            with self.subTest(name=name),self.assertRaises(ValueError):self.make(**{name:None})
+
+    def test_idle_cannot_carry_new_update(self):
+        with self.assertRaisesRegex(ValueError,'Idle cannot'):self.make(transition='idle')
+
+    def test_boundary_copies_descriptors_not_aliases(self):
+        sources={'role':A.pin(self.cpu)};frozen={str(self.epoch):A.digest(self.epoch)}
+        value=self.make(source_files=sources,frozen_inputs=frozen)
+        sources['role']['sha256']='0'*64;frozen.clear()
+        self.assertNotEqual(value['source_files'],sources);self.assertTrue(value['frozen_inputs'])
+
+    def test_complete_direct_closure_and_conflicting_pin(self):
+        value=self.make();pins=A.files_from_authority(value)
+        for p in (self.epoch,self.cpu,self.case/'requests.npz',self.parent/'checkpoint-manifest.json',self.update/'delta-after.npz'):
+            self.assertEqual(pins[str(p)],A.digest(p))
+        value['frozen_inputs'][str(self.cpu)]='0'*64
+        with self.assertRaisesRegex(ValueError,'Conflicting'):A.files_from_authority(value)
+
+    def test_epoch_template_is_not_modified(self):
+        spec=A.read(self.case/'spec.json');spec['steps']=1200;self.write(self.case/'spec.json',spec)
+        template=dict(schema='phase4an-epoch-postprocess-authority-v1',files={'old':{'path':'literal','sha256':'1'*64}},
+                      frozen_inputs={'literal':'1'*64})
+        original=copy.deepcopy(template)
+        result=A.epoch_authority(template,case=self.case,checkpoint=self.parent,overlay=self.before,
+                                 epoch_id='mechanical',us_tick=1199)
+        self.assertEqual(template,original);self.assertEqual(result['command']['us_tick'],1199)
+        self.assertEqual(result['files']['state'],A.pin(self.parent/'state.npz'))
+        with self.assertRaises(ValueError):A.epoch_authority(template,case=self.case,checkpoint=self.parent,
+                                                           overlay=self.before,epoch_id='bad',us_tick=1200)
+
+    def test_duplicate_or_nonfinite_JSON_rejected(self):
+        for data in ('{"a":1,"a":2}','{"a":NaN}'):
+            self.cpu.write_text(data)
+            with self.assertRaises(ValueError):A.read(self.cpu)
+
+
+if __name__=='__main__':unittest.main()