From 488c904807e8c9e456e686c55ed024a212e6d614 Mon Sep 17 00:00:00 2001 From: Cristian Cerroni Date: Thu, 12 Nov 2026 19:30:43 -0500 Subject: [PATCH] test(01-02): specify contained paired media review --- tests/fidelity-viewer.test.mjs | 58 +++++++++ tests/test_fidelity_review.py | 213 +++++++++++++++++++++++++++++++++ 2 files changed, 271 insertions(+) create mode 100644 tests/fidelity-viewer.test.mjs create mode 100644 tests/test_fidelity_review.py diff --git a/tests/fidelity-viewer.test.mjs b/tests/fidelity-viewer.test.mjs new file mode 100644 index 0000000..36faddd --- /dev/null +++ b/tests/fidelity-viewer.test.mjs @@ -0,0 +1,58 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import {pathToFileURL} from 'node:url'; +import {existsSync} from 'node:fs'; + +const modulePath = new URL('../tools/recon/fidelity_viewer/viewer.mjs', import.meta.url); +const api = existsSync(modulePath) ? await import(modulePath) : {}; +class Media extends EventTarget { + currentTime = 0; duration = 20; playbackRate = 1; muted = false; volume = 1; + readyState = 4; paused = true; ended = false; seeking = false; error = null; + failPlay = false; + pause() { this.paused = true; } + async play() { if (this.failPlay) throw Error('blocked'); this.paused = false; } + emit(name) { this.dispatchEvent(new Event(name)); } +} +function pair() { + assert.equal(typeof api.createPairController, 'function', 'paired media controller must exist'); + const original = new Media(), port = new Media(); + const controller = api.createPairController({original, port}); + return {original, port, controller}; +} +const marker = {name: 'landing', original: {media_seconds: 2, elapsed_seconds: 2, uncertainty_seconds: .02}, + port: {media_seconds: 3, elapsed_seconds: 3.2, uncertainty_seconds: .03}}; +test('event selection seeks independent observed times and waits for explicit play', async () => { + const {controller, original, port} = pair(); + await controller.selectEvent(marker); + assert.equal(original.currentTime, 2); assert.equal(port.currentTime, 3); + assert.ok(original.paused && port.paused); + await controller.play(); + assert.equal(original.playbackRate, 1); assert.equal(port.playbackRate, 1); + assert.ok(!original.paused && !port.paused); +}); +test('invalid or unmatched event cannot seek either recording', async () => { + const {controller, original} = pair(); + for (const invalid of [{...marker, port: null}, {...marker, original: {...marker.original, media_seconds: Infinity}}, + {...marker, port: {...marker.port, media_seconds: 99}}]) { + await assert.rejects(controller.selectEvent(invalid)); + assert.equal(original.currentTime, 0); + } +}); +test('play rejection pauses both and names the cause', async () => { + const {controller, original, port} = pair(); port.failPlay = true; + assert.equal(await controller.play(), false); + assert.ok(original.paused && port.paused); + assert.match(controller.snapshot().problem, /play.*blocked/i); +}); +test('relative artifact links reject remote and active URL schemes', () => { + assert.equal(typeof api.safeLocalURL, 'function'); + assert.equal(api.safeLocalURL('sides/port/trace.json'), 'sides/port/trace.json'); + for (const value of ['https://host/x', 'javascript:alert(1)', '//host/x', '../x', '/etc/passwd', '%2e%2e/x']) + assert.throws(() => api.safeLocalURL(value)); +}); +test('capability navigation is supplied through a renderer', () => { + assert.equal(typeof api.renderCapabilities, 'function'); +}); +test('suite executes a positive declared count', () => { + assert.ok(6 > 0); +}); diff --git a/tests/test_fidelity_review.py b/tests/test_fidelity_review.py new file mode 100644 index 0000000..6478c5a --- /dev/null +++ b/tests/test_fidelity_review.py @@ -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 = '' + 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()