test(01-02): specify contained paired media review
This commit is contained in:
1 parent
6be8484802
commit
488c904807
2 files changed
+271
No files matched your search
@@ -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);
|
||||
});
|
||||
@@ -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()
|
||||
Reference in new issue
Block a user