From 741ddd5fa182a26ee4a00a9b0e9cdc6a27deca5d Mon Sep 17 00:00:00 2001 From: Omri Katz <9701896+omridevk@users.noreply.github.com> Date: Tue, 11 Aug 2026 01:00:03 +0300 Subject: [PATCH 1/4] fix(extension-testkit): name-bound the dispose steps and stop rpc-observer timers outliving their observer (#361) settleTeardown now names each step and wraps it in p-timeout (20s default), so a wedged closeBrowser/close/stop names itself in the error instead of blowing vitest's generic 30s hookTimeout, and the sibling steps still settle inside the hook budget. rpc-observer's dispose() cleared its waiters Set but never cancelled the setTimeout each buffered() call schedules, so a pending wait outlived its own observer and page; under @playwright/test's single-worker-per-file run, that timer could fire during a later, unrelated test and misattribute a timeout. dispose() now fails every pending waiter (which clears its timer) before clearing the set, and openObservedPage wires dispose to the page's own 'close' event so observers never outlive the page that owns them. Refs #361, epic #409. --- packages/extension-testkit/package.json | 1 + .../src/get-extension-test-api.ts | 6 +++- packages/extension-testkit/src/launch.ts | 3 +- .../extension-testkit/src/rpc-observer.ts | 3 ++ .../extension-testkit/src/settle-teardown.ts | 22 +++++++++++-- .../test/rpc-observer-dispose.it.test.ts | 33 +++++++++++++++++++ .../test/settle-teardown.test.ts | 24 ++++++++++++++ pnpm-lock.yaml | 3 ++ 8 files changed, 91 insertions(+), 4 deletions(-) create mode 100644 packages/extension-testkit/test/rpc-observer-dispose.it.test.ts create mode 100644 packages/extension-testkit/test/settle-teardown.test.ts 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..8503e3dabb 100644 --- a/packages/extension-testkit/src/rpc-observer.ts +++ b/packages/extension-testkit/src/rpc-observer.ts @@ -302,6 +302,9 @@ export function observeRpc(page: Page): RpcObserver { page.off('request', onRequest) page.off('response', onResponse) page.off('websocket', onSocket) + for (const waiter of waiters) { + 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..159e0889dd 100644 --- a/packages/extension-testkit/src/settle-teardown.ts +++ b/packages/extension-testkit/src/settle-teardown.ts @@ -1,5 +1,23 @@ -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(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..a8dc9df575 --- /dev/null +++ b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts @@ -0,0 +1,33 @@ +import {chromium} from 'playwright' +import {test, expect} from 'vitest' +import {launch} from '../src/launch.js' +import {observeRpc, rpcObserverFor} from '../src/rpc-observer.js' + +const NATURAL_TIMEOUT_MS = 300 +const DISPOSE_SETTLE_BUDGET_MS = 150 + +test('dispose fails the pending waiter immediately instead of leaving its timer to fire naturally', async () => { + const browser = await chromium.launch() + 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(() => {}) + const disposedAt = Date.now() + observer.dispose() + await expect(pending).rejects.toThrow(/disposed/) + expect(Date.now() - disposedAt).toBeLessThan(DISPOSE_SETTLE_BUDGET_MS) + } finally { + await browser.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/) +}) 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..4664c43b3d --- /dev/null +++ b/packages/extension-testkit/test/settle-teardown.test.ts @@ -0,0 +1,24 @@ +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']) +}) 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 From 8b4afabae49d7f38330b3c9a81a55418a7fbbe99 Mon Sep 17 00:00:00 2001 From: Omri Katz <9701896+omridevk@users.noreply.github.com> Date: Tue, 11 Aug 2026 01:23:50 +0300 Subject: [PATCH 2/4] fix(extension-testkit): silence disposal rejections for un-awaited rpc-observer waits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CI caught a regression from the prior dispose fix: embed's composer-rich-input.it.test.ts failed with "Error: rpc observer disposed while awaiting page.queries" leaking as an unhandled rejection from an abandoned wait (a wait a test never awaited, or moved on from before the page closed). Root cause: completed()/firstEvent() were async wrapper functions, so the promise a caller actually holds is a *different* object from the internal buffered() promise — attaching a no-op .catch() to only the internal one (the previous fix) didn't reach the outer promise callers can abandon. Collapsed the wrapper: buffered()/settle() now take the result projection directly and return the exact promise handed to callers, so Waiter.promise IS that promise. dispose() attaches a no-op .catch() to it before failing it, so an abandoned wait's disposal rejection is always handled (no leak) while an awaited wait still receives the rejection (multiple handlers each get it). Refs #361, epic #409. --- .../extension-testkit/src/rpc-observer.ts | 89 ++++++++++++------- .../test/rpc-observer-dispose.it.test.ts | 26 ++++++ 2 files changed, 82 insertions(+), 33 deletions(-) diff --git a/packages/extension-testkit/src/rpc-observer.ts b/packages/extension-testkit/src/rpc-observer.ts index 8503e3dabb..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, @@ -303,6 +325,7 @@ export function observeRpc(page: Page): RpcObserver { 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/test/rpc-observer-dispose.it.test.ts b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts index a8dc9df575..404175dea9 100644 --- a/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts +++ b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts @@ -31,3 +31,29 @@ test('closing the launched page disposes its rpc observer and cancels pending wa 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 () => { + const browser = await chromium.launch() + 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 browser.close() + } +}) From c81ee05ea7bda6845f61d61bcd195dce7332ac0a Mon Sep 17 00:00:00 2001 From: Omri Katz <9701896+omridevk@users.noreply.github.com> Date: Tue, 11 Aug 2026 02:29:26 +0300 Subject: [PATCH 3/4] fix(extension-testkit): address PR #418 review findings - settle-teardown.ts: wrap step.run() in Promise.resolve().then() before pTimeout so a step that throws synchronously (not just one that returns a rejected promise) still lets sibling steps start and complete, instead of throwing out of steps.map() before any step began. - rpc-observer-dispose.it.test.ts: drop the wall-clock Date.now()-delta assertion; a descheduled CI worker can fail it for reasons unrelated to the code under test. rejects.toThrow(/disposed/) already proves disposal beat the natural timeout semantically. - rpc-observer-dispose.it.test.ts: migrate the two raw chromium.launch() calls onto @conciv/browser-fixture's file-scoped, timeout-bounded browser fixture (already a direct dependency), each test opening and closing its own page. The third test (closing the launched page...) is unchanged: it exercises launch.ts's own browser lifecycle, not a bare chromium.launch() call. Refs #361, epic #409. --- .../extension-testkit/src/settle-teardown.ts | 11 ++++++---- .../test/rpc-observer-dispose.it.test.ts | 21 +++++++++---------- .../test/settle-teardown.test.ts | 16 ++++++++++++++ 3 files changed, 33 insertions(+), 15 deletions(-) diff --git a/packages/extension-testkit/src/settle-teardown.ts b/packages/extension-testkit/src/settle-teardown.ts index 159e0889dd..bd06464c51 100644 --- a/packages/extension-testkit/src/settle-teardown.ts +++ b/packages/extension-testkit/src/settle-teardown.ts @@ -12,10 +12,13 @@ export async function settleTeardown(steps: readonly TeardownStep[]): Promise { const milliseconds = step.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS - return pTimeout(step.run(), { - milliseconds, - message: `testkit ${step.name} exceeded ${milliseconds}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') diff --git a/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts index 404175dea9..f4deee859b 100644 --- a/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts +++ b/packages/extension-testkit/test/rpc-observer-dispose.it.test.ts @@ -1,25 +1,23 @@ -import {chromium} from 'playwright' -import {test, expect} from 'vitest' +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 -const DISPOSE_SETTLE_BUDGET_MS = 150 -test('dispose fails the pending waiter immediately instead of leaving its timer to fire naturally', async () => { - const browser = await chromium.launch() +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(() => {}) - const disposedAt = Date.now() observer.dispose() await expect(pending).rejects.toThrow(/disposed/) - expect(Date.now() - disposedAt).toBeLessThan(DISPOSE_SETTLE_BUDGET_MS) } finally { - await browser.close() + await page.close() } }) @@ -32,8 +30,9 @@ test('closing the launched page disposes its rpc observer and cancels pending wa 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 () => { - const browser = await chromium.launch() +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 { @@ -54,6 +53,6 @@ test('dispose does not leak an unhandled rejection for a wait nobody awaited, an process.off('unhandledRejection', onUnhandledRejection) } } finally { - await browser.close() + await page.close() } }) diff --git a/packages/extension-testkit/test/settle-teardown.test.ts b/packages/extension-testkit/test/settle-teardown.test.ts index 4664c43b3d..a2b2910471 100644 --- a/packages/extension-testkit/test/settle-teardown.test.ts +++ b/packages/extension-testkit/test/settle-teardown.test.ts @@ -22,3 +22,19 @@ test('a wedged step rejects with its own name after its own timeout, and the oth ).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']) +}) From 694a32eb5fbce56198428bd2e3f93f66dafed2ff Mon Sep 17 00:00:00 2001 From: Omri Katz <9701896+omridevk@users.noreply.github.com> Date: Tue, 11 Aug 2026 03:02:31 +0300 Subject: [PATCH 4/4] fix(embed): catch the unawaited derived promise in the no-false-match rpc-observer test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CI (run 31442555924, shard-1) failed rpc-observer.it.test.ts:186 with "rpc observer disposed while awaiting page.queries" — not composer-rich-input as first suspected. The test intentionally leaves a page.queries wait pending (proving an extension-namespaced call never falsely matches the core path) and disposes while it's still pending, which #361's dispose contract correctly rejects. The test derived a second promise via `.then()` with no `.catch()`; dispose's own `waiter.promise.catch(() => {})` only guards the promise it holds, not sibling branches callers derive from it, so the derived chain surfaced as an unhandled rejection. Attaching `.catch()` to that derived chain is enough — no rpc-observer.ts change needed, the dispose contract in rpc-observer-dispose.it.test.ts is correct and unchanged. Co-Authored-By: Claude Fable 5 --- packages/embed/tests/e2e/rpc-observer.it.test.ts | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) 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)