Files
quality_analyse/web/verification/workspace_transition.test.mjs
T

35 lines
4.2 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createWorkspaceTransition, waitForWorkspaceContent } from '../src/workspaceTransition.ts';
const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return {promise,resolve};};
function nativeFixture(){const records=[];const start=update=>{const ready=deferred(),finished=deferred(),record={update,ready,finished,skipped:0};records.push(record);return {ready:ready.promise,finished:finished.promise,skipTransition(){record.skipped++;}};};return {start,records};}
test('rapid selections only commit the latest route even when skipped native callbacks still execute',async()=>{
const native=nativeFixture(),controller=createWorkspaceTransition(native.start),pages=[];
controller.run(()=>pages.push('department'));controller.run(()=>pages.push('overall'));
assert.equal(native.records[0].skipped,1);await native.records[0].update();await native.records[1].update();assert.deepEqual(pages,['overall']);controller.cancel();
});
test('new navigation interrupts preparation of the previous target without queueing behind it',async()=>{
const native=nativeFixture(),controller=createWorkspaceTransition(native.start),pages=[];let previousSignal;
controller.run(signal=>{pages.push('department');previousSignal=signal;return new Promise(resolve=>signal.addEventListener('abort',resolve,{once:true}));});
const preparing=native.records[0].update();controller.run(()=>pages.push('product'));assert.equal(previousSignal.aborted,true);await preparing;await native.records[1].update();assert.deepEqual(pages,['department','product']);controller.cancel();
});
test('reduced motion and unavailable APIs commit immediately',()=>{
for(const reduced of [true,false]){let starts=0,commits=0;const controller=createWorkspaceTransition(reduced?()=>{starts++;throw Error('must not start');}:undefined,()=>reduced);controller.run(()=>commits++);assert.equal(starts,0);assert.equal(commits,1);controller.cancel();}
});
test('native failure falls back exactly once and cancellation rejects stale pending navigation',async()=>{
let commits=0;createWorkspaceTransition(()=>{throw Error('unavailable snapshot');}).run(()=>commits++);assert.equal(commits,1);
const native=nativeFixture(),controller=createWorkspaceTransition(native.start);controller.run(()=>commits++);controller.cancel();await native.records[0].update();assert.equal(commits,1);
});
test('content preparation resolves on readiness, timeout or abort and always releases observers/timers',async()=>{
const previous={window:globalThis.window,document:globalThis.document,MutationObserver:globalThis.MutationObserver};let callback,disconnected=0;const timers=new Map();let timerId=0;
globalThis.window={setTimeout(fn,delay){const id=++timerId;timers.set(id,{fn:()=>{timers.delete(id);fn();},delay});return id;},clearTimeout:id=>timers.delete(id)};globalThis.document={body:{}};globalThis.MutationObserver=class{constructor(fn){callback=fn;}observe(){}disconnect(){disconnected++;}};
try{let busy=true;const node={querySelector:()=>busy?{}:null};const a=new AbortController();let done=false;const first=waitForWorkspaceContent(()=>node,a.signal).then(()=>done=true);await Promise.resolve();assert.equal(done,false);busy=false;callback();[...timers.values()].find(x=>x.delay===32).fn();await first;assert.equal(timers.size,0);
const b=new AbortController();const second=waitForWorkspaceContent(()=>null,b.signal);b.abort();await second;assert.equal(timers.size,0);
const third=waitForWorkspaceContent(()=>null,new AbortController().signal);[...timers.values()][0].fn();await third;assert.equal(timers.size,0);assert.equal(disconnected,3);
}finally{for(const [key,value] of Object.entries(previous)){if(value===undefined)delete globalThis[key];else globalThis[key]=value;}}
});
test('an older completion never unlocks input while the newer transition is still running',async()=>{
const native=nativeFixture(),busy=[],controller=createWorkspaceTransition(native.start,()=>false,value=>busy.push(value));controller.run(()=>{});controller.run(()=>{});native.records[0].finished.resolve();await Promise.resolve();assert.equal(busy.at(-1),true);native.records[1].finished.resolve();await Promise.resolve();assert.equal(busy.at(-1),false);controller.cancel();
});