Skip to content

: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.

4.3 KB
Raw Blame
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'])
    })
})