"""Synthetic media tests prove local review plumbing, never game acceptance.""" import copy import importlib import json from pathlib import Path import subprocess import sys import tempfile import threading import unittest import urllib.error import urllib.request import wave ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tools/recon')) import fidelity_receipts as receipts try: review = importlib.import_module('fidelity_review') except ModuleNotFoundError: review = None def fixture(base, side): bundle = base / side bundle.mkdir() for name in ('video.wav', 'audio.wav'): with wave.open(str(bundle / name), 'wb') as stream: stream.setparams((1, 2, 8000, 0, 'NONE', 'uncompressed')) stream.writeframes(b'\0\0' * 16000) (bundle / 'trace.json').write_text('{"fixture": true}') items = [dict(receipts.identify_file(bundle / name), path=name, role=role, synthetic=True, **({'duration_seconds': 2} if role != 'input_events' else {})) for name, role in [('video.wav', 'video'), ('audio.wav', 'audio'), ('trace.json', 'input_events')]] value = dict(schema_version=1, receipt_id='test-' + side, session_id='test-session', case_id='test-only', evidence_kind='synthetic', status='captured', scope='tooling-test', historical=False, identity={}, platform={'os': 'test', 'execution': 'synthetic'}, invocation={'argv': ['fixture'], 'cwd': '.'}, clocks={'wall_start': '2026-01-01T00:00:00Z', 'wall_end': '2026-01-01T00:00:02Z', 'monotonic_start': 0, 'monotonic_end': 2}, artifacts=items, derivatives=[], events=[dict(name='landing', artifact='video.wav', media_seconds=0.5, elapsed_seconds=0.5, method='procedural', uncertainty_seconds=0.02)], limitations=['Synthetic silent audio fixture; no original execution'], missing_evidence=[], acceptance={'state': 'open', 'remaining': ['Real capture required']}) path = bundle / 'receipt.json' path.write_text(json.dumps(value)) imported = receipts.import_receipt(path, bundle, base / 'test-imports') return Path(imported['path']), value class FidelityReview(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory(prefix='fidelity-review-test-') self.addCleanup(self.temp.cleanup) self.base = Path(self.temp.name) self.original, self.value = fixture(self.base, 'original') self.port, _ = fixture(self.base, 'port') self.output = self.base / 'test-review' def api(self): self.assertIsNotNone(review, 'contained review export/server must exist') return review def export(self, **kwargs): return self.api().export_review(kwargs.pop('original', self.original), kwargs.pop('port', self.port), self.output, **kwargs) def server(self): server = self.api().make_server(self.output, port=0) thread = threading.Thread(target=server.serve_forever, daemon=True) thread.start() self.addCleanup(server.server_close) self.addCleanup(thread.join, 2) self.addCleanup(server.shutdown) return 'http://127.0.0.1:' + str(server.server_port) def request(self, url, method='GET', headers=None): request = urllib.request.Request(url, method=method, headers=headers or {}) try: return urllib.request.urlopen(request, timeout=3) except urllib.error.HTTPError as error: return error def test_cli_import_export_http_round_trip(self): cli = ROOT / 'tools/recon/fidelity_review.py' self.assertTrue(cli.is_file(), 'review CLI must export an imported pair') result = subprocess.run([sys.executable, str(cli), 'export', '--original', str(self.original), '--port', str(self.port), '--output', str(self.output)], capture_output=True, text=True, timeout=15) self.assertEqual(result.returncode, 0, result.stderr) url = self.server() with self.request(url + '/review.json') as response: model = json.load(response) self.assertEqual(model['acceptance']['state'], 'open') self.assertEqual(model['events'][0]['name'], 'landing') for side in ('original', 'port'): self.assertEqual(model['sides'][side]['evidence_kind'], 'synthetic') with self.request(url + '/' + model['sides'][side]['media']['url']) as response: self.assertTrue(response.read().startswith(b'RIFF')) def test_export_keeps_raw_derivatives_and_links(self): data = self.export() for side in data['sides'].values(): self.assertEqual({x['role'] for x in side['artifacts']}, {'video', 'audio', 'input_events'}) self.assertTrue((self.output / side['receipt_url']).is_file()) self.assertEqual(side['derivatives'], []) def test_missing_original_explicit(self): data = self.export(original=None) self.assertIn('Missing original', data['sides']['original']['missing']) self.assertIsNone(data['sides']['original']['media']) def test_empty_review_is_explicit(self): data = self.export(original=None, port=None) self.assertEqual(data['events'], []) self.assertEqual(data['acceptance']['state'], 'open') def test_tampered_artifact_rejected(self): (self.port.parent / 'video.wav').write_bytes(b'changed') with self.assertRaises(ValueError): self.export() self.assertFalse(self.output.exists()) def test_tampered_receipt_sidecar_rejected(self): self.port.write_text('{}') with self.assertRaises(ValueError): self.export() def test_traversal_absolute_remote_and_symlink_references_rejected(self): for path in ('../secret', '/secret', 'C:/secret', 'https://host/a', 'a\\b'): value = copy.deepcopy(self.value) value['artifacts'][0]['path'] = path raw = self.original.parent / 'raw.json' raw.write_text(json.dumps(value)) with self.assertRaises(ValueError): self.api().export_review(raw, None, self.output) (self.original.parent / 'video.wav').unlink() (self.original.parent / 'video.wav').symlink_to(self.port.parent / 'video.wav') with self.assertRaises(ValueError): self.export() def test_labels_are_json_text_never_interpolated_html(self): value = copy.deepcopy(self.value) hostile = '' value['limitations'].append(hostile) raw = self.original.parent / 'raw.json' raw.write_text(json.dumps(value)) # A new collector bundle has no import sidecar; do not reuse another # receipt's immutable metadata identity for this changed observation. (self.original.parent / 'receipt.sha256').unlink() data = self.api().export_review(raw, None, self.output) self.assertIn(hostile, data['sides']['original']['limitations']) self.assertNotIn(hostile, (self.output / 'index.html').read_text()) self.assertNotIn('innerHTML', (self.output / 'viewer.mjs').read_text()) def test_event_out_of_range_rejected(self): value = copy.deepcopy(self.value) value['events'][0]['media_seconds'] = 3 raw = self.original.parent / 'raw.json' raw.write_text(json.dumps(value)) with self.assertRaises(ValueError): self.api().export_review(raw, None, self.output) def test_existing_or_overlapping_output_rejected(self): with self.assertRaises(ValueError): self.api().export_review(self.original, self.port, self.original.parent) self.export() with self.assertRaises(ValueError): self.export() def test_head_and_ranges_seek_actual_bytes(self): data = self.export() url = self.server() + '/' + data['sides']['port']['media']['url'] for range_value, expected in [('bytes=0-3', b'RIFF'), ('bytes=-4', b'\0' * 4), ('bytes=4-', (self.port.parent / 'video.wav').read_bytes()[4:])]: with self.request(url, headers={'Range': range_value}) as response: self.assertEqual(response.status, 206) self.assertEqual(response.read(), expected) self.assertIn('Content-Range', response.headers) with self.request(url, 'HEAD', {'Range': 'bytes=0-3'}) as response: self.assertEqual(response.status, 206) self.assertEqual(response.headers['Content-Length'], '4') self.assertEqual(response.read(), b'') def test_bad_ranges_return_416(self): self.export() url = self.server() + '/index.html' for value in ('bytes=9-2', 'bytes=999999-', 'bytes=0-1,4-5', 'bytes=-0', 'nonsense'): with self.request(url, headers={'Range': value}) as response: self.assertEqual(response.status, 416) def test_server_rejects_escape_symlink_and_directory(self): self.export() (self.output / 'escape').symlink_to(self.port.parent / 'video.wav') url = self.server() for path in ('/%2e%2e/tools.yaml', '/escape', '/sides/', '/%2fetc/passwd'): with self.request(url + path) as response: self.assertIn(response.status, (400, 403, 404)) def test_write_methods_forbidden(self): self.export() url = self.server() for method in ('POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'): with self.request(url + '/review.json', method) as response: self.assertEqual(response.status, 405) def test_only_generated_root_loopback_and_security_headers(self): with self.assertRaises(ValueError): self.api().make_server(ROOT, port=0) self.export() with self.assertRaises(ValueError): self.api().make_server(self.output, port=0, host='0.0.0.0') with self.request(self.server() + '/') as response: self.assertEqual(response.status, 200) self.assertEqual(response.headers['X-Content-Type-Options'], 'nosniff') self.assertIn("default-src 'none'", response.headers['Content-Security-Policy']) if __name__ == '__main__': unittest.main()