diff --git a/packages/embed/tests/e2e/rpc-observer.it.test.ts b/packages/embed/tests/e2e/rpc-observer.it.test.ts index becc2746cc..f75e5c369a 100644 --- a/packages/embed/tests/e2e/rpc-observer.it.test.ts +++ b/packages/embed/tests/e2e/rpc-observer.it.test.ts @@ -187,9 +187,11 @@ test.describe('the shared rpc observer correlates calls on both transports', () const {observer} = await openProbePage(page) const core = observer.completed({path: ['page', 'queries'], timeout: 15_000}) const settlement = {done: false} - void core.then(() => { - settlement.done = true - }) + core + .then(() => { + settlement.done = true + }) + .catch(() => undefined) await page .evaluate(() => window.__CONCIV_WS_PROBE__.call(['ext', 'page-probe', 'page', 'queries'], undefined)) .catch(() => undefined) diff --git a/packages/extension-testkit/package.json b/packages/extension-testkit/package.json index 0563888088..982803f311 100644 --- a/packages/extension-testkit/package.json +++ b/packages/extension-testkit/package.json @@ -48,6 +48,7 @@ "@orpc/standard-server-peer": "catalog:", "@playwright/test": "^1.61.1", "@vitest/coverage-v8": "^4.1.8", + "p-timeout": "^7.0.1", "playwright": "^1.61.1", "solid-js": "^1.9.13", "unocss": "^66.7.2", diff --git a/packages/extension-testkit/src/get-extension-test-api.ts b/packages/extension-testkit/src/get-extension-test-api.ts index 9e6e0eac9f..c54d7d1d8d 100644 --- a/packages/extension-testkit/src/get-extension-test-api.ts +++ b/packages/extension-testkit/src/get-extension-test-api.ts @@ -61,7 +61,11 @@ export async function getExtensionTestApi(extension: ExtensionUnderTest): Promis return {page: second, close: () => second.close()} }, dispose: async () => { - await settleTeardown([() => closeBrowser(), () => close(), () => stop()]) + await settleTeardown([ + {name: 'closeBrowser', run: () => closeBrowser()}, + {name: 'close', run: () => close()}, + {name: 'stop', run: () => stop()}, + ]) }, } } diff --git a/packages/extension-testkit/src/launch.ts b/packages/extension-testkit/src/launch.ts index f12e44114c..f9f2328c07 100644 --- a/packages/extension-testkit/src/launch.ts +++ b/packages/extension-testkit/src/launch.ts @@ -5,7 +5,8 @@ export type LaunchedPage = {page: Page; context: BrowserContext; close: () => Pr export async function openObservedPage(context: BrowserContext, url: string): Promise { const page = await context.newPage() - rpcObserverFor(page) + const observer = rpcObserverFor(page) + page.once('close', () => observer.dispose()) await page.goto(url, {waitUntil: 'domcontentloaded'}) return page } diff --git a/packages/extension-testkit/src/rpc-observer.ts b/packages/extension-testkit/src/rpc-observer.ts index b36f9bf9eb..05b04771be 100644 --- a/packages/extension-testkit/src/rpc-observer.ts +++ b/packages/extension-testkit/src/rpc-observer.ts @@ -49,10 +49,25 @@ type Need = 'completed' | 'first-event' type Waiter = { filter: RpcCallFilter needs: Need + promise: Promise deliver: (state: CallState) => void fail: (error: Error) => void } +function createDeferred(): { + promise: Promise + resolve: (value: Value) => void + reject: (error: Error) => void +} { + let resolve: (value: Value) => void = () => {} + let reject: (error: Error) => void = () => {} + const promise = new Promise((res, rej) => { + resolve = res + reject = rej + }) + return {promise, resolve, reject} +} + function matchesPattern(actual: unknown, expected: unknown): boolean { if (expected instanceof RegExp) return expected.test(typeof actual === 'string' ? actual : JSON.stringify(actual)) if (Array.isArray(expected)) { @@ -244,43 +259,53 @@ export function observeRpc(page: Page): RpcObserver { page.on('response', onResponse) page.on('websocket', onSocket) - const buffered = (filter: RpcCallFilter, needs: Need): Promise => { + const buffered = ( + filter: RpcCallFilter, + needs: Need, + project: (state: CallState) => Result, + ): Promise => { const timeoutMs = filter.timeout ?? DEFAULT_TIMEOUT_MS - return new Promise((resolve, reject) => { - const timer = setTimeout(() => { - waiters.delete(waiter) - const observed = states.map((state) => state.record.procedurePath.join('.')).join(', ') - reject( - new Error( - `no rpc call to ${filter.path.join('.')} reached "${needs}" within ${timeoutMs}ms (observed calls: ${observed})`, - ), - ) - }, timeoutMs) - const waiter: Waiter = { - filter, - needs, - deliver: (state) => { - clearTimeout(timer) - resolve(state) - }, - fail: (error) => { - clearTimeout(timer) - reject(error) - }, - } - waiters.add(waiter) - }) + const deferred = createDeferred() + const timer = setTimeout(() => { + waiters.delete(waiter) + const observed = states.map((state) => state.record.procedurePath.join('.')).join(', ') + deferred.reject( + new Error( + `no rpc call to ${filter.path.join('.')} reached "${needs}" within ${timeoutMs}ms (observed calls: ${observed})`, + ), + ) + }, timeoutMs) + const projected = deferred.promise.then(project) + const waiter: Waiter = { + filter, + needs, + promise: projected, + deliver: (state) => { + clearTimeout(timer) + deferred.resolve(state) + }, + fail: (error) => { + clearTimeout(timer) + deferred.reject(error) + }, + } + waiters.add(waiter) + return projected } - const settle = (filter: RpcCallFilter, needs: Need): Promise => { + const settle = ( + filter: RpcCallFilter, + needs: Need, + project: (state: CallState) => Result, + ): Promise => { if (drift.error) return Promise.reject(drift.error) const seen = states.find((state) => matches(state, filter, 'completion') && satisfied(state, needs)) - if (seen) return Promise.resolve(seen) + if (seen) return Promise.resolve(project(seen)) const answeredOverFetch = states.find( (state) => matches(state, filter, 'completion') && state.record.transport === 'fetch', ) if (needs === 'first-event' && answeredOverFetch) return Promise.reject(fetchIteratorError(filter)) - return buffered(filter, needs) + return buffered(filter, needs, project) } const counted = (filter: Omit, stamp: Stamp): number => { @@ -290,11 +315,8 @@ export function observeRpc(page: Page): RpcObserver { return { mark: () => sequence.next, - completed: async (filter) => (await settle(filter, 'completed')).record, - firstEvent: async (filter) => { - const state = await settle(filter, 'first-event') - return {call: state.record, data: state.events[0]} - }, + completed: (filter) => settle(filter, 'completed', (state) => state.record), + firstEvent: (filter) => settle(filter, 'first-event', (state) => ({call: state.record, data: state.events[0]})), startedCount: (filter) => counted(filter, 'start'), completedCount: (filter) => counted(filter, 'completion'), socketCount: () => sockets.count, @@ -302,6 +324,10 @@ export function observeRpc(page: Page): RpcObserver { page.off('request', onRequest) page.off('response', onResponse) page.off('websocket', onSocket) + for (const waiter of waiters) { + waiter.promise.catch(() => {}) + waiter.fail(new Error(`rpc observer disposed while awaiting ${waiter.filter.path.join('.')}`)) + } waiters.clear() }, } diff --git a/packages/extension-testkit/src/settle-teardown.ts b/packages/extension-testkit/src/settle-teardown.ts index ca8cd17252..bd06464c51 100644 --- a/packages/extension-testkit/src/settle-teardown.ts +++ b/packages/extension-testkit/src/settle-teardown.ts @@ -1,5 +1,26 @@ -export async function settleTeardown(steps: Array<() => Promise>): Promise { - const results = await Promise.allSettled(steps.map((step) => step())) +import pTimeout from 'p-timeout' + +const DEFAULT_STEP_TIMEOUT_MS = 20_000 + +export type TeardownStep = { + name: string + run: () => Promise + timeoutMs?: number +} + +export async function settleTeardown(steps: readonly TeardownStep[]): Promise { + const results = await Promise.allSettled( + steps.map((step) => { + const milliseconds = step.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS + return pTimeout( + Promise.resolve().then(() => step.run()), + { + milliseconds, + message: `testkit ${step.name} exceeded ${milliseconds}ms`, + }, + ) + }), + ) const firstFailure = results.find((result): result is PromiseRejectedResult => result.status === 'rejected') if (firstFailure) throw firstFailure.reason } diff --git a/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts new file mode 100644 index 0000000000..f4deee859b --- /dev/null +++ b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts @@ -0,0 +1,58 @@ +import {expect} from 'vitest' +import {test} from '@conciv/browser-fixture' +import {launch} from '../src/launch.js' +import {observeRpc, rpcObserverFor} from '../src/rpc-observer.js' + +const NATURAL_TIMEOUT_MS = 300 + +test('dispose fails the pending waiter immediately instead of leaving its timer to fire naturally', async ({ + browser, +}) => { + const page = await browser.newPage() + await page.goto('about:blank') + try { + const observer = observeRpc(page) + const pending = observer.completed({path: ['never', 'called'], timeout: NATURAL_TIMEOUT_MS}) + pending.catch(() => {}) + observer.dispose() + await expect(pending).rejects.toThrow(/disposed/) + } finally { + await page.close() + } +}) + +test('closing the launched page disposes its rpc observer and cancels pending waits', async () => { + const {page, close} = await launch('about:blank') + const observer = rpcObserverFor(page) + const pending = observer.completed({path: ['never', 'called'], timeout: NATURAL_TIMEOUT_MS}) + pending.catch(() => {}) + await close() + await expect(pending).rejects.toThrow(/disposed/) +}) + +test('dispose does not leak an unhandled rejection for a wait nobody awaited, and an awaited wait still rejects', async ({ + browser, +}) => { + const page = await browser.newPage() + await page.goto('about:blank') + try { + const observer = observeRpc(page) + observer.completed({path: ['abandoned', 'wait'], timeout: NATURAL_TIMEOUT_MS}) + const awaited = observer.completed({path: ['awaited', 'wait'], timeout: NATURAL_TIMEOUT_MS}) + + const unhandled: unknown[] = [] + const onUnhandledRejection = (reason: unknown): void => void unhandled.push(reason) + process.on('unhandledRejection', onUnhandledRejection) + + try { + observer.dispose() + await expect(awaited).rejects.toThrow(/disposed/) + await new Promise((resolve) => setImmediate(resolve)) + expect(unhandled).toEqual([]) + } finally { + process.off('unhandledRejection', onUnhandledRejection) + } + } finally { + await page.close() + } +}) diff --git a/packages/extension-testkit/test/settle-teardown.test.ts b/packages/extension-testkit/test/settle-teardown.test.ts new file mode 100644 index 0000000000..a2b2910471 --- /dev/null +++ b/packages/extension-testkit/test/settle-teardown.test.ts @@ -0,0 +1,40 @@ +import {expect, test} from 'vitest' +import {settleTeardown} from '../src/settle-teardown.js' + +test('all steps succeeding resolves without throwing', async () => { + const completed: string[] = [] + await settleTeardown([ + {name: 'first', run: async () => void completed.push('first')}, + {name: 'second', run: async () => void completed.push('second')}, + ]) + expect(completed.toSorted()).toEqual(['first', 'second']) +}) + +test('a wedged step rejects with its own name after its own timeout, and the other steps still complete', async () => { + const completed: string[] = [] + const wedged = new Promise(() => {}) + await expect( + settleTeardown([ + {name: 'closeBrowser', run: () => wedged, timeoutMs: 20}, + {name: 'close', run: async () => void completed.push('close')}, + {name: 'stop', run: async () => void completed.push('stop')}, + ]), + ).rejects.toThrow('testkit closeBrowser exceeded 20ms') + expect(completed.toSorted()).toEqual(['close', 'stop']) +}) + +test('a step whose run() throws synchronously still lets a later step complete', async () => { + const completed: string[] = [] + await expect( + settleTeardown([ + { + name: 'throwsSync', + run: () => { + throw new Error('boom') + }, + }, + {name: 'after', run: async () => void completed.push('after')}, + ]), + ).rejects.toThrow('boom') + expect(completed).toEqual(['after']) +}) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 404da01b7d..0cab1d3d96 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -2007,6 +2007,9 @@ importers: '@vitest/coverage-v8': specifier: ^4.1.8 version: 4.1.10(@vitest/browser@4.1.10)(vitest@4.1.10) + p-timeout: + specifier: ^7.0.1 + version: 7.0.1 playwright: specifier: ^1.61.1 version: 1.61.1