Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it, vi } from 'vitest'
import { EventEmitter } from 'node:events'
import { ORCA_RENDERER_UNLOAD_PREVENTED_EVENT } from '../shared/renderer-shutdown-events'
import {
ORCA_APP_RESTART_ABORTED_EVENT,
ORCA_APP_RESTART_STARTED_EVENT,
ORCA_UPDATER_QUIT_AND_INSTALL_STARTED_EVENT
} from '../shared/updater-renderer-events'
import {
prepareAndInvokeAppRestart,
prepareAndInvokeUpdaterInstall,
registerRendererRestartIpcRelays
} from './renderer-restart-wiring'
function restartIpc(eventTarget: EventTarget) {
const ipcRenderer = Object.assign(new EventEmitter(), {
invoke: vi.fn(async () => {}),
postMessage: vi.fn(),
send: vi.fn(),
sendSync: vi.fn(),
sendToHost: vi.fn()
})
const relay = { handleStatus: vi.fn(), abort: vi.fn() }
registerRendererRestartIpcRelays(ipcRenderer, eventTarget, relay)
return { ipcRenderer, ...relay }
}
describe('renderer restart wiring', () => {
it.each(['no-op', 'failure'] as const)(
'keeps a committed restart prepared after a later %s',
async (outcome) => {
const eventTarget = new EventTarget()
const { ipcRenderer } = restartIpc(eventTarget)
const aborted = vi.fn()
const started = vi.fn()
const checkpoint = vi.fn(async () => {})
eventTarget.addEventListener(ORCA_APP_RESTART_ABORTED_EVENT, aborted)
eventTarget.addEventListener(ORCA_APP_RESTART_STARTED_EVENT, started)
await prepareAndInvokeAppRestart(
eventTarget,
async () => {
ipcRenderer.emit('app:restart-committed')
return true
},
checkpoint,
Boolean
)
const subsequent = prepareAndInvokeAppRestart(
eventTarget,
async () => {
if (outcome === 'failure') {
throw new Error('already finalized')
}
return false
},
checkpoint,
Boolean
)
await (outcome === 'failure'
? expect(subsequent).rejects.toThrow('already finalized')
: expect(subsequent).resolves.toBe(false))
expect(checkpoint).toHaveBeenCalledOnce()
expect(started).toHaveBeenCalledOnce()
expect(aborted).not.toHaveBeenCalled()
}
)
it('refuses overlapping preparation without abandoning the accepted restart', async () => {
const eventTarget = new EventTarget()
const aborted = vi.fn()
eventTarget.addEventListener(ORCA_APP_RESTART_ABORTED_EVENT, aborted)
const checkpoint = Promise.withResolvers<void>()
const invoke = vi.fn(async () => true)
const first = prepareAndInvokeAppRestart(eventTarget, invoke, () => checkpoint.promise)
const refused = vi.fn(async () => false)
await expect(
prepareAndInvokeAppRestart(eventTarget, refused, async () => {}, Boolean)
).rejects.toThrow('already in progress')
expect(refused).not.toHaveBeenCalled()
expect(aborted).not.toHaveBeenCalled()
checkpoint.resolve()
await expect(first).resolves.toBe(true)
expect(invoke).toHaveBeenCalledOnce()
})
it('retains late commitment across an unrelated unload veto', async () => {
const eventTarget = new EventTarget()
const abandoned = vi.fn()
eventTarget.addEventListener(ORCA_APP_RESTART_ABORTED_EVENT, abandoned)
eventTarget.addEventListener(ORCA_RENDERER_UNLOAD_PREVENTED_EVENT, abandoned)
const { ipcRenderer } = restartIpc(eventTarget)
const checkpoint = vi.fn(async () => {})
await prepareAndInvokeAppRestart(eventTarget, async () => true, checkpoint, Boolean)
ipcRenderer.emit('app:restart-committed')
await prepareAndInvokeAppRestart(eventTarget, async () => false, checkpoint, Boolean)
expect(checkpoint).toHaveBeenCalledOnce()
ipcRenderer.emit('window:unload-prevented')
await prepareAndInvokeAppRestart(eventTarget, async () => true, checkpoint, Boolean)
expect(checkpoint).toHaveBeenCalledOnce()
expect(abandoned).not.toHaveBeenCalled()
})
it('releases preparation ownership and its listener after checkpoint failure', async () => {
const eventTarget = new EventTarget()
const add = vi.spyOn(eventTarget, 'addEventListener')
const remove = vi.spyOn(eventTarget, 'removeEventListener')
await expect(
prepareAndInvokeAppRestart(
eventTarget,
async () => {},
async () => {
throw new Error('checkpoint failed')
}
)
).rejects.toThrow('checkpoint failed')
await prepareAndInvokeAppRestart(
eventTarget,
async () => {},
async () => {}
)
expect(add.mock.calls).toHaveLength(2)
expect(remove.mock.calls).toEqual(add.mock.calls)
})
it('relays updater status, aborted installs, and prevented unload events', () => {
const eventTarget = new EventTarget()
const unloadPrevented = vi.fn()
const restartAborted = vi.fn()
const { ipcRenderer, handleStatus, abort } = restartIpc(eventTarget)
eventTarget.addEventListener(ORCA_RENDERER_UNLOAD_PREVENTED_EVENT, unloadPrevented)
eventTarget.addEventListener(ORCA_APP_RESTART_ABORTED_EVENT, restartAborted)
ipcRenderer.emit('updater:status', {}, { state: 'error', message: 'install failed' })
// Main can abandon an install without emitting a status.
ipcRenderer.emit('updater:quitAndInstallAborted')
ipcRenderer.emit('window:unload-prevented')
expect(handleStatus).toHaveBeenCalledWith({ state: 'error', message: 'install failed' })
expect(abort).toHaveBeenCalledTimes(1)
expect(unloadPrevented).toHaveBeenCalledTimes(1)
expect(restartAborted).toHaveBeenCalledTimes(1)
})
it('marks preparation before invoking main and aborts on IPC failure', async () => {
const eventTarget = new EventTarget()
const calls: string[] = []
eventTarget.addEventListener(ORCA_UPDATER_QUIT_AND_INSTALL_STARTED_EVENT, () => {
calls.push('prepared')
})
const relay = {
markPrepared: () => calls.push('marked'),
abort: () => calls.push('aborted')
}
const invoke = vi.fn(async () => {
calls.push('invoked')
throw new Error('IPC failed')
})
await expect(
prepareAndInvokeUpdaterInstall(eventTarget, relay, invoke, async () => {
calls.push('checkpoint-flushed')
})
).rejects.toThrow('IPC failed')
expect(calls).toEqual(['prepared', 'checkpoint-flushed', 'marked', 'invoked', 'aborted'])
})
it('never installs the update when the shutdown checkpoint fails to persist', async () => {
const eventTarget = new EventTarget()
const invoke = vi.fn(() => Promise.resolve())
const relay = { markPrepared: vi.fn(), abort: vi.fn() }
await expect(
prepareAndInvokeUpdaterInstall(eventTarget, relay, invoke, () =>
Promise.reject(new Error('Failed to persist renderer state before unload.'))
)
).rejects.toThrow('Failed to persist renderer state before unload.')
expect(invoke).not.toHaveBeenCalled()
expect(relay.markPrepared).not.toHaveBeenCalled()
})
})