157 lines
9.5 KiB
Python
157 lines
9.5 KiB
Python
"""Actual port-process observation plumbing; fixtures never fill native acceptance."""
|
|
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'))
|
|
import fidelity_receipts as receipts
|
|
|
|
|
|
class FidelityObservation(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
result = subprocess.run(['bash', '-lc', 'source scripts/env.sh && dotnet build GamePort.csproj --no-restore'],
|
|
cwd=ROOT, capture_output=True, text=True, timeout=90)
|
|
if result.returncode:
|
|
raise RuntimeError(result.stdout + result.stderr)
|
|
required = ['level1b/scene.json', 'VR04/scene.json', 'ui/ui.json', 'animations/jimstop/animation.json']
|
|
if not all((ROOT / 'artifacts/extracted' / name).is_file() for name in required):
|
|
# The consolidated script runs Python before its preparation step.
|
|
# Reuse its local extractor instead of assuming generated fixtures exist.
|
|
result = subprocess.run([sys.executable, 'tools/extractors/prepare.py', '--all-scenes',
|
|
'--audio', 'sounds', 'musicsecretlab'], cwd=ROOT,
|
|
capture_output=True, text=True, timeout=300)
|
|
if result.returncode:
|
|
raise RuntimeError(result.stdout + result.stderr)
|
|
|
|
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 bin/Debug/net10.0/GamePort.dll "$@"',
|
|
'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)
|
|
|
|
def test_retained_continuation_keeps_one_ordered_session_clock(self):
|
|
with tempfile.TemporaryDirectory(prefix='gameport-observer-return-') as temporary:
|
|
output = Path(temporary) / 'observation'
|
|
result = self.run_port('--headless', '--mute', '--no-validation', '--smoke-practice-return',
|
|
'--width', '320', '--height', '240', '--fidelity-output', output,
|
|
'--fidelity-session', 'retained-process', '--fidelity-case', 'retained-skipped-edge')
|
|
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
|
records = [json.loads(line) for line in (output / 'events.jsonl').read_text().splitlines()]
|
|
entries = [e for e in records if e['name'] == 'scene_entry']
|
|
self.assertEqual([e['scene'] for e in entries], ['LV1B', 'VR04', 'LV1B'],
|
|
'actual continuation must publish source/destination scene entries')
|
|
self.assertEqual([e['data']['returning'] for e in entries], [False, False, True])
|
|
self.assertEqual([e['data']['retained_player'] for e in entries], [False, True, True])
|
|
departures = [e for e in records if e['name'] == 'scene_departure']
|
|
self.assertEqual(len(departures), 2)
|
|
self.assertEqual([e['data']['departure_sequence'] for e in entries[1:]],
|
|
[e['sequence'] for e in departures])
|
|
self.assertEqual(departures[-1]['data']['returning'], True)
|
|
self.assertEqual({e['session_id'] for e in records}, {'retained-process'})
|
|
self.assertEqual({e['evidence_kind'] for e in records}, {'port_fixture'})
|
|
self.assertEqual([e['sequence'] for e in records], list(range(1, len(records) + 1)))
|
|
times = [e['elapsed_seconds'] for e in records]
|
|
self.assertEqual(times, sorted(times))
|
|
|
|
def test_observed_off_fixture_state_and_readbacks_match(self):
|
|
with tempfile.TemporaryDirectory(prefix='gameport-observer-parity-') as temporary:
|
|
root = Path(temporary)
|
|
on, off = root / 'on', root / 'off'
|
|
on.mkdir(); off.mkdir()
|
|
enabled, disabled = self.fixture(on), self.fixture(off, observed=False)
|
|
captures = sorted(p.name for p in on.glob('*.ppm'))
|
|
self.assertGreaterEqual(len(captures), 4)
|
|
self.assertEqual(captures, sorted(p.name for p in off.glob('*.ppm')))
|
|
for name in captures:
|
|
self.assertEqual((on / name).read_bytes(), (off / name).read_bytes(), name)
|
|
prefixes = ('Movement ', 'Carl ', 'Control-phase ', 'Scene sequence:', 'Simulation:')
|
|
self.assertEqual([s for s in enabled.stdout.splitlines() if s.startswith(prefixes)],
|
|
[s for s in disabled.stdout.splitlines() if s.startswith(prefixes)])
|
|
|
|
def test_skip_and_natural_paths_are_distinct(self):
|
|
_, _, _, records, _ = self.observed_fixture()
|
|
skips = [e for e in records if e['name'] == 'dialogue_skip']
|
|
self.assertTrue(skips, 'fixture uses actual skip paths')
|
|
self.assertTrue(all(e['method'].startswith('skip:') for e in skips))
|
|
ends = [e for e in records if e['name'] == 'dialogue_end']
|
|
self.assertTrue(any(e['method'].startswith('skip:') for e in ends))
|
|
self.assertFalse(any(e['method'] == 'natural_director_step' for e in ends))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|