Files
quality_analyse/web/verification/unified_loading.test.mjs

85 lines
2.9 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createVisiblePollingController } from '../src/visiblePollingController.ts';
function fakeClock() {
let nextId = 0;
let now = 0;
const timers = new Map();
return {
timers,
now: () => now,
setTimeout(callback, delay) { const id = ++nextId; timers.set(id, { at: now + delay, callback }); return id; },
clearTimeout(id) { timers.delete(id); },
advance(ms) {
now += ms;
const due = [...timers.entries()].filter(([, timer]) => timer.at <= now).sort((a, b) => a[1].at - b[1].at);
for (const [id, timer] of due) { timers.delete(id); timer.callback(); }
},
};
}
const flush = async () => { await Promise.resolve(); await Promise.resolve(); };
test('polls serially and waits the full interval after each request settles', async () => {
const clock = fakeClock(); let completeFirst; let calls = 0;
const controller = createVisiblePollingController(() => {
calls++;
if (calls === 1) return new Promise(resolve => { completeFirst = resolve; });
}, 15000, clock);
controller.start(true);
assert.equal(calls, 0);
clock.advance(15000);
await flush();
assert.equal(calls, 1);
clock.advance(60000);
assert.equal(calls, 1, 'an unresolved request prevents overlap');
completeFirst();
await flush();
clock.advance(14999);
assert.equal(calls, 1);
clock.advance(1);
await flush();
assert.equal(calls, 2);
controller.stop();
assert.equal(clock.timers.size, 0);
});
test('pauses while hidden and immediately checks on resume without overlapping an in-flight read', async () => {
const clock = fakeClock(); let release; let calls = 0; let concurrent = 0; let maxConcurrent = 0;
const controller = createVisiblePollingController(async () => {
calls++; concurrent++; maxConcurrent = Math.max(maxConcurrent, concurrent);
if (calls === 1) await new Promise(resolve => { release = resolve; });
concurrent--;
}, 2000, clock);
controller.start(false, true);
assert.equal(calls, 0);
controller.setVisible(true);
await flush();
assert.equal(calls, 1);
controller.setVisible(false);
controller.setVisible(true);
await flush();
assert.equal(calls, 1, 'visibility return queues an immediate read behind the active request');
release();
await flush();
await flush();
assert.equal(calls, 2);
assert.equal(maxConcurrent, 1);
controller.stop();
assert.equal(clock.timers.size, 0);
});
test('stopping polling leaves the current request alone and prevents future scheduling', async () => {
const clock = fakeClock(); let release; let calls = 0;
const controller = createVisiblePollingController(() => { calls++; return new Promise(resolve => { release = resolve; }); }, 5000, clock);
controller.start(true);
clock.advance(5000);
await flush();
controller.stop();
release();
await flush();
assert.equal(clock.timers.size, 0);
clock.advance(50000);
assert.equal(calls, 1);
});