Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 5 additions & 3 deletions packages/embed/tests/e2e/rpc-observer.it.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
1 change: 1 addition & 0 deletions packages/extension-testkit/package.json
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down
6 changes: 5 additions & 1 deletion packages/extension-testkit/src/get-extension-test-api.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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()},
])
},
}
}
3 changes: 2 additions & 1 deletion packages/extension-testkit/src/launch.ts
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,8 @@ export type LaunchedPage = {page: Page; context: BrowserContext; close: () => Pr

export async function openObservedPage(context: BrowserContext, url: string): Promise<Page> {
const page = await context.newPage()
rpcObserverFor(page)
const observer = rpcObserverFor(page)
page.once('close', () => observer.dispose())
await page.goto(url, {waitUntil: 'domcontentloaded'})
return page
}
Expand Down
92 changes: 59 additions & 33 deletions packages/extension-testkit/src/rpc-observer.ts
Original file line number Diff line number Diff line change
Expand Up @@ -49,10 +49,25 @@ type Need = 'completed' | 'first-event'
type Waiter = {
filter: RpcCallFilter
needs: Need
promise: Promise<unknown>
deliver: (state: CallState) => void
fail: (error: Error) => void
}

function createDeferred<Value>(): {
promise: Promise<Value>
resolve: (value: Value) => void
reject: (error: Error) => void
} {
let resolve: (value: Value) => void = () => {}
let reject: (error: Error) => void = () => {}
const promise = new Promise<Value>((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)) {
Expand Down Expand Up @@ -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<CallState> => {
const buffered = <Result>(
filter: RpcCallFilter,
needs: Need,
project: (state: CallState) => Result,
): Promise<Result> => {
const timeoutMs = filter.timeout ?? DEFAULT_TIMEOUT_MS
return new Promise<CallState>((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<CallState>()
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<CallState> => {
const settle = <Result>(
filter: RpcCallFilter,
needs: Need,
project: (state: CallState) => Result,
): Promise<Result> => {
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<RpcCallFilter, 'timeout'>, stamp: Stamp): number => {
Expand All @@ -290,18 +315,19 @@ 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,
dispose: () => {
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()
},
}
Expand Down
25 changes: 23 additions & 2 deletions packages/extension-testkit/src/settle-teardown.ts
Original file line number Diff line number Diff line change
@@ -1,5 +1,26 @@
export async function settleTeardown(steps: Array<() => Promise<void>>): Promise<void> {
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<void>
timeoutMs?: number
}

export async function settleTeardown(steps: readonly TeardownStep[]): Promise<void> {
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
}
58 changes: 58 additions & 0 deletions packages/extension-testkit/test/rpc-observer-dispose.it.test.ts
Original file line number Diff line number Diff line change
@@ -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()
}
})
40 changes: 40 additions & 0 deletions packages/extension-testkit/test/settle-teardown.test.ts
Original file line number Diff line number Diff line change
@@ -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<void>(() => {})
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'])
})
3 changes: 3 additions & 0 deletions pnpm-lock.yaml

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

Loading