A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.
import assert from 'node:assert/strict'
import { EventEmitter } from 'node:events'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { test } from 'node:test'
import { WebSocket } from 'ws'
import { BotViews, isBotId } from '../src/bot-views.mjs'
// Windows makes a junction to a folder without special rights; elsewhere it is a plain
// symbolic link to the folder.
const folderLink = process.platform === 'win32' ? 'junction' : 'dir'
function fixture({ statePath } = {}) {
const changes = []
const handlers = new Map()
const views = []
class WebContents extends EventEmitter {
constructor() {
super()
this.url = 'about:blank'
this.loadedUrls = []
this.debugger = Object.assign(new EventEmitter(), {
attach() {},
async sendCommand(method) {
if (method === 'Page.getFrameTree') return { frameTree: { frame: { id: 'frame-a', url: 'https://example.com/' } } }
return { method }
},
})
}
getURL() { return this.url }
getTitle() { return this.url }
isLoading() { return false }
canGoBack() { return false }
canGoForward() { return false }
isDestroyed() { return false }
async loadURL(url) { this.url = url; this.loadedUrls.push(url) }
async executeJavaScript(script) { return script }
setWindowOpenHandler(handler) { this.windowOpenHandler = handler }
close() {}
focus() {}
}
class WebContentsView {
constructor(options) {
this.options = options
this.webContents = new WebContents()
views.push(this)
}
setBounds(bounds) { this.bounds = bounds }
setVisible(visible) { this.visible = visible }
}
const guests = {
storageFor(key) { return { partition: `persist:${key}` } },
setDownloadHandler(key, handler) { handlers.set(key, handler) },
}
const added = []
let window = { contentView: { addChildView(view) { added.push(view) }, removeChildView() {} } }
const manager = new BotViews({ window: () => window, WebContentsView, guests, origin: () => 'http://127.0.0.1:43117', statePath, onChange: change => changes.push(change) })
return { manager, handlers, views, changes, added, setWindow: (next) => { window = next } }
}
test('Bot endpoint identifiers follow DSH session.create IDs', () => {
assert.equal(isBotId('session-7e90ddf9-38a7-4c6c-b37a-1c445f771234'), true)
assert.equal(isBotId('7e90ddf9-38a7-4c6c-b37a-1c445f771234'), false)
assert.equal(isBotId('session-1'), false)
})
test('Bot endpoints accept only up to four absolute download roots', async t => {
const { manager } = fixture()
t.after(() => manager.dispose())
await assert.rejects(() => manager.endpoint('a', { downloadRoots: ['relative'] }), /Invalid browser download roots/u)
await assert.rejects(() => manager.endpoint('a', { downloadRoots: new Array(1) }), /Invalid browser download roots/u)
await assert.rejects(() => manager.endpoint('a', { downloadRoots: ['/a', '/b', '/c', '/d', '/e'] }), /Invalid browser download roots/u)
assert.match(await manager.endpoint('a', { downloadRoots: ['/a', '/b', '/c', '/d'] }), /^ws:\/\//u)
})
function openSocket(url, options) {
return new Promise((resolve, reject) => {
const socket = new WebSocket(url, options)
socket.once('open', () => resolve(socket))
socket.once('error', reject)
})
}
function closed(socket) {
return new Promise(resolve => {
socket.on('error', () => {})
socket.once('close', resolve)
})
}
function request(socket, id, method, params = {}, sessionId) {
return new Promise((resolve, reject) => {
const timer = setTimeout(() => reject(new Error(`Timed out waiting for ${method}`)), 1000)
const onMessage = raw => {
const message = JSON.parse(raw.toString())
if (message.id !== id) return
clearTimeout(timer)
socket.off('message', onMessage)
resolve(message)
}
socket.on('message', onMessage)
socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }))
})
}
test('CDP endpoint creates and loads an initial view for a Bot with no tabs', async t => {
const { manager, views } = fixture()
t.after(() => manager.dispose())
const endpoint = await manager.endpoint('a')
assert.deepEqual(views[0].webContents.loadedUrls, ['about:blank'])
const socket = await openSocket(endpoint)
t.after(() => socket.close())
const targets = await request(socket, 1, 'Target.getTargets')
assert.equal(targets.result.targetInfos.length, 1)
assert.equal(targets.result.targetInfos[0].url, 'about:blank')
const info = await request(socket, 2, 'Target.getTargetInfo')
assert.equal(info.result.targetInfo.targetId, targets.result.targetInfos[0].targetId)
})
test('CDP relay limits targets and created tabs to the token Bot', async t => {
const { manager, views } = fixture()
t.after(() => manager.dispose())
manager.create('a')
manager.create('b')
const [a, b] = await Promise.all([manager.endpoint('a'), manager.endpoint('b')])
const socketA = await openSocket(a)
const socketB = await openSocket(b)
t.after(() => { socketA.close(); socketB.close() })
const targetsA = await request(socketA, 1, 'Target.getTargets')
const targetsB = await request(socketB, 2, 'Target.getTargets')
assert.equal(targetsA.result.targetInfos.length, 1)
assert.equal(targetsA.result.targetInfos[0].browserContextId, 'bot:a')
assert.equal(targetsB.result.targetInfos.length, 1)
assert.equal(targetsB.result.targetInfos[0].browserContextId, 'bot:b')
const rootInfo = await request(socketA, 3, 'Target.getTargetInfo')
assert.equal(rootInfo.result.targetInfo.targetId, targetsA.result.targetInfos[0].targetId)
const foreignInfo = await request(socketA, 4, 'Target.getTargetInfo', { targetId: targetsB.result.targetInfos[0].targetId })
assert.equal(foreignInfo.error.message, 'Browser tab does not belong to this Bot')
const attached = await request(socketA, 5, 'Target.attachToTarget', { targetId: targetsA.result.targetInfos[0].targetId, flatten: true })
const sessionId = attached.result.sessionId
const pageEnabled = await request(socketA, 6, 'Page.enable', {}, sessionId)
assert.equal(pageEnabled.sessionId, sessionId)
assert.deepEqual(pageEnabled.result, { method: 'Page.enable' })
const frameTree = await request(socketA, 7, 'Page.getFrameTree', {}, sessionId)
assert.equal(frameTree.result.frameTree.frame.id, targetsA.result.targetInfos[0].targetId)
const created = await request(socketA, 8, 'Target.createTarget', { url: 'about:blank' })
assert.equal(created.result.targetId, manager.sync('a')[1].tabId)
assert.equal(manager.sync('a').length, 2)
assert.equal(manager.sync('b').length, 1)
})
test('CDP relay rejects invalid paths and Origin headers', async t => {
const { manager } = fixture()
t.after(() => manager.dispose())
const endpoint = await manager.endpoint('a')
const valid = await openSocket(endpoint)
t.after(() => valid.close())
const originSocket = new WebSocket(endpoint, { headers: { Origin: 'https://example.com' } })
await closed(originSocket)
const badPath = new WebSocket(endpoint.replace(/\/devtools\/browser\/[^/]+$/u, '/invalid'))
await closed(badPath)
})
test('CDP download behavior saves to the Bot path and emits download events', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const rootPath = mkdtempSync(join(tmpdir(), 'bot-views-download-root-'))
const downloadPath = join(rootPath, 'downloads')
t.after(() => rmSync(rootPath, { recursive: true, force: true }))
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a', { downloadRoots: [rootPath] }))
t.after(() => socket.close())
const discovered = await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
assert.ok(discovered.result.sessionId)
const sessionId = discovered.result.sessionId
await request(socket, 2, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath })
const events = []
let resolveEvents
const eventsReady = new Promise(resolve => { resolveEvents = resolve })
socket.on('message', raw => {
const message = JSON.parse(raw.toString())
if (message.method?.startsWith('Browser.download')) {
events.push(message)
if (events.length === 3) resolveEvents()
}
})
const saved = []
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { saved.push(path) },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
getReceivedBytes() { return 3 },
getTotalBytes() { return 3 },
})
const event = { preventDefault() { throw new Error('download was unexpectedly prevented') } }
handlers.get('bot:a')(event, item, views[0].webContents)
item.emit('updated', {}, 'progressing')
item.emit('done', {}, 'completed')
await Promise.race([eventsReady, new Promise((_, reject) => setTimeout(() => reject(new Error('download events were not relayed')), 1000))])
assert.equal(saved.length, 1)
assert.match(saved[0], new RegExp(`^${realpathSync(downloadPath).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[/\\\\]`, 'u'))
assert.equal(events[0].params.suggestedFilename, 'report.pdf')
assert.equal(events.some(message => message.method === 'Browser.downloadProgress' && message.params.state === 'completed'), true)
assert.equal(sessionId.length > 0, true)
})
test('CDP accepts a download root created after endpoint setup', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const parentPath = mkdtempSync(join(tmpdir(), 'bot-views-download-late-root-'))
const rootPath = join(parentPath, 'downloads-root')
t.after(() => rmSync(parentPath, { recursive: true, force: true }))
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a', { downloadRoots: [rootPath] }))
t.after(() => socket.close())
assert.equal(existsSync(rootPath), false)
await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
const downloadPath = join(rootPath, 'downloads')
const response = await request(socket, 2, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath })
assert.deepEqual(response.result, {})
let savePath
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { savePath = path; writeFileSync(path, 'download') },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
let prevented = false
handlers.get('bot:a')({ preventDefault() { prevented = true } }, item, views[0].webContents)
assert.equal(prevented, false)
assert.equal(existsSync(savePath), true)
assert.equal(readFileSync(savePath, 'utf8'), 'download')
})
test('download roots are isolated per Bot', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const rootA = mkdtempSync(join(tmpdir(), 'bot-views-download-a-'))
const rootB = mkdtempSync(join(tmpdir(), 'bot-views-download-b-'))
t.after(() => {
rmSync(rootA, { recursive: true, force: true })
rmSync(rootB, { recursive: true, force: true })
})
const entryA = manager.create('a')
const entryB = manager.create('b')
const [endpointA, endpointB] = await Promise.all([
manager.endpoint('a', { downloadRoots: [rootA] }),
manager.endpoint('b', { downloadRoots: [rootB] }),
])
const socketA = await openSocket(endpointA)
const socketB = await openSocket(endpointB)
t.after(() => { socketA.close(); socketB.close() })
await request(socketA, 1, 'Target.attachToTarget', { targetId: entryA.tabId, flatten: true })
await request(socketB, 2, 'Target.attachToTarget', { targetId: entryB.tabId, flatten: true })
await request(socketA, 3, 'Browser.setDownloadBehavior', { behavior: 'allow', downloadPath: rootA })
await request(socketB, 4, 'Browser.setDownloadBehavior', { behavior: 'allow', downloadPath: rootA })
let savedByA
const accepted = Object.assign(new EventEmitter(), {
setSavePath(path) { savedByA = path },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
handlers.get('bot:a')({ preventDefault() { throw new Error('Bot A download was refused') } }, accepted, views[0].webContents)
assert.match(savedByA, new RegExp(`^${realpathSync(rootA).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[/\\\\]`, 'u'))
let preventedForB = false
const refused = Object.assign(new EventEmitter(), {
setSavePath() { throw new Error('Bot B must not use Bot A download root') },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
handlers.get('bot:b')({ preventDefault() { preventedForB = true } }, refused, views[1].webContents)
assert.equal(preventedForB, true)
})
test('cancelling a relay download removes its save path', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const downloadPath = mkdtempSync(join(tmpdir(), 'playwright-artifacts-bot-views-cancel-'))
t.after(() => rmSync(downloadPath, { recursive: true, force: true }))
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a'))
t.after(() => socket.close())
await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
await request(socket, 2, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath })
const events = []
socket.on('message', raw => {
const message = JSON.parse(raw.toString())
if (message.method?.startsWith('Browser.download')) events.push(message)
})
let savePath
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { savePath = path; writeFileSync(path, 'partial') },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
getReceivedBytes() { return 1 },
getTotalBytes() { return 2 },
async cancel() { this.emit('done', {}, 'cancelled') },
})
handlers.get('bot:a')({ preventDefault() {} }, item, views[0].webContents)
let willBegin
for (let tries = 0; tries < 100 && !willBegin; tries++) {
await new Promise(resolve => setTimeout(resolve, 10))
willBegin = events.find(message => message.method === 'Browser.downloadWillBegin')
}
const guid = willBegin.params.guid
await request(socket, 3, 'Browser.cancelDownload', { guid })
for (let tries = 0; tries < 100 && existsSync(savePath); tries++) await new Promise(resolve => setTimeout(resolve, 10))
assert.equal(existsSync(savePath), false)
})
test('CDP rejects outside, traversal, and symlink download paths and cancels downloads', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const rootPath = mkdtempSync(join(tmpdir(), 'bot-views-download-root-'))
const outsidePath = mkdtempSync(join(tmpdir(), 'bot-views-download-outside-'))
symlinkSync(outsidePath, join(rootPath, 'outside-link'), folderLink)
t.after(() => {
rmSync(rootPath, { recursive: true, force: true })
rmSync(outsidePath, { recursive: true, force: true })
})
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a', { downloadRoots: [rootPath] }))
t.after(() => socket.close())
await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
const refusedPaths = [
'/etc/x',
join(rootPath, '..', 'bot-views-download-escape'),
join(rootPath, 'outside-link'),
]
let id = 2
for (const downloadPath of refusedPaths) {
await request(socket, id++, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath: rootPath })
const response = await request(socket, id++, 'Browser.setDownloadBehavior', { behavior: 'allow', downloadPath })
assert.deepEqual(response.result, {})
let prevented = false
let savePath
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { savePath = path },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
handlers.get('bot:a')({ preventDefault() { prevented = true } }, item, views[0].webContents)
assert.equal(prevented, true)
assert.equal(savePath, undefined)
}
await request(socket, id++, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath: rootPath })
await request(socket, id, 'Browser.setDownloadBehavior', { behavior: 'deny', downloadPath: rootPath })
let denied = false
const item = Object.assign(new EventEmitter(), {
setSavePath() { throw new Error('denied downloads must not get a save path') },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
handlers.get('bot:a')({ preventDefault() { denied = true } }, item, views[0].webContents)
assert.equal(denied, true)
})
test('CDP accepts a direct Playwright artifacts directory under os.tmpdir()', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const downloadPath = mkdtempSync(join(tmpdir(), 'playwright-artifacts-bot-views-'))
t.after(() => rmSync(downloadPath, { recursive: true, force: true }))
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a'))
t.after(() => socket.close())
await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
const response = await request(socket, 2, 'Browser.setDownloadBehavior', { behavior: 'allowAndName', downloadPath })
assert.deepEqual(response.result, {})
let savePath
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { savePath = path },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
let prevented = false
handlers.get('bot:a')({ preventDefault() { prevented = true } }, item, views[0].webContents)
assert.equal(prevented, false)
assert.match(savePath, new RegExp(`^${realpathSync(downloadPath).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[/\\\\]`, 'u'))
})
test('a relay download is cancelled if its accepted directory is swapped for an outside symlink', async t => {
const { manager, handlers, views } = fixture()
t.after(() => manager.dispose())
const rootPath = mkdtempSync(join(tmpdir(), 'bot-views-download-symlink-swap-'))
const downloadPath = join(rootPath, 'downloads')
const outsidePath = mkdtempSync(join(tmpdir(), 'bot-views-download-outside-'))
t.after(() => rmSync(outsidePath, { recursive: true, force: true }))
t.after(() => rmSync(rootPath, { recursive: true, force: true }))
const entry = manager.create('a')
const socket = await openSocket(await manager.endpoint('a', { downloadRoots: [rootPath] }))
t.after(() => socket.close())
await request(socket, 1, 'Target.attachToTarget', { targetId: entry.tabId, flatten: true })
const accepted = await request(socket, 2, 'Browser.setDownloadBehavior', {
behavior: 'allowAndName',
downloadPath,
})
assert.deepEqual(accepted.result, {})
rmSync(downloadPath, { recursive: true, force: true })
symlinkSync(outsidePath, downloadPath, folderLink)
let prevented = false
const item = Object.assign(new EventEmitter(), {
setSavePath(path) { writeFileSync(path, 'outside') },
getURL() { return 'https://example.com/file' },
getFilename() { return 'report.pdf' },
})
handlers.get('bot:a')({ preventDefault() { prevented = true } }, item, views[0].webContents)
assert.equal(prevented, true)
assert.deepEqual(readdirSync(outsidePath), [])
})
test('user hold closes relay sockets, rejects endpoints, and allows a new endpoint after give-back', async t => {
const { manager } = fixture()
t.after(() => manager.dispose())
const endpoint = await manager.endpoint('a')
const socket = await openSocket(endpoint)
const closedPromise = closed(socket)
await manager.hold('a', true)
await closedPromise
await assert.rejects(() => manager.endpoint('a'), /The user has taken over this browser/u)
await manager.hold('a', false)
const resumed = await manager.endpoint('a')
const resumedSocket = await openSocket(resumed)
t.after(() => resumedSocket.close())
assert.equal((await request(resumedSocket, 3, 'Target.getTargets')).result.targetInfos.length, 1)
})
test('navigation guard rejects the app origin and popup tabs work before relay attachment', async t => {
const { manager, views } = fixture()
t.after(() => manager.dispose())
const entry = manager.create('a')
let prevented = false
entry.view.webContents.emit('will-frame-navigate', { url: 'http://127.0.0.1:43117/settings', isMainFrame: true, preventDefault() { prevented = true } })
assert.equal(prevented, true)
const popup = entry.view.webContents.windowOpenHandler({ url: 'http://127.0.0.1:43118/popup', postBody: undefined })
assert.deepEqual(popup, { action: 'deny' })
assert.equal(views.length, 2)
assert.equal(manager.sync('a')[1].url, 'http://127.0.0.1:43118/popup')
})
test('saved active tabs restore their tab id and URL', async t => {
const statePath = join(mkdtempSync(join(tmpdir(), 'bot-views-state-')), 'bot-views.json')
t.after(() => rmSync(statePath, { force: true }))
const first = fixture({ statePath })
const entry = first.manager.create('a', { tabId: 'saved-tab', url: 'http://127.0.0.1:43118/form' })
assert.equal(first.manager.create('a', { tabId: 'saved-tab' }), entry)
first.manager.dispose()
const second = fixture({ statePath })
t.after(() => second.manager.dispose())
const endpoint = await second.manager.endpoint('a')
assert.equal(second.manager.sync('a')[0].tabId, entry.tabId)
assert.equal(second.manager.sync('a')[0].url, 'http://127.0.0.1:43118/form')
const socket = await openSocket(endpoint)
t.after(() => socket.close())
})
test('the views stay hidden while the app’s card is up, and the shown ones come back after it', t => {
const { manager, views } = fixture()
t.after(() => manager.dispose())
manager.create('a', { tabId: 'A' })
manager.create('a', { tabId: 'B' })
const rect = { left: 0, top: 0, width: 400, height: 300 }
manager.place('A', rect, true)
manager.cover(true)
assert.deepEqual(views.map(view => view.visible), [false, false])
// The page places its view again while the card is up: it still waits.
manager.place('B', rect, true)
assert.equal(views[1].visible, false)
manager.cover(false)
assert.deepEqual(views.map(view => view.visible), [true, true])
manager.place('A', rect, false)
manager.cover(true)
manager.cover(false)
assert.deepEqual(views.map(view => view.visible), [false, true])
})
test('closing the active saved tab preserves the replacement after another page updates', async t => {
const directory = mkdtempSync(join(tmpdir(), 'bot-views-active-state-'))
const statePath = join(directory, 'bot-views.json')
t.after(() => rmSync(directory, { recursive: true, force: true }))
const first = fixture({ statePath })
first.manager.create('a', { tabId: 'A', url: 'http://127.0.0.1:43118/a' })
first.manager.create('a', { tabId: 'B', url: 'http://127.0.0.1:43118/b' })
first.manager.create('a', { tabId: 'C', url: 'http://127.0.0.1:43118/c' })
first.manager.place('B', { left: 0, top: 0, width: 400, height: 300 }, true)
await first.manager.close('a', 'B')
first.views[0].webContents.url = 'http://127.0.0.1:43118/a-updated'
first.views[0].webContents.emit('did-navigate')
first.manager.dispose()
const second = fixture({ statePath })
t.after(() => second.manager.dispose())
await second.manager.endpoint('a')
assert.deepEqual(second.manager.sync('a').map(({ tabId, url }) => ({ tabId, url })), [
{ tabId: 'C', url: 'http://127.0.0.1:43118/c' },
])
})
test('saved file and app-origin URLs restore as blank with their tab ids', async t => {
const directory = mkdtempSync(join(tmpdir(), 'bot-views-unsafe-state-'))
const statePath = join(directory, 'bot-views.json')
t.after(() => rmSync(directory, { recursive: true, force: true }))
writeFileSync(statePath, JSON.stringify({ version: 1, bots: {
file: { tabs: [{ tabId: 'file-tab', url: 'file:///etc/passwd', title: 'passwd' }], active: 'file-tab' },
app: { tabs: [{ tabId: 'app-tab', url: 'http://127.0.0.1:43117/settings', title: 'Settings' }], active: 'app-tab' },
} }))
const { manager } = fixture({ statePath })
t.after(() => manager.dispose())
const stored = JSON.parse(readFileSync(statePath, 'utf8'))
assert.deepEqual(stored.bots.file.tabs, [{ tabId: 'file-tab', url: 'about:blank', title: '' }])
assert.deepEqual(stored.bots.app.tabs, [{ tabId: 'app-tab', url: 'about:blank', title: '' }])
for (const [botId, tabId] of [['file', 'file-tab'], ['app', 'app-tab']]) {
await manager.endpoint(botId)
assert.deepEqual(manager.sync(botId).map(({ tabId: actualId, url }) => ({ tabId: actualId, url })), [
{ tabId, url: 'about:blank' },
])
}
})
test('load errors remain published until a real main-frame navigation starts', async t => {
const { manager, views, changes } = fixture()
t.after(() => manager.dispose())
const entry = manager.create('a')
const contents = views[0].webContents
contents.emit('did-fail-load', {}, -105, 'offline', contents.getURL(), true)
contents.emit('did-stop-loading')
assert.equal(changes.at(-1).error, 'offline')
contents.emit('did-start-navigation', { isMainFrame: true, isSameDocument: false })
assert.equal(changes.at(-1).error, null)
assert.ok(entry)
})
test('a tab whose window is gone joins the next window', async t => {
const { manager, views, added } = fixture()
t.after(() => manager.dispose())
manager.create('a')
assert.equal(added.length, 1, 'the view belongs to the window')
// The window is gone, but its view is still alive.
manager.release()
const next = { contentView: { addChildView(view) { added.push(view) } } }
manager.attach(next)
assert.equal(added.length, 2, 'the view joins the next window')
assert.equal(added[1], views[0], 'it is the same view')
})
test('a view that went with its window is dropped', async t => {
const { manager, views, added } = fixture()
t.after(() => manager.dispose())
manager.create('a')
views[0].webContents.isDestroyed = () => true
manager.release()
const next = { contentView: { addChildView(view) { added.push(view) } } }
manager.attach(next)
assert.equal(added.length, 1, 'the dead view is not attached again')
assert.deepEqual(manager.sync('a'), [], 'the tab is gone')
})
test('a view that is built without a window waits for one', async t => {
const { manager, views, added, setWindow } = fixture()
t.after(() => manager.dispose())
setWindow(undefined)
manager.create('a')
assert.equal(added.length, 0, 'there is no window to hold it')
const next = { contentView: { addChildView(view) { added.push(view) } } }
manager.attach(next)
assert.equal(added.length, 1, 'the view joins the window that comes')
assert.equal(added[0], views[0], 'it is the same view')
})