From 7f736d7c4aa7c611bb2315762275366655852bec Mon Sep 17 00:00:00 2001 From: OrcaWin Date: Fri, 13 Nov 2026 23:14:08 -0800 Subject: [PATCH] test: remove low-value launch removal and persistence examples (#42318) Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com> --- ...ex-runtime-home-launch-preparation.test.ts | 10 +- .../hook-service-launch-preparation.test.ts | 23 --- .../windows-worktree-authorization.test.ts | 81 +------- ...ime-removal-recovery-scan-contract.test.ts | 186 +----------------- ...-process-ready-persistence-cleanup.test.ts | 119 +---------- .../main-process-quit-pending-writer.test.ts | 87 +------- .../removal/worktree-removal-lifetime.test.ts | 28 --- 7 files changed, 8 insertions(+), 526 deletions(-) diff --git a/src/main/codex/configuration/homes/codex-runtime-home-launch-preparation.test.ts b/src/main/codex/configuration/homes/codex-runtime-home-launch-preparation.test.ts index d600828aada..887d75e1d6f 100644 --- a/src/main/codex/configuration/homes/codex-runtime-home-launch-preparation.test.ts +++ b/src/main/codex/configuration/homes/codex-runtime-home-launch-preparation.test.ts @@ -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 = { 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, diff --git a/src/main/codex/hooks/installation/hook-service-launch-preparation.test.ts b/src/main/codex/hooks/installation/hook-service-launch-preparation.test.ts index 2afc30c9df7..4630a669e1d 100644 --- a/src/main/codex/hooks/installation/hook-service-launch-preparation.test.ts +++ b/src/main/codex/hooks/installation/hook-service-launch-preparation.test.ts @@ -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) => { diff --git a/src/main/git/worktrees/removal/windows-worktree-authorization.test.ts b/src/main/git/worktrees/removal/windows-worktree-authorization.test.ts index 3847b06772a..ff14a5e2679 100644 --- a/src/main/git/worktrees/removal/windows-worktree-authorization.test.ts +++ b/src/main/git/worktrees/removal/windows-worktree-authorization.test.ts @@ -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() - 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() - const entered = Promise.withResolvers() - 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() @@ -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() - graph.mockImplementation(async (_repo, options) => { - entered.resolve() - return waitForPromiseWithSignal(new Promise(() => {}), 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) -}) diff --git a/src/main/runtime/workspaces/removal/runtime-removal-recovery-scan-contract.test.ts b/src/main/runtime/workspaces/removal/runtime-removal-recovery-scan-contract.test.ts index f5e955e25dc..30119cd6fe9 100644 --- a/src/main/runtime/workspaces/removal/runtime-removal-recovery-scan-contract.test.ts +++ b/src/main/runtime/workspaces/removal/runtime-removal-recovery-scan-contract.test.ts @@ -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((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() - } - } -) diff --git a/src/main/startup/main-process-ready-persistence-cleanup.test.ts b/src/main/startup/main-process-ready-persistence-cleanup.test.ts index 1639ff60b4b..0b0b8a0f9dc 100644 --- a/src/main/startup/main-process-ready-persistence-cleanup.test.ts +++ b/src/main/startup/main-process-ready-persistence-cleanup.test.ts @@ -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((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() - } -) diff --git a/src/main/startup/quit/main-process-quit-pending-writer.test.ts b/src/main/startup/quit/main-process-quit-pending-writer.test.ts index 1e69dbc82f8..9d6ea485170 100644 --- a/src/main/startup/quit/main-process-quit-pending-writer.test.ts +++ b/src/main/startup/quit/main-process-quit-pending-writer.test.ts @@ -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(() => {})) - 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 - 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') diff --git a/src/main/workspaces/removal/worktree-removal-lifetime.test.ts b/src/main/workspaces/removal/worktree-removal-lifetime.test.ts index 13477362053..39249775e37 100644 --- a/src/main/workspaces/removal/worktree-removal-lifetime.test.ts +++ b/src/main/workspaces/removal/worktree-removal-lifetime.test.ts @@ -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 -})