254 lines
14 KiB
Python
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()
|