test: remove low-value launch removal and persistence examples (#42318)

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
This commit is contained in:
OrcaWin
2026-11-13 23:14:08 -08:00
committed by GitHub
co-authored by OrcaWin
parent 3e0a9585a6
commit 7f736d7c4a
7 changed files with 8 additions and 526 deletions
@@ -32,7 +32,7 @@ beforeEach(() => {
afterEach(() => rmSync(paths.root, { recursive: true, force: true }))
describe('managed Codex launch configuration', () => {
it.each(['prepared', 'reused', 'hooks failed'] as const)(
it.each(['prepared', 'hooks failed'] as const)(
'provides mirrored sandbox settings before the grant when preparation is %s',
async (outcome) => {
const systemHomePath = join(paths.root, '.codex')
@@ -41,11 +41,6 @@ describe('managed Codex launch configuration', () => {
mkdirSync(runtimeHomePath)
const expectedConfig = '[windows]\nsandbox = "elevated"\n'
writeFileSync(join(systemHomePath, 'config.toml'), expectedConfig)
const runtimeConfig = join(runtimeHomePath, 'config.toml')
if (outcome === 'reused') {
writeFileSync(runtimeConfig, expectedConfig)
writeFileSync(`${runtimeConfig}.bak`, 'recoverable settings\n')
}
const runtimeHome: Pick<CodexRuntimeHomeService, 'prepareForCodexLaunchAsync'> = {
prepareForCodexLaunchAsync: async (_target, _env, options) => {
const sync = (): boolean =>
@@ -71,9 +66,6 @@ describe('managed Codex launch configuration', () => {
let grantedConfig: string | undefined
grantRead.mockImplementation(async (home: string) => {
grantedConfig = readFileSync(join(home, 'config.toml'), 'utf8')
if (outcome === 'reused') {
expect(readFileSync(`${runtimeConfig}.bak`, 'utf8')).toBe('recoverable settings\n')
}
})
const prepare = createCodexRuntimeHomeLaunchPreparation({
getRuntimeHome: () => runtimeHome,
@@ -191,20 +191,6 @@ describe('completed Codex launch preparation', () => {
expect(readFileSync(`${runtime}.bak`, 'utf8')).toBe('model = "recoverable"\n')
})
it('reports a newly pending Codex answer after an asynchronous refresh snapshot', async () => {
const { service, home } = seed()
await settle(service, home)
for (let index = 0; index < 3; index++) {
await service.refreshRuntimeUserHooksForLaunchPrep(home)
}
controls.afterSnapshot = () => {
controls.answer = null
}
expect((await service.refreshRuntimeUserHooksForLaunchPrep(home)).detail).toContain(
'Orca has not asked Codex yet'
)
})
it('honors Off before effects when it changes during the asynchronous snapshot', async () => {
const { service, home } = seed()
await settle(service, home)
@@ -248,15 +234,6 @@ describe('completed Codex launch preparation', () => {
expect(readFileSync(runtime, 'utf8')).toContain('model = "A"')
})
it('preserves the recovery backup when launch inputs are unchanged', async () => {
const { service, home, runtime } = seed()
await settle(service, home)
const backup = `${runtime}.bak`
writeFileSync(backup, 'model = "recoverable"\n')
await service.installForLaunchPrep(home, true, () => true)
expect(readFileSync(backup, 'utf8')).toBe('model = "recoverable"\n')
})
it.each(['temporarily absent', 'temporarily locked'] as const)(
'retries legacy cleanup after its profile was %s',
async (failure) => {
@@ -35,7 +35,7 @@ vi.mock('../../../workspaces/removal/worktree-removal-safety', async (original)
}))
vi.mock('./worktree-removal-preflight', () => ({ assertWorktreeCleanForRemoval: clean }))
import { authorizeWindowsCheckout, removeWindowsCheckout } from './windows-worktree-removal'
import { removeWindowsCheckout } from './windows-worktree-removal'
import { _resetWorktreeScanCacheForTests } from '../catalog/worktree-scan-cache'
const originalPlatform = process.platform
@@ -71,65 +71,6 @@ afterEach(() => {
_resetWorktreeScanCacheForTests()
})
it.each([10, 100])(
'shares one native eligibility graph for %i equivalent overlapping authorizations',
async (population) => {
const reading = Promise.withResolvers<GitWorktreeInfo[]>()
graph.mockReturnValueOnce(reading.promise)
const signal = new AbortController().signal
const checks = Array.from({ length: population }, () =>
authorizeWindowsCheckout('C:/repo', root, true, { checkoutDeleteSignal: signal })
)
expect(graph).toHaveBeenCalledOnce()
reading.resolve([row])
expect(await Promise.all(checks)).toEqual(Array.from({ length: population }, () => true))
expect(graph.mock.calls[0]?.[1].signal).toBe(signal)
}
)
it('refuses nested preparation registrations and strict inventory errors', async () => {
graph.mockResolvedValueOnce([row, { ...row, path: `${root}/.orca-worktree-preparation` }])
await expect(authorizeWindowsCheckout('C:/repo', root, true, {})).rejects.toThrow(
'another registered worktree'
)
const failure = new Error('inventory failed')
graph.mockRejectedValueOnce(failure)
await expect(authorizeWindowsCheckout('C:/repo', root, true, {})).rejects.toBe(failure)
expect(removeChild).not.toHaveBeenCalled()
})
it.each(['status', 'recursive'] as const)(
'cancels the later %s read with the original checkout stop reason',
async (stage) => {
const controller = new AbortController()
const held = Promise.withResolvers<void>()
const entered = Promise.withResolvers<void>()
if (stage === 'status') {
clean.mockImplementation(async (_root, _force, options) => {
entered.resolve()
await waitForPromiseWithSignal(held.promise, options.signal)
})
} else {
graph
.mockImplementationOnce(async () => [row])
.mockImplementationOnce(async (_repo, options) => {
entered.resolve()
await waitForPromiseWithSignal(held.promise, options.signal)
return [row]
})
}
const reason = new Error('owner stopped')
const pending = authorizeWindowsCheckout('C:/repo', root, false, {
checkoutDeleteSignal: controller.signal
})
const rejected = expect(pending).rejects.toBe(reason)
await entered.promise
controller.abort(reason)
await rejected
expect(unlink).not.toHaveBeenCalled()
}
)
it('joins held children before cancelling the real repeated delete-time authorization', async () => {
const controller = new AbortController()
const sibling = Promise.withResolvers<void>()
@@ -169,23 +110,3 @@ it('joins held children before cancelling the real repeated delete-time authoriz
expect(unlink).not.toHaveBeenCalled()
expect(rmdir).not.toHaveBeenCalled()
})
it('honors distinct read and checkout signals without replacing either caller option', async () => {
const read = new AbortController()
const checkout = new AbortController()
const entered = Promise.withResolvers<void>()
graph.mockImplementation(async (_repo, options) => {
entered.resolve()
return waitForPromiseWithSignal(new Promise<GitWorktreeInfo[]>(() => {}), options.signal)
})
const options = { signal: read.signal, checkoutDeleteSignal: checkout.signal }
const reason = new Error('checkout closing')
const rejected = expect(authorizeWindowsCheckout('C:/repo', root, true, options)).rejects.toBe(
reason
)
await entered.promise
checkout.abort(reason)
await rejected
expect(options.signal).toBe(read.signal)
expect(options.checkoutDeleteSignal).toBe(checkout.signal)
})
@@ -1,12 +1,3 @@
import { GitAdmissionScheduler } from '../../../../shared/git/admission/git-admission-scheduler'
import {
acquireGitAdmission,
_resetGitAdmissionForTests
} from '../../../git/command-runner/admission/git-subprocess-admission'
import { worktreeRemovalLifetime } from '../../../workspaces/removal/worktree-removal-lifetime'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, expect, it, vi } from 'vitest'
import type { Repo } from '../../../../shared/repo-types'
import type { GitWorktreeInfo } from '../../../../shared/worktree/types'
@@ -43,30 +34,13 @@ import {
_resetWorktreeScanCacheForTests,
bumpWorktreeScanGeneration
} from '../../../git/worktrees/catalog/worktree-scan-cache'
import {
_resetPendingWorktreeRemovalsForTests,
_settlePendingWorktreeRemovalsForTests,
resumeInterruptedWorktreeRemovals
} from '../../../workspaces/removal/worktree-background-removal'
import { prepareWorktreeRemovalsForStore } from '../../../workspaces/removal/worktree-removal-records-load'
import {
writeWorktreeRemovalRecords,
readWorktreeRemovalRecords
} from '../../../workspaces/removal/worktree-removal-records'
import { _resetPendingWorktreeRemovalsForTests } from '../../../workspaces/removal/worktree-background-removal'
const originalPlatform = process.platform
let directory = ''
afterEach(async () => {
afterEach(() => {
_resetPendingWorktreeRemovalsForTests()
_resetWorktreeScanCacheForTests()
scan.mockReset()
nativeGraph.mockReset()
Object.defineProperty(process, 'platform', { configurable: true, value: originalPlatform })
_resetGitAdmissionForTests()
if (directory) {
await rm(directory, { recursive: true, force: true })
}
directory = ''
})
function record(index: number, repoId: string): WorktreeRemovalRecord {
return {
@@ -99,46 +73,6 @@ function host(repos: Repo[]) {
}
}
it.each([10, 100])(
'shares the two owning repo inventories while completing %i saved removals',
async (population) => {
directory = await mkdtemp(join(tmpdir(), 'orca-recovery-scan-contract-'))
const repos = [0, 1].map((i) => ({
id: `repo-${i}`,
path: `/missing/repo-${i}`,
displayName: 'repo',
badgeColor: '',
addedAt: 0
}))
const records = Array.from({ length: population }, (_, index) =>
record(index, `repo-${index % 2}`)
)
await writeWorktreeRemovalRecords(directory, () => records)
await prepareWorktreeRemovalsForStore({
getProfileStorageDirectory: () => directory,
getRepos: () => repos
})
let release!: () => void
const reading = new Promise<void>((resolve) => {
release = resolve
})
scan.mockImplementation(async () => {
await reading
return []
})
const runtime = host(repos)
resumeInterruptedWorktreeRemovals((saved) => interruptedLocalWorktreeRemovalJob(saved, runtime))
// Each distinct repo needs one authoritative inventory; pending rows cannot require duplicate concurrent reads.
await vi.waitFor(() => expect(scan).toHaveBeenCalledTimes(2))
release()
await _settlePendingWorktreeRemovalsForTests()
expect(runtime.purge.mock.calls.map(([saved]) => saved.worktreeId).sort()).toEqual(
records.map((saved) => saved.worktreeId).sort()
)
expect(await readWorktreeRemovalRecords(directory)).toEqual([])
}
)
it('obtains a fresh inventory after a catalog generation changes and protects the replacement checkout', async () => {
const saved = record(0, 'repo-0')
const runtime = host([
@@ -167,119 +101,3 @@ it('obtains a fresh inventory after a catalog generation changes and protects th
release()
await first
})
it.each([10, 100])(
'cancels queued recovery before spawning an inventory and preserves %i accepted records',
async (population) => {
directory = await mkdtemp(join(tmpdir(), 'orca-recovery-cancel-'))
_resetGitAdmissionForTests(new GitAdmissionScheduler({ generalCap: 1, generalHeadroom: 0 }))
const blocker = await acquireGitAdmission({
args: ['status'],
cwd: '/held',
tier: 'background'
})
const repos = [
{ id: 'repo-0', path: '/missing/repo-0', displayName: 'repo', badgeColor: '', addedAt: 0 }
]
const records = Array.from({ length: population }, (_, index) => record(index, 'repo-0'))
const spawn = vi.fn()
scan.mockImplementation(async (cwd: string, options: { signal: AbortSignal }) => {
const grant = await acquireGitAdmission({
args: ['worktree', 'list', '--porcelain'],
cwd,
signal: options.signal,
tier: 'background'
})
try {
spawn()
return []
} finally {
grant.release()
}
})
try {
await writeWorktreeRemovalRecords(directory, () => records)
await prepareWorktreeRemovalsForStore({
getProfileStorageDirectory: () => directory,
getRepos: () => repos
})
const runtime = host(repos)
resumeInterruptedWorktreeRemovals((saved) =>
interruptedLocalWorktreeRemovalJob(saved, runtime)
)
await vi.waitFor(() => expect(scan).toHaveBeenCalledOnce())
await worktreeRemovalLifetime.close()
expect(spawn).not.toHaveBeenCalled()
expect(runtime.purge).not.toHaveBeenCalled()
expect(
(await readWorktreeRemovalRecords(directory)).map((saved) => saved.worktreeId).sort()
).toEqual(records.map((saved) => saved.worktreeId).sort())
} finally {
blocker.release()
}
}
)
it.each([10, 100])(
'cancels the shared native authorization after outer inventory for %i saved removals',
async (population) => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
directory = await mkdtemp(join(tmpdir(), 'orca-native-recovery-cancel-'))
_resetGitAdmissionForTests(new GitAdmissionScheduler({ generalCap: 1, generalHeadroom: 0 }))
const blocker = await acquireGitAdmission({
args: ['status'],
cwd: '/held',
tier: 'background'
})
const records = Array.from({ length: population }, (_, index) => record(index, 'repo-0'))
const repos = [
{ id: 'repo-0', path: '/missing/repo-0', displayName: 'repo', badgeColor: '', addedAt: 0 }
]
scan.mockResolvedValue(
records.map((saved) => ({
path: saved.worktreePath,
branch: 'refs/heads/feature',
head: 'abc',
isBare: false,
isMainWorktree: false
}))
)
const spawned = vi.fn()
nativeGraph.mockImplementation(async (cwd: string, options: { signal: AbortSignal }) => {
const grant = await acquireGitAdmission({
args: ['worktree', 'list', '--porcelain'],
cwd,
signal: options.signal,
tier: 'background'
})
try {
spawned()
return []
} finally {
grant.release()
}
})
try {
await writeWorktreeRemovalRecords(directory, () => records)
await prepareWorktreeRemovalsForStore({
getProfileStorageDirectory: () => directory,
getRepos: () => repos
})
const runtime = host(repos)
resumeInterruptedWorktreeRemovals((saved) =>
interruptedLocalWorktreeRemovalJob(saved, runtime)
)
await vi.waitFor(() => expect(nativeGraph).toHaveBeenCalledOnce())
await worktreeRemovalLifetime.close()
expect(spawned).not.toHaveBeenCalled()
expect(runtime.acquireWatcherRemoval).not.toHaveBeenCalled()
expect(runtime.stopPtys).not.toHaveBeenCalled()
expect(runtime.purge).not.toHaveBeenCalled()
expect(
(await readWorktreeRemovalRecords(directory)).map((saved) => saved.worktreeId).sort()
).toEqual(records.map((saved) => saved.worktreeId).sort())
} finally {
blocker.release()
}
}
)
@@ -5,17 +5,14 @@ import {
readPersistedStateJson
} from '../persistence/persistence-test-harness'
import { hostWorktreeTarget } from '../../shared/worktree/host-qualified-identity'
import {
worktreeRemovalLifetime,
_resetWorktreeRemovalLifetimeForTests
} from '../workspaces/removal/worktree-removal-lifetime'
import { mkdtemp, readFile, rm } from 'node:fs/promises'
import { _resetWorktreeRemovalLifetimeForTests } from '../workspaces/removal/worktree-removal-lifetime'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { holdRemovalMetadata } from '../workspaces/removal/worktree-removal-lifetime.test-fixtures'
import { readWorktreeRemovalRecords } from '../workspaces/removal/worktree-removal-records'
import { _resetPendingWorktreeRemovalsForTests } from '../workspaces/removal/worktree-background-removal'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
import type { ServeDesktopActivationGate } from './serve-launch/serve-desktop-activation'
const { state, foundation, runtime, i18n, launch } = vi.hoisted(() => ({
@@ -79,92 +76,6 @@ beforeEach(() => {
state.profileShutdownCheckpoint = null
})
describe('startup persistence lifetime', () => {
it('awaits writer release after a later startup phase fails', async () => {
const failure = new Error('runtime startup failed')
const admission = state.profileStateAdmission
runtime.mockRejectedValueOnce(failure)
let release = () => {}
state.store.freezeWritesAsync.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
release = resolve
})
)
const ready = initializeMainProcessReady(options)
const rejected = expect(ready).rejects.toBe(failure)
await vi.waitFor(() => expect(state.store.freezeWritesAsync).toHaveBeenCalledOnce())
expect(admission?.release).not.toHaveBeenCalled()
release()
await rejected
expect(admission?.release).toHaveBeenCalledOnce()
expect(state.profileStateAdmission).toBeUndefined()
expect(launch).not.toHaveBeenCalled()
})
it('keeps the original startup failure when cleanup also fails', async () => {
const log = vi.spyOn(console, 'error').mockImplementation(() => {})
const failure = new Error('foundation failed')
foundation.mockRejectedValueOnce(failure)
state.store.freezeWritesAsync.mockRejectedValueOnce(new Error('close failed'))
try {
await expect(initializeMainProcessReady(options)).rejects.toBe(failure)
expect(log).toHaveBeenCalledOnce()
expect(state.profileStateAdmission?.release).not.toHaveBeenCalled()
} finally {
log.mockRestore()
}
})
})
it('freezes the profile after a drained removal fails without releasing its ownership', async () => {
const log = vi.spyOn(console, 'error').mockImplementation(() => {})
try {
await expect(
worktreeRemovalLifetime.prepare(
async () => {
throw new Error('load failed')
},
() => {},
async () => {}
)
).rejects.toThrow('load failed')
const failure = new Error('runtime startup failed')
runtime.mockRejectedValueOnce(failure)
await expect(initializeMainProcessReady(options)).rejects.toBe(failure)
expect(state.store.flushFinalOrThrowAsync).toHaveBeenCalledOnce()
expect(state.store.freezeWritesAsync).toHaveBeenCalledOnce()
expect(state.profileStateAdmission?.release).not.toHaveBeenCalled()
} finally {
log.mockRestore()
}
})
it('joins successful removal metadata and its journal before failed startup freezes or releases the profile', async () => {
const directory = await mkdtemp(join(tmpdir(), 'orca-startup-removal-'))
try {
const pending = await holdRemovalMetadata(directory)
const failure = new Error('runtime startup failed')
runtime.mockRejectedValueOnce(failure)
const rejected = expect(initializeMainProcessReady(options)).rejects.toBe(failure)
await vi.waitFor(() => expect(worktreeRemovalLifetime.closing).toBe(true))
expect(state.store.freezeWritesAsync).not.toHaveBeenCalled()
expect(state.profileStateAdmission?.release).not.toHaveBeenCalled()
expect(await readWorktreeRemovalRecords(directory)).toHaveLength(1)
pending.release()
await rejected
await pending.result
expect(await readFile(join(directory, 'metadata-finished'), 'utf8')).toBe('removed')
expect(await readWorktreeRemovalRecords(directory)).toEqual([])
expect(state.store.freezeWritesAsync).toHaveBeenCalledOnce()
expect(state.profileStateAdmission).toBeUndefined()
} finally {
vi.restoreAllMocks()
_resetPendingWorktreeRemovalsForTests()
await rm(directory, { recursive: true, force: true })
}
})
it('persists successful removal metadata after the early startup checkpoint before releasing its profile', async () => {
vi.useFakeTimers()
const directory = await mkdtemp(join(tmpdir(), 'orca-startup-final-save-'))
@@ -208,27 +119,3 @@ it('persists successful removal metadata after the early startup checkpoint befo
await rm(directory, { recursive: true, force: true })
}
})
it.each(['final-save', 'early-checkpoint'] as const)(
'still freezes after a %s failure and preserves the startup error',
async (phase) => {
const log = vi.spyOn(console, 'error').mockImplementation(() => {})
const failure = new Error('runtime startup failed')
runtime.mockRejectedValueOnce(failure)
if (phase === 'final-save') {
state.store.flushFinalOrThrowAsync.mockRejectedValueOnce(new Error('save failed'))
} else {
state.store.flushPendingOrThrowAsync.mockRejectedValueOnce(new Error('early save failed'))
}
const admission = state.profileStateAdmission
await expect(initializeMainProcessReady(options)).rejects.toBe(failure)
expect(state.store.flushFinalOrThrowAsync).toHaveBeenCalledOnce()
expect(state.store.freezeWritesAsync).toHaveBeenCalledOnce()
if (phase === 'final-save') {
expect(admission?.release).not.toHaveBeenCalled()
} else {
expect(admission?.release).toHaveBeenCalledOnce()
}
log.mockRestore()
}
)
@@ -1,5 +1,5 @@
import { EventEmitter } from 'node:events'
import { mkdtemp, readFile, rm } from 'node:fs/promises'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, expect, it, vi } from 'vitest'
@@ -141,91 +141,6 @@ async function startQuit(
return { app, admission, store, state }
}
it('quits at the teardown deadline without releasing admission while the writer is pending', async () => {
const { app, admission, store, state } = await startQuit(() => new Promise<void>(() => {}))
await vi.advanceTimersByTimeAsync(WILL_QUIT_TEARDOWN_DEADLINE_MS - 1)
expect(app.quit).not.toHaveBeenCalled()
await vi.advanceTimersByTimeAsync(1)
expect(app.quit).toHaveBeenCalledOnce()
expect(console.warn).toHaveBeenCalledWith('[shutdown] Quit teardown deadline reached', {
pendingTeardowns: ['state']
})
expect(store.flushFinalOrThrowAsync).toHaveBeenCalledOnce()
expect(store.freezeWritesAsync).not.toHaveBeenCalled()
expect(admission.release).not.toHaveBeenCalled()
expect(state.profileStateAdmission).toBe(admission)
})
it('keeps profile, watcher and daemon ownership until successful removal metadata and journal settle', async () => {
const directory = await mkdtemp(join(tmpdir(), 'orca-quit-removal-'))
let release!: () => void
let readRecords!: () => Promise<unknown[]>
let reset!: () => void
const { store, admission } = await startQuit(
async () => {},
{ watcherShutdownDone: false },
async () => {
const { worktreeRemovalLifetime } =
await import('../../workspaces/removal/worktree-removal-lifetime')
const { holdRemovalMetadata } =
await import('../../workspaces/removal/worktree-removal-lifetime.test-fixtures')
release = (await holdRemovalMetadata(directory)).release
const records = await import('../../workspaces/removal/worktree-removal-records')
readRecords = () => records.readWorktreeRemovalRecords(directory)
reset = (await import('../../workspaces/removal/worktree-background-removal'))
._resetPendingWorktreeRemovalsForTests
expect(worktreeRemovalLifetime.closing).toBe(false)
}
)
await vi.advanceTimersByTimeAsync(0)
expect(store.flushFinalOrThrowAsync).not.toHaveBeenCalled()
expect(admission.release).not.toHaveBeenCalled()
expect(disconnectDaemon).not.toHaveBeenCalled()
expect(closeAllWatchers).not.toHaveBeenCalled()
expect(await readRecords()).toHaveLength(1)
release()
await vi.waitFor(() => expect(admission.release).toHaveBeenCalledOnce())
expect(await readFile(join(directory, 'metadata-finished'), 'utf8')).toBe('removed')
expect(await readRecords()).toEqual([])
reset()
await rm(directory, { recursive: true, force: true })
expect(store.freezeWritesAsync).toHaveBeenCalledOnce()
expect(admission.release).toHaveBeenCalledOnce()
expect(disconnectDaemon).toHaveBeenCalledOnce()
expect(closeAllWatchers).toHaveBeenCalledOnce()
})
it('finishes saving after a quiescent removal reports failure, retaining the failed ownership fence', async () => {
const log = vi.spyOn(console, 'error').mockImplementation(() => {})
const { store, admission } = await startQuit(
async () => {},
{ watcherShutdownDone: false },
async () => {
const { worktreeRemovalLifetime } =
await import('../../workspaces/removal/worktree-removal-lifetime')
await expect(
worktreeRemovalLifetime.prepare(
async () => {
throw new Error('load failed')
},
() => {},
async () => {}
)
).rejects.toThrow('load failed')
}
)
await vi.advanceTimersByTimeAsync(0)
expect(store.flushFinalOrThrowAsync).toHaveBeenCalledOnce()
expect(store.freezeWritesAsync).toHaveBeenCalledOnce()
expect(admission.release).not.toHaveBeenCalled()
expect(disconnectDaemon).toHaveBeenCalledOnce()
expect(closeAllWatchers).toHaveBeenCalledOnce()
expect(log).toHaveBeenCalledWith(
'[worktrees] Failed to finish stopping workspace deletion:',
expect.any(Error)
)
})
it('checkpoints pane state during a held synchronous deletion, then saves later metadata before releasing ownership', async () => {
const directory = await mkdtemp(join(tmpdir(), 'orca-quit-checkpoint-'))
const { Store } = await import('../../persistence/loading-store/store')
@@ -178,31 +178,3 @@ it('joins listing writes outside jobs and seals submissions before a successor w
expect.objectContaining({ worktreeId: 'successor' })
])
})
it('joins preparation that is still loading before allowing a failed startup to unwind', async () => {
const loading = deferred()
const draining = deferred()
const ready = worktreeRemovalLifetime.prepare(
() => loading.promise,
() => {},
() => draining.promise
)
const startupFailure = expect(ready).rejects.toThrow('Orca stopped while preparing')
const closing = worktreeRemovalLifetime.close()
const stopFailure = expect(closing).rejects.toThrow('Orca stopped while preparing')
loading.resolve()
await startupFailure
let released = false
void closing.then(
() => {
released = true
},
() => {
released = true
}
)
await Promise.resolve()
expect(released).toBe(false)
draining.resolve()
await stopFailure
})