Files
Neutron/tests/test_fidelity_review.py
T

291 lines
15 KiB
Python

"""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):
(self.original.parent / 'receipt.sha256').unlink()
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.assertRaisesRegex(ValueError, 'reference|Reference'):
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))
# 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):
(self.original.parent / 'receipt.sha256').unlink()
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.assertRaisesRegex(ValueError, 'exceeds'):
self.api().export_review(raw, None, self.output)
def test_duplicate_event_is_ambiguous_not_silently_selected(self):
(self.original.parent / 'receipt.sha256').unlink()
value = copy.deepcopy(self.value)
value['events'].append(copy.deepcopy(value['events'][0]))
raw = self.original.parent / 'raw.json'
raw.write_text(json.dumps(value))
with self.assertRaisesRegex(ValueError, 'Ambiguous'):
self.api().export_review(raw, None, self.output)
def test_cross_case_pair_rejected(self):
(self.original.parent / 'receipt.sha256').unlink()
value = copy.deepcopy(self.value)
value['case_id'] = 'other-case'
raw = self.original.parent / 'raw.json'
raw.write_text(json.dumps(value))
with self.assertRaisesRegex(ValueError, 'same case'):
self.api().export_review(raw, self.port, self.output)
def test_lossless_stills_and_derivative_ancestry_remain_linked(self):
(self.original.parent / 'receipt.sha256').unlink()
value = copy.deepcopy(self.value)
# A byte-identified derivative record tests ancestry retention only;
# browser/PNG validation is separately required before image differences.
(self.original.parent / 'still.png').write_bytes(b'test-only not a PNG')
value['artifacts'].append(dict(receipts.identify_file(self.original.parent / 'still.png'),
path='still.png', role='lossless_still', synthetic=True))
value['derivatives'].append({'path': 'still.png', 'source': 'video.wav',
'tool': 'synthetic fixture', 'argv': ['inert']})
raw = self.original.parent / 'raw.json'
raw.write_text(json.dumps(value))
data = self.api().export_review(raw, None, self.output)
self.assertEqual(data['sides']['original']['derivatives'], value['derivatives'])
self.assertTrue((self.output / 'sides/original/still.png').is_file())
def test_imported_active_document_served_as_attachment(self):
(self.original.parent / 'receipt.sha256').unlink()
value = copy.deepcopy(self.value)
artifact = self.original.parent / 'untrusted.html'
artifact.write_text('<script>alert(1)</script>')
value['artifacts'].append(dict(receipts.identify_file(artifact), path='untrusted.html', role='note'))
raw = self.original.parent / 'raw.json'
raw.write_text(json.dumps(value))
self.api().export_review(raw, None, self.output)
with self.request(self.server() + '/sides/original/untrusted.html') as response:
self.assertEqual(response.headers['Content-Type'], 'application/octet-stream')
self.assertEqual(response.headers['Content-Disposition'], 'attachment')
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'])
def test_ledger_sources_are_validated_copied_and_linked(self):
ledger = self.base / 'ledger.json'
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'id': 'test', 'source_links':
[{'label': 'Progress', 'path': 'docs/progress.md'}, {'label': 'Missing', 'path': 'docs/absent-fixture.md'}]}]}))
data = self.export(ledger=ledger)
links = data['ledger']['capabilities'][0]['source_links']
self.assertTrue(links[0]['validated_local'])
self.assertEqual((self.output / links[0]['href']).read_bytes(), (ROOT / 'docs/progress.md').read_bytes())
self.assertIsNone(links[1]['href'])
self.assertIn('Missing', links[1]['missing'])
with self.request(self.server() + '/' + links[0]['href']) as response:
self.assertEqual(response.headers['Content-Type'], 'text/plain; charset=utf-8')
self.assertTrue(response.read())
def test_ledger_source_paths_and_mismatched_hashes_rejected(self):
ledger = self.base / 'ledger.json'
for path in ('../Original/game.exe', 'https://host/a', '.git/config', 'artifacts/test.log'):
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'source_links': [{'label': 'bad', 'path': path}]}]}))
with self.assertRaises(ValueError): self.export(ledger=ledger)
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'source_links':
[{'label': 'bad hash', 'path': 'docs/progress.md', 'sha256': '0' * 64}]}]}))
with self.assertRaisesRegex(ValueError, 'hash mismatch'): self.export(ledger=ledger)
if __name__ == '__main__':
unittest.main()