Files
Neutron/tests/test_fidelity_observation.py
T

94 lines
5.1 KiB
Python

"""Actual port-process observation plumbing; fixtures never fill native acceptance."""
import json
import os
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'))
import fidelity_receipts as receipts
class FidelityObservation(unittest.TestCase):
def run_port(self, *args):
# Fixed shell source; caller values are positional argv, never shell code.
return subprocess.run(['bash', '-lc', 'source scripts/env.sh && dotnet run --no-build -- "$@"',
'observer-test', *map(str, args)], cwd=ROOT, text=True,
capture_output=True, timeout=90)
def test_real_port_exposes_observation_options(self):
result = self.run_port('--help')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn('--fidelity-output', result.stdout, 'actual port must expose passive observation')
self.assertIn('--fidelity-session', result.stdout)
self.assertIn('--fidelity-case', result.stdout)
def fixture(self, directory, observed=True):
args = ['--headless', '--mute', '--no-validation', '--smoke-control-phases',
'--width', '320', '--height', '240', '--screenshot', directory / 'frame.ppm']
if observed:
args += ['--fidelity-output', directory / 'observation', '--fidelity-session', 'process-session',
'--fidelity-case', 'fresh-skipped-edge']
result = self.run_port(*args)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
return result
def observed_fixture(self):
temporary = tempfile.TemporaryDirectory(prefix='gameport-observer-')
self.addCleanup(temporary.cleanup)
root = Path(temporary.name)
result = self.fixture(root)
output = root / 'observation'
summary = json.loads((output / 'observation-summary.json').read_text())
records = [json.loads(line) for line in (output / 'events.jsonl').read_text().splitlines()]
self.assertTrue(records, 'real process must emit records')
return root, output, summary, records, result
def receipt(self, output, summary, records):
duration = summary['elapsed_seconds']
return dict(schema_version=1, receipt_id='observer-fixture', session_id=summary['session_id'],
case_id=summary['case_id'], evidence_kind=summary['evidence_kind'], status='captured',
platform={'os': 'linux', 'execution': 'port_fixture'}, historical=False,
scope='observer-wiring', identity={}, invocation={'argv': ['bounded-existing-fixture'], 'cwd': '.'},
clocks={'wall_start': summary['wall_start'], 'wall_end': summary['wall_end'],
'monotonic_start': 0, 'monotonic_end': duration},
artifacts=[dict(receipts.identify_file(output / 'events.jsonl'), path='events.jsonl',
role='input_events', duration_seconds=duration)], derivatives=[],
events=[dict(name=e['name'], artifact='events.jsonl', media_seconds=e['elapsed_seconds'],
elapsed_seconds=e['elapsed_seconds'], method=e['method'], uncertainty_seconds=0,
simulation_tick=e['simulation_tick']) for e in records],
limitations=['Bounded injected fixture; observer perturbs timing'], missing_evidence=[],
acceptance={'state': 'open', 'remaining': ['Full native route and audiovisual review required']})
def test_actual_fixture_emits_requested_and_accepted_input(self):
_, output, summary, records, _ = self.observed_fixture()
self.assertFalse(summary['incomplete'])
self.assertEqual(summary['evidence_kind'], 'port_fixture')
inputs = [e for e in records if e['name'] == 'input_step']
self.assertTrue(any(not e['data']['accepts_input'] and e['data']['requested_input']['forward'] for e in inputs))
self.assertTrue(any(e['data']['accepts_input'] for e in inputs))
result = receipts.validate_receipt(self.receipt(output, summary, records), output)
self.assertTrue(result['valid'])
self.assertFalse(result['accepted'])
def test_fixture_cannot_promote_native_acceptance(self):
_, output, summary, records, _ = self.observed_fixture()
receipt = self.receipt(output, summary, records)
receipt['acceptance']['state'] = 'accepted'
with self.assertRaises(ValueError): receipts.validate_receipt(receipt, output)
def test_missing_output_and_incomplete_records_do_not_qualify(self):
_, output, summary, records, _ = self.observed_fixture()
receipt = self.receipt(output, summary, records)
receipt['status'] = 'aborted'
self.assertFalse(receipts.validate_receipt(receipt, output)['accepted'])
(output / 'events.jsonl').unlink()
with self.assertRaises((ValueError, OSError)): receipts.validate_receipt(receipt, output)
if __name__ == '__main__':
unittest.main()