85 lines
2.9 KiB
JavaScript
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);
|
|
});
|