273 lines
14 KiB
JavaScript
273 lines
14 KiB
JavaScript
import nodeTest from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {existsSync} from 'node:fs';
|
|
let declared = 0;
|
|
function test(name, action) { declared++; return nodeTest(name, action); }
|
|
|
|
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('raw elapsed, event drift and playback drift are distinct', async () => {
|
|
const {controller, original, port} = pair();
|
|
await controller.selectEvent(marker);
|
|
original.currentTime = 5; port.currentTime = 6.25;
|
|
const s = controller.snapshot();
|
|
assert.equal(s.sides.original.recording_seconds, 5);
|
|
assert.equal(s.sides.port.recording_seconds, 6.25);
|
|
assert.equal(s.sides.original.aligned_elapsed, 3);
|
|
assert.equal(s.sides.port.aligned_elapsed, 3.25);
|
|
assert.ok(Math.abs(s.eventDrift.seconds - 1.2) < 1e-9);
|
|
assert.equal(s.eventDrift.uncertainty_seconds, .05);
|
|
assert.equal(s.playbackDrift, .25);
|
|
});
|
|
test('no selected event means no invented drift', () => {
|
|
const {controller} = pair();
|
|
assert.equal(controller.snapshot().eventDrift, null);
|
|
assert.equal(controller.snapshot().playbackDrift, null);
|
|
});
|
|
test('exclusive soundtrack switch mutes both before selecting one', () => {
|
|
const {controller, original, port} = pair();
|
|
assert.ok(original.muted && port.muted);
|
|
controller.setAudio('original');
|
|
assert.ok(!original.muted && port.muted);
|
|
controller.setAudio('port');
|
|
assert.ok(original.muted && !port.muted);
|
|
controller.setAudio('none');
|
|
assert.ok(original.muted && port.muted);
|
|
assert.throws(() => controller.setAudio('external'));
|
|
});
|
|
test('gain is unadjusted by default and visibly review-only when changed', () => {
|
|
const {controller, original, port} = pair();
|
|
assert.equal(controller.snapshot().gain, 1);
|
|
assert.equal(controller.snapshot().gainAdjusted, false);
|
|
controller.setGain(.4);
|
|
assert.equal(original.volume, .4); assert.equal(port.volume, .4);
|
|
assert.equal(controller.snapshot().gainAdjusted, true);
|
|
assert.match(controller.snapshot().gainLabel, /review-only/i);
|
|
for (const value of [-1, 2, NaN]) assert.throws(() => controller.setGain(value));
|
|
});
|
|
test('buffering pauses both; explicit recovered play stays at rate one', async () => {
|
|
const {controller, original, port} = pair();
|
|
await controller.play(); port.readyState = 2; port.emit('waiting');
|
|
assert.ok(original.paused && port.paused);
|
|
assert.match(controller.snapshot().problem, /port.*buffer/i);
|
|
assert.equal(await controller.play(), false);
|
|
port.readyState = 4; port.emit('canplay');
|
|
assert.ok(original.paused && port.paused, 'readiness must not auto-resume');
|
|
assert.equal(await controller.play(), true);
|
|
assert.equal(port.playbackRate, 1);
|
|
});
|
|
test('decode failure is visible and blocks play', async () => {
|
|
const {controller, original, port} = pair();
|
|
port.error = {code: 3}; port.emit('error');
|
|
assert.ok(original.paused && port.paused);
|
|
assert.match(controller.snapshot().problem, /port.*decod/i);
|
|
assert.equal(await controller.play(), false);
|
|
});
|
|
test('missing media blocks pair but preserves manual available-side playback', async () => {
|
|
const port = new Media();
|
|
const controller = api.createPairController({original: null, port});
|
|
assert.equal(await controller.play(), false);
|
|
assert.match(controller.snapshot().problem, /missing/i);
|
|
assert.equal(await controller.playSide('port'), true);
|
|
assert.equal(controller.snapshot().sides.original.state, 'missing');
|
|
});
|
|
test('asymmetric end pauses pair and allows the complete longer tail', async () => {
|
|
const {controller, original, port} = pair();
|
|
await controller.play(); original.currentTime = original.duration; original.ended = true;
|
|
original.emit('ended');
|
|
assert.ok(port.paused);
|
|
assert.match(controller.snapshot().problem, /tail/i);
|
|
assert.equal(await controller.play(), true);
|
|
assert.equal(original.currentTime, 20); assert.ok(!port.paused);
|
|
port.currentTime = port.duration; port.ended = true; port.emit('ended');
|
|
assert.equal(await controller.play(), false);
|
|
});
|
|
test('manual play and seek never force the other recording to follow', async () => {
|
|
const {controller, original, port} = pair();
|
|
await controller.selectEvent(marker);
|
|
assert.equal(await controller.playSide('port'), true);
|
|
assert.ok(original.paused && !port.paused);
|
|
await controller.seekSide('port', 8);
|
|
assert.equal(original.currentTime, 2); assert.equal(port.currentTime, 8);
|
|
assert.ok(original.paused && port.paused);
|
|
});
|
|
test('external rate changes are corrected to actual speed without seeking', () => {
|
|
const {controller, original, port} = pair();
|
|
original.currentTime = 7; port.currentTime = 9;
|
|
port.playbackRate = 1.5; port.emit('ratechange');
|
|
assert.equal(port.playbackRate, 1);
|
|
assert.equal(port.currentTime, 9); assert.equal(original.currentTime, 7);
|
|
controller.pause();
|
|
});
|
|
test('event selection waits for asynchronous metadata and seek readiness', async () => {
|
|
const original = new Media(), port = new Media(); original.readyState = port.readyState = 0;
|
|
let t = 0;
|
|
Object.defineProperty(port, 'currentTime', {get: () => t, set: value => {
|
|
t = value; port.seeking = true;
|
|
setTimeout(() => {port.seeking = false; port.emit('seeked');}, 5);
|
|
}});
|
|
const controller = api.createPairController({original, port, timeoutMs: 100});
|
|
let finished = false;
|
|
const seek = controller.selectEvent(marker).then(() => {finished = true;});
|
|
await new Promise(resolve => setTimeout(resolve, 2));
|
|
assert.equal(finished, false); assert.equal(t, 0);
|
|
original.readyState = port.readyState = 4; original.emit('loadedmetadata'); port.emit('loadedmetadata');
|
|
await seek;
|
|
assert.equal(finished, true); assert.equal(port.currentTime, 3);
|
|
assert.ok(original.paused && port.paused);
|
|
});
|
|
test('seek timeout reports the cause and leaves pair paused', async () => {
|
|
const original = new Media(), port = new Media(); port.readyState = 0;
|
|
const controller = api.createPairController({original, port, timeoutMs: 10});
|
|
await assert.rejects(controller.selectEvent(marker), /readiness|metadata|timed out/i);
|
|
assert.match(controller.snapshot().problem, /readiness|metadata|timed out/i);
|
|
assert.ok(original.paused && port.paused);
|
|
});
|
|
test('buffering during a pending play cannot be erased by promise completion', async () => {
|
|
const {controller, original, port} = pair();
|
|
let release;
|
|
port.play = () => new Promise(resolve => { release = () => {port.paused = false; resolve();}; });
|
|
const playing = controller.play();
|
|
port.readyState = 2; port.emit('waiting'); release();
|
|
assert.equal(await playing, false);
|
|
assert.ok(original.paused && port.paused);
|
|
assert.match(controller.snapshot().problem, /buffer/i);
|
|
});
|
|
test('overlays start off and unsupported differences explain their gate', () => {
|
|
const {controller} = pair();
|
|
assert.deepEqual(controller.snapshot().overlays, {annotations: false, difference: false});
|
|
controller.setOverlay('annotations', true);
|
|
assert.equal(controller.snapshot().overlays.annotations, true);
|
|
assert.throws(() => controller.setOverlay('difference', true), /lossless|frame/i);
|
|
assert.equal(controller.snapshot().overlays.difference, false);
|
|
});
|
|
const frame = (sha = 'a'.repeat(64)) => ({url: 'sides/original/still.png', sha256: sha, size: 100,
|
|
frame: {lossless: true, event: 'landing', media_sha256: 'b'.repeat(64), media_seconds: 2,
|
|
viewport: [640, 480], crop: [0, 0, 640, 480], width: 640, height: 480}});
|
|
test('lossless differences need matched frame event viewport aspect and crop', () => {
|
|
assert.equal(typeof api.differenceEligibility, 'function');
|
|
const a = frame(), b = frame('c'.repeat(64));
|
|
assert.equal(api.differenceEligibility(a, b).eligible, true);
|
|
for (const patch of [{viewport: [800, 600]}, {crop: [1, 0, 639, 480]},
|
|
{event: 'jump'}, {lossless: false}, {media_sha256: null}]) {
|
|
const result = api.differenceEligibility(a, {...b, frame: {...b.frame, ...patch}});
|
|
assert.equal(result.eligible, false);
|
|
assert.ok(result.reason.length);
|
|
}
|
|
});
|
|
test('nonfinite elapsed or uncertainty is rejected before seeking', async () => {
|
|
const {controller, original} = pair();
|
|
for (const patch of [{elapsed_seconds: NaN}, {uncertainty_seconds: -1}])
|
|
await assert.rejects(controller.selectEvent({...marker, original: {...marker.original, ...patch}}));
|
|
assert.equal(original.currentTime, 0);
|
|
});
|
|
class Node {
|
|
children = []; textContent = '';
|
|
constructor(tag, ownerDocument) { this.tag = tag; this.ownerDocument = ownerDocument; }
|
|
append(...items) { this.children.push(...items); }
|
|
replaceChildren(...items) { this.children = items; }
|
|
get text() { return this.textContent + this.children.map(c => c.text).join(' '); }
|
|
}
|
|
test('capability renderer preserves facts, impact order, history and inert hostile text', () => {
|
|
const doc = {createElement: tag => new Node(tag, doc)};
|
|
const container = new Node('section', doc);
|
|
api.renderCapabilities(container, {capabilities: [{id: 'move', group: 'movement',
|
|
summary: '<script>malicious()</script>', requirement_ids: ['MOVE-01'],
|
|
verified_scope: 'bounded fixture', differences: ['unverified'], acceptance: {state: 'open'},
|
|
source_links: ['javascript:bad()'], scenario_ids: ['case-a'], current: ['native receipt'],
|
|
history: [{superseded: true, revision: 'old'}],
|
|
discrepancies: [{id: 'b', impact: 'subtle'}, {id: 'a', impact: 'blocking'}]}]});
|
|
assert.match(container.text, /<script>malicious\(\)<\/script>/);
|
|
assert.match(container.text, /MOVE-01/); assert.match(container.text, /superseded/);
|
|
assert.ok(container.text.indexOf('blocking') < container.text.indexOf('subtle'));
|
|
assert.ok(container.children.some(c => c.children?.some(n => n.tag === 'details')));
|
|
assert.equal(container.children.some(c => c.tag === 'script'), false);
|
|
});
|
|
test('empty capability export has an explicit open state', () => {
|
|
const doc = {createElement: tag => new Node(tag, doc)};
|
|
const container = new Node('section', doc);
|
|
api.renderCapabilities(container, {capabilities: []});
|
|
assert.match(container.text, /No capability ledger supplied.*open/);
|
|
});
|
|
test('percent-encoded local filenames remain inert and usable', () => {
|
|
assert.equal(api.safeLocalURL('sides/port/frame%20one%23.png'), 'sides/port/frame%20one%23.png');
|
|
assert.throws(() => api.safeLocalURL('sides/port/frame.png?redirect=http://host'));
|
|
});
|
|
test('difference frame must match its own observed source event and timestamp', () => {
|
|
const a = frame(), b = frame('c'.repeat(64));
|
|
const side = artifact => ({media: {path: 'video.webm', sha256: 'b'.repeat(64), duration_seconds: 10},
|
|
artifacts: [artifact], events: [{name: 'landing', artifact: 'video.webm', media_seconds: 2}]});
|
|
const model = {sides: {original: side(a), port: side(b)}};
|
|
assert.equal(api.framePair(model).port, b);
|
|
model.sides.port.events[0].media_seconds = 3;
|
|
assert.equal(api.framePair(model).port, undefined);
|
|
model.sides.port.events[0].media_seconds = 2;
|
|
model.sides.port.media.sha256 = 'd'.repeat(64);
|
|
assert.equal(api.framePair(model).port, undefined);
|
|
});
|
|
test('a newer event seek supersedes pending metadata without cancelling the newer action', async () => {
|
|
const original = new Media(), port = new Media(); original.readyState = port.readyState = 0;
|
|
const controller = api.createPairController({original, port, timeoutMs: 100});
|
|
const old = controller.selectEvent(marker).catch(error => error);
|
|
const next = {...marker, name: 'idle', original: {...marker.original, media_seconds: 4}, port: {...marker.port, media_seconds: 5}};
|
|
const recent = controller.selectEvent(next);
|
|
original.readyState = port.readyState = 4; original.emit('loadedmetadata'); port.emit('loadedmetadata');
|
|
assert.match((await old).message, /cancelled/);
|
|
await recent;
|
|
assert.equal(original.currentTime, 4); assert.equal(port.currentTime, 5);
|
|
assert.equal(controller.snapshot().selected.name, 'idle');
|
|
assert.equal(controller.snapshot().selecting, false);
|
|
assert.equal(await controller.play(), true);
|
|
});
|
|
test('suite executes at least sixteen registered behavior tests', () => {
|
|
assert.ok(declared >= 16, 'runner must register at least sixteen tests');
|
|
});
|