Files
Neutron/tests/test_fidelity_scenarios.py
T

254 lines
14 KiB
Python

"""Scenario completeness uses temporary metadata fixtures, never real captures."""
import copy
import importlib
import itertools
import json
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tools/recon'))
api = importlib.import_module('fidelity_receipts')
PROTOCOL = ROOT / 'docs/evidence/scenarios.json'
class FidelityScenarios(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.base = Path(self.tmp.name)
def protocol(self):
self.assertTrue(PROTOCOL.is_file(), 'eight-cell executable protocol must exist')
return json.loads(PROTOCOL.read_text())
def test_eight_explicit_cells(self):
p = self.protocol()
self.assertEqual(len(p['cells']), 8)
expected = set(itertools.product(('fresh', 'retained'), ('natural', 'skipped'), ('ordinary', 'edge')))
self.assertEqual({(c['lifetime'], c['dialogue'], c['input']) for c in p['cells']}, expected)
self.assertEqual(len({c['id'] for c in p['cells']}), 8)
def test_stable_ids_and_order(self):
p = self.protocol()
self.assertEqual([c['id'] for c in p['cells']], sorted(c['id'] for c in p['cells']))
for c in p['cells']:
self.assertEqual(c['id'], '-'.join((c['lifetime'], c['dialogue'], c['input'])))
api.validate_scenario_contract(p)
def test_every_cell_has_continuous_and_focused_obligations(self):
p = self.protocol()
for cell in p['cells']:
self.assertEqual(cell['obligations'], ['continuous', 'dialogue-return', 'bank-left', 'bank-right', 'landing-idle'])
self.assertEqual(p['obligations']['continuous']['route'], ['lab', 'VR04', 'lab', 'outside'])
for o in p['obligations'].values():
for field in ('setup', 'actions', 'end_condition', 'required_events', 'required_artifact_roles'):
self.assertTrue(o[field])
def test_missing_dimension_even_equal_count_rejected(self):
p = self.protocol()
p['cells'][-1] = copy.deepcopy(p['cells'][0])
with self.assertRaises(ValueError): api.validate_scenario_contract(p)
def test_natural_skipped_are_equal_obligations(self):
p = self.protocol()
for lifetime, inputs in itertools.product(('fresh', 'retained'), ('ordinary', 'edge')):
cells = [c for c in p['cells'] if c['lifetime'] == lifetime and c['input'] == inputs]
self.assertEqual(cells[0]['obligations'], cells[1]['obligations'])
self.assertIn('dialogue_end', p['dialogue_events']['natural'])
self.assertIn('dialogue_skip', p['dialogue_events']['skipped'])
def test_edge_procedure_includes_held_input_both_banks_landing_idle(self):
p = self.protocol()
self.assertEqual(set(p['input_events']['edge']), {'resumed_held_input', 'held_dialogue', 'held_return'})
self.assertIn('first_neutral_input', p['obligations']['dialogue-return']['required_events'])
self.assertIn('landing', p['obligations']['landing-idle']['required_events'])
self.assertIn('idle', p['obligations']['landing-idle']['required_events'])
def test_empty_receipts_structural_readiness_is_not_acceptance(self):
result = api.audit_scenarios(self.protocol(), [])
self.assertTrue(result['structurally_ready'])
self.assertFalse(result['complete'])
self.assertEqual(result['required'], 120)
self.assertEqual(result['accepted'], 0)
self.assertEqual(len(result['missing_case_ids']), 8)
def receipt(self, cell='retained-skipped-edge', obligation='continuous', kind='native_port', os_name='linux'):
p = self.protocol()
c = next(c for c in p['cells'] if c['id'] == cell)
d = self.base / (cell + '-' + obligation + '-' + kind + '-' + os_name)
d.mkdir(exist_ok=True)
artifacts = []
for name, role in [('video.txt', 'video'), ('audio.txt', 'audio'),
('events.txt', 'input_events'), ('setup.txt', 'prerequisite')]:
(d / name).write_text('temporary metadata fixture; not native media')
artifacts.append(dict(api.identify_file(d / name), path=name, role=role,
duration_seconds=100))
identity = {}
for key in ('executable', 'package', 'resources', 'launcher', 'source', 'original_pre',
'original_post', 'copy_pre', 'copy_post', 'retained_copy', 'dxwnd', 'dxwnd_config'):
if key in ('copy_pre', 'retained_copy'):
path = d / (key + '.json')
path.write_text(json.dumps({'copy_state': key, 'session': d.name}))
else:
path = d / 'setup.txt'
identity[key] = dict(api.identify_file(path), path=path.name)
identity['source'].update(commit='a' * 40, dirty=False, diff_sha256='b' * 64)
required = api.required_events(p, c, obligation)
events = [dict(name=name, artifact='video.txt', media_seconds=index + 2,
elapsed_seconds=index + 2, method='manual', uncertainty_seconds=.1)
for index, name in enumerate(required)]
if c['lifetime'] == 'retained':
events = [dict(name=name, artifact='setup.txt', media_seconds=index,
elapsed_seconds=index, method='manual', uncertainty_seconds=.1)
for index, name in enumerate(('prerequisite_departure', 'prerequisite_return'))] + events
value = {'schema_version': 1, 'receipt_id': d.name, 'session_id': d.name,
'case_id': cell, 'obligation_id': obligation, 'evidence_kind': kind,
'status': 'reviewed', 'historical': False, 'scope': obligation,
'platform': {'os': os_name, 'execution': {'native_port': 'native',
'original_dxwnd': 'dxwnd'}.get(kind, kind), 'version': 'unit-fixture',
'gpu': 'fixture', 'driver': 'fixture', 'vulkan': 'fixture', 'sdl': 'fixture'},
'identity': identity, 'invocation': {'argv': ['fixture'], 'cwd': '.'},
'clocks': {'wall_start': '2026-01-01T00:00:00Z', 'wall_end': '2026-01-01T00:01:40Z',
'monotonic_start': 0, 'monotonic_end': 100, 'clock_id': d.name},
'artifacts': artifacts, 'derivatives': [], 'events': events,
'limitations': ['Unit fixture, not imported as runtime proof'], 'missing_evidence': [],
'acceptance': {'state': 'accepted', 'remaining': []},
'review': dict(visible=True, audible=True, ordinary_input=True, human_reviewed=True),
'wrapper_settings': {'description': 'unit fixture only'},
'continuity': {'lifetime_id': d.name, 'departure_session_id': d.name,
'return_session_id': d.name, 'prerequisite_artifact': 'setup.txt',
'copy_pre_sha256': identity['copy_pre']['sha256'],
'retained_copy_sha256': identity['retained_copy']['sha256']}}
return value, d
def test_identified_metadata_cell_can_cover_one_obligation(self):
value, root = self.receipt()
result = api.audit_scenarios(self.protocol(), [(value, root)])
self.assertEqual(result['accepted'], 1)
self.assertFalse(result['complete'])
def test_disconnected_route_snapshots_fail(self):
value, root = self.receipt()
value['events'][-1]['artifact'] = 'audio.txt'
result = api.audit_scenarios(self.protocol(), [(value, root)])
self.assertEqual(result['accepted'], 0)
self.assertTrue(any('continuous' in error for error in result['invalid']))
def test_retained_departure_return_must_share_session(self):
value, root = self.receipt()
value['continuity']['return_session_id'] = 'different-launch'
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_retained_requires_prerequisite_and_copy_state(self):
value, root = self.receipt()
del value['continuity']['retained_copy_sha256']
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_copy_continuity_requires_named_state_for_both_lifetimes(self):
for lifetime in ('fresh', 'retained'):
for digest in ('f' * 64, 'launcher', 'package'):
with self.subTest(lifetime=lifetime, digest=digest):
value, root = self.receipt(lifetime + '-natural-ordinary', 'dialogue-return')
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 1)
value['continuity']['copy_pre_sha256'] = (
value['identity'][digest]['sha256'] if digest in value['identity'] else digest)
result = api.audit_scenarios(self.protocol(), [(value, root)])
self.assertEqual(result['accepted'], 0)
self.assertTrue(result['invalid'])
def test_retained_snapshot_cannot_bind_unrelated_identity(self):
for name in ('copy_pre', 'copy_post', 'launcher'):
value, root = self.receipt()
value['continuity']['retained_copy_sha256'] = value['identity'][name]['sha256']
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_reset_timestamps_fail(self):
value, root = self.receipt()
value['events'][-1]['elapsed_seconds'] = 0
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_fresh_sessions_are_independent(self):
a, ar = self.receipt('fresh-natural-ordinary')
b, br = self.receipt('fresh-natural-edge')
b['session_id'] = a['session_id']
b['continuity'] = copy.deepcopy(a['continuity'])
result = api.audit_scenarios(self.protocol(), [(a, ar), (b, br)])
self.assertLess(result['accepted'], 2)
self.assertTrue(any('fresh' in error for error in result['invalid']))
def test_synthetic_wine_component_cannot_substitute_native(self):
for kind in ('synthetic', 'wine', 'component', 'cross_publish'):
value, root = self.receipt(kind=kind)
value['acceptance'] = {'state': 'open', 'remaining': ['not native']}
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_skipped_aborted_failed_missing_remain_open(self):
for status in ('skipped', 'aborted', 'failed', 'missing'):
value, root = self.receipt()
value['status'] = status
value['acceptance'] = {'state': 'open', 'remaining': [status]}
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_missing_event_and_media_out_of_range_rejected(self):
value, root = self.receipt()
value['events'].pop()
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
value, root = self.receipt()
value['events'][-1]['media_seconds'] = 101
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_cli_readiness_and_strict_verdicts_differ(self):
p = self.protocol()
path = self.base / 'scenarios.json'
path.write_text(json.dumps(p))
index = self.base / 'receipts'
index.mkdir()
args = [sys.executable, str(ROOT / 'tools/recon/fidelity.py'), 'validate',
'--scenarios', str(path), '--receipts', str(index)]
ready = subprocess.run([*args, '--allow-open'], capture_output=True, text=True, timeout=15)
strict = subprocess.run([*args, '--require-complete'], capture_output=True, text=True, timeout=15)
self.assertEqual(ready.returncode, 0, ready.stderr)
self.assertNotEqual(strict.returncode, 0)
self.assertIn('0/120', ready.stdout)
self.assertIn('OPEN', strict.stdout)
self.assertIn('fresh-natural-edge', strict.stdout)
def test_protected_observations_and_clock_semantics_recorded(self):
p = self.protocol()
self.assertEqual(set(p['protected_observations']), {'tsk_retained_order', 'fresh_direct_scene_order', 'legitimate_landing_bank'})
self.assertEqual(p['event_contract']['simulation_ticks'], 'separate_port_only')
self.assertEqual(p['event_contract']['original_method'], ['manual', 'procedural'])
def test_all_120_metadata_slots_are_counted_independently(self):
p = self.protocol()
records = [self.receipt(c['id'], o, side['evidence_kind'], side['os'])
for c in p['cells'] for o in c['obligations'] for side in p['required_sides']]
result = api.audit_scenarios(p, records)
self.assertEqual(result['invalid'], [])
self.assertEqual(result['accepted'], 120)
self.assertTrue(result['complete'])
def test_duplicate_slot_cannot_replace_another_case(self):
value, root = self.receipt()
result = api.audit_scenarios(self.protocol(), [(value, root), (value, root)])
self.assertEqual(result['accepted'], 0)
self.assertTrue(result['invalid'])
def test_retained_prerequisite_must_have_observed_departure_and_return(self):
value, root = self.receipt()
value['events'] = [e for e in value['events'] if e['name'] != 'prerequisite_departure']
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
def test_retained_copy_hash_must_bind_identified_bytes(self):
value, root = self.receipt()
value['continuity']['retained_copy_sha256'] = 'f' * 64
self.assertEqual(api.audit_scenarios(self.protocol(), [(value, root)])['accepted'], 0)
if __name__ == '__main__':
unittest.main()