:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import { createPrefetchQueue, PREFETCH_CONCURRENCY, prefetchRows, prefetchWindow } from './prefetchPlan'
const ids = (count: number): string[] => Array.from({ length: count }, (_, index) => `r${index}`)
interface Deferred {
resolve: () => void
reject: (error: Error) => void
}
function controlledRun(): { run: (id: string) => Promise<void>; started: string[]; settle: Map<string, Deferred> } {
const started: string[] = []
const settle = new Map<string, Deferred>()
const run = (id: string): Promise<void> => {
started.push(id)
return new Promise<void>((resolve, reject) => settle.set(id, { resolve, reject }))
}
return { run, started, settle }
}
const flush = (): Promise<void> => new Promise((resolve) => setImmediate(resolve))
describe('prefetchPlan', () => {
test.each<[string, number, number | null, number | null, string[]]>([
['no viewability event yet', 100, null, null, []],
['visible rows plus one ahead', 100, 0, 2, ids(4)],
['earlier offscreen rows are excluded', 100, 20, 23, ids(25).slice(20)],
['a short list is not overrun', 3, 1, 2, ['r1', 'r2']],
['only closed rows are visible', 10, 2, 1, []],
])('prefetchWindow: %s', (_name, length, firstVisible, lastVisible, expected) => {
const rows = prefetchRows(ids(length).map((reportId) => ({ reportId, state: 'open' })))
const visible =
firstVisible === null || lastVisible === null ? null : { first: firstVisible, last: lastVisible }
expect(prefetchWindow(rows, visible)).toEqual(expected)
})
test('prefetchRows skips done and dismissed rows and maps list rows onto the remaining ids', () => {
const rows = prefetchRows([
{ reportId: 'a', state: 'done' },
{ reportId: 'b', state: 'open' },
{ reportId: 'c', state: 'dismissed' },
{ reportId: 'd', state: 'snoozed' },
])
expect(rows).toEqual({ ids: ['b', 'd'], idIndexByRow: [-1, 0, 0, 1] })
expect(prefetchWindow(rows, { first: 2, last: 3 })).toEqual(['d'])
})
test('queue runs an id once while it is pending or running, and again after its run settles', async () => {
const { run, started, settle } = controlledRun()
const queue = createPrefetchQueue(run)
queue.enqueue(ids(PREFETCH_CONCURRENCY + 1))
queue.enqueue(ids(PREFETCH_CONCURRENCY + 1))
expect(started).toEqual(ids(PREFETCH_CONCURRENCY))
settle.get('r0')?.resolve()
await flush()
queue.enqueue(['r0'])
expect(started).toEqual(ids(PREFETCH_CONCURRENCY + 1))
settle.get(`r${PREFETCH_CONCURRENCY}`)?.resolve()
settle.get('r1')?.resolve()
await flush()
expect(started).toEqual([...ids(PREFETCH_CONCURRENCY + 1), 'r0'])
})
test('queue starts at most the concurrency limit until a run settles', async () => {
const { run, started, settle } = controlledRun()
createPrefetchQueue(run).enqueue(ids(5))
expect(started).toEqual(ids(PREFETCH_CONCURRENCY))
settle.get('r0')?.resolve()
await flush()
expect(started).toEqual(ids(PREFETCH_CONCURRENCY + 1))
})
test('queue starts the next run after a rejected one', async () => {
const { run, started, settle } = controlledRun()
createPrefetchQueue(run).enqueue(ids(PREFETCH_CONCURRENCY + 1))
settle.get('r0')?.reject(new Error('offline'))
await flush()
expect(started).toContain(`r${PREFETCH_CONCURRENCY}`)
})
test('a new visible window drops older pending rows', async () => {
const { run, started, settle } = controlledRun()
const queue = createPrefetchQueue(run)
queue.enqueue(['a', 'b', 'c'])
queue.enqueue(['x', 'y'])
settle.get('a')?.resolve()
await flush()
expect(started).toEqual(['a', 'x'])
})
test('queue reset drops the pending ids and lets the runs in flight finish', async () => {
const { run, started, settle } = controlledRun()
const queue = createPrefetchQueue(run)
queue.enqueue(ids(PREFETCH_CONCURRENCY + 1))
queue.reset()
queue.enqueue(['x'])
for (const id of ids(PREFETCH_CONCURRENCY)) {
settle.get(id)?.resolve()
}
await flush()
expect(started).toEqual([...ids(PREFETCH_CONCURRENCY), 'x'])
})
})