diff --git a/tests/fidelity-viewer.test.mjs b/tests/fidelity-viewer.test.mjs index c40644b..ab6d6d9 100644 --- a/tests/fidelity-viewer.test.mjs +++ b/tests/fidelity-viewer.test.mjs @@ -54,6 +54,161 @@ test('relative artifact links reject remote and active URL schemes', () => { test('capability navigation is supplied through a renderer', () => { assert.equal(typeof api.renderCapabilities, 'function'); }); -test('suite executes a positive declared count', () => { - assert.ok(declared >= 6, 'runner must register a positive number of behavior tests'); +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); +}); +test('suite executes at least sixteen registered behavior tests', () => { + assert.ok(declared >= 16, 'runner must register at least sixteen tests'); });