test(01-02): specify contained paired media review

This commit is contained in:
UnixNight committed 2026-11-12 19:30:43 -05:00
1 parent 6be8484802
commit 488c904807
2 files changed
+271

No files matched your search

+213
View File
@@ -0,0 +1,213 @@
"""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 = '</script><img src=x onerror=alert(1)>'
value['limitations'].append(hostile)
raw = self.original.parent / 'raw.json'
raw.write_text(json.dumps(value))
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()