mirror of
https://github.com/stablyai/orca.git
synced 2026-11-18 11:54:46 +00:00
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:
@@ -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)
|
||||
})
|
||||
|
||||
+2
-184
@@ -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
|
||||
})
|
||||
|
||||
Reference in New Issue
Block a user