import { afterAll, describe, expect, spyOn, test } from 'bun:test'
import process from 'node:process'
import { closeSharedBrowsers, findChrome, launch, SHARED_CHROME_LINGER_MS } from '../src/browser'
/*
* One Chrome per process, a browser context per launch. Against the real
* Chrome on this machine: isolation is the property a shared process could
* quietly lose, so it is checked through the browser itself, cookies and
* storage both, with two sessions open at once.
*/
const chrome = findChrome()
const server = Bun.serve({
hostname: '127.0.0.1',
port: 0,
fetch: request => new Response(`
${request.headers.get('cookie') ?? 'no cookie'}`, { headers: { 'content-type': 'text/html' } }),
})
const origin = `http://127.0.0.1:${server.port}`
afterAll(async () => {
await closeSharedBrowsers()
server.stop(true)
})
async function open(cdp: any, path = '/'): Promise {
await cdp.send('Page.navigate', { url: `${origin}${path}` })
for (let i = 0; i < 100 && await cdp.evaluate(`document.readyState`) !== 'complete'; i++) await Bun.sleep(50)
}
describe.skipIf(!chrome || process.platform === 'win32')('a shared Chrome', () => {
test('an in-flight expiry cannot retire a Chrome borrowed by the next session', async () => {
const set = globalThis.setTimeout.bind(globalThis)
const clear = globalThis.clearTimeout.bind(globalThis)
let expiry: { timer: ReturnType, run: () => void } | undefined
let deliverExpiry = false
// Model an expiry callback already delivered when the borrower cancels
// its timer. Its async retirement must recheck the new session lease.
const setting = spyOn(globalThis, 'setTimeout').mockImplementation((callback: any, delay?: number, ...args: any[]) => {
const timer = set(callback, delay, ...args)
if (delay === SHARED_CHROME_LINGER_MS) expiry = { timer, run: () => callback(...args) }
return timer
})
const clearing = spyOn(globalThis, 'clearTimeout').mockImplementation((timer) => {
if (deliverExpiry && expiry && timer === expiry.timer) {
deliverExpiry = false
expiry.run()
}
clear(timer)
})
let before: Awaited> | undefined
let after: Awaited> | undefined
try {
before = await launch()
expect(await before.cdp.evaluate('1 + 1')).toBe(2)
await before.close()
expect(expiry).toBeDefined()
deliverExpiry = true
after = await launch()
expect(after.port).toBe(before.port)
expect(await after.cdp.evaluate('1 + 1')).toBe(2)
}
finally {
deliverExpiry = false
clearing.mockRestore()
setting.mockRestore()
await before?.close()
await after?.close()
}
}, 60_000)
test('two sessions at once share the process and nothing else', async () => {
const first = await launch()
const startedSecond = Date.now()
const second = await launch()
const secondMs = Date.now() - startedSecond
try {
expect(second.port).toBe(first.port)
// A page on a running Chrome, not a cold start.
expect(secondMs).toBeLessThan(5_000)
await open(first.cdp)
await open(second.cdp)
await first.cdp.evaluate(`document.cookie = 'who=first; path=/'; localStorage.setItem('who', 'first'); true`)
expect(await second.cdp.evaluate(`document.cookie`)).toBe('')
expect(await second.cdp.evaluate(`localStorage.getItem('who')`)).toBeNull()
// And the server sees each context's own cookie jar.
await open(second.cdp, '/again')
expect(await second.cdp.evaluate(`document.body.textContent`)).toBe('no cookie')
await open(first.cdp, '/again')
expect(await first.cdp.evaluate(`document.body.textContent`)).toBe('who=first')
}
finally {
await Promise.all([first.close(), second.close()])
}
}, 60_000)
test('clearing cookies in one session leaves the other\'s alone', async () => {
const keep = await launch()
const clear = await launch()
try {
await open(keep.cdp)
await open(clear.cdp)
// A renderer cookie assignment queues a write on a different IPC pipe
// from DevTools deletion. Establish committed native jars before asking
// whether clearing one context preserves the other; no timing delay is
// a substitute for the cookie manager's acknowledged write.
expect((await keep.cdp.send('Network.setCookie', { name: 'kept', value: 'yes', url: origin, path: '/' })).success).toBe(true)
expect((await clear.cdp.send('Network.setCookie', { name: 'gone', value: 'yes', url: origin, path: '/' })).success).toBe(true)
expect((await keep.cdp.send('Network.getCookies', { urls: [origin] })).cookies.map((cookie: { name: string, value: string }) => `${cookie.name}=${cookie.value}`)).toEqual(['kept=yes'])
expect((await clear.cdp.send('Network.getCookies', { urls: [origin] })).cookies.map((cookie: { name: string, value: string }) => `${cookie.name}=${cookie.value}`)).toEqual(['gone=yes'])
await clear.cdp.send('Network.clearBrowserCookies')
const cleared = await clear.cdp.evaluate(`document.cookie`)
if (cleared !== '') {
// Preserve the failing observation before diagnostic commands yield.
// A stale renderer read and an uncleared native cookie jar are different bugs.
try {
console.error('shared-cookie-failure', JSON.stringify({
observed: cleared,
version: await clear.cdp.send('Browser.getVersion'),
clearedJar: await clear.cdp.send('Network.getCookies', { urls: [origin] }),
retainedJar: await keep.cdp.send('Network.getCookies', { urls: [origin] }),
subsequentDom: await clear.cdp.evaluate(`document.cookie`),
}))
}
catch (error) { console.error('shared-cookie-diagnostic-failure', String(error)) }
}
expect(cleared).toBe('')
expect(await keep.cdp.evaluate(`document.cookie`)).toBe('kept=yes')
}
finally {
await Promise.all([keep.close(), clear.close()])
}
}, 60_000)
test('a closed session leaves nothing for the next, and the Chrome stops after it lingers', async () => {
const before = await launch()
const port = before.port
await open(before.cdp)
await before.cdp.evaluate(`document.cookie = 'stale=yes; path=/'; localStorage.setItem('stale', 'yes'); true`)
await before.close()
const after = await launch()
try {
expect(after.port).toBe(port)
await open(after.cdp)
expect(await after.cdp.evaluate(`document.cookie`)).toBe('')
expect(await after.cdp.evaluate(`localStorage.getItem('stale')`)).toBeNull()
}
finally {
await after.close()
}
await Bun.sleep(SHARED_CHROME_LINGER_MS + 3_000)
const answered = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(1_000) }).then(() => true).catch(() => false)
expect(answered).toBe(false)
}, 60_000)
test('a launch that keeps a profile, or asks not to share, gets a Chrome of its own', async () => {
const shared = await launch()
const own = await launch({ shared: false })
try {
expect(own.port).not.toBe(shared.port)
}
finally {
await Promise.all([shared.close(), own.close()])
}
}, 60_000)
})