test: remove low-value workspace and launch coverage

This commit is contained in:
OrcaWin
2026-11-11 18:47:48 -08:00
parent 9f32c6d06d
commit 7642949317
10 changed files with 15 additions and 885 deletions
File diff suppressed because one or more lines are too long
@@ -235,7 +235,6 @@
"config/scripts/typecheck/project-execution/run-typecheck-projects-in-parallel.test.mjs": 182,
"config/scripts/tool-invocation/script-entry-detection.test.mjs": 107,
"config/scripts/test-fixtures/script-copy-closure/script-module-dependencies.test.mjs": 62,
"config/scripts/orcad-distribution/server-bundle/session-scanner-service-smoke.test.mjs": 562,
"config/scripts/ci/workflow-contracts/setup-pnpm-action.test.mjs": 421,
"config/scripts/electron-installation/shared-dist-cache/shared-electron-dist-cache.test.ts": 140,
"config/scripts/native-build/node-addons/shared-native-build.test.mjs": 127,
@@ -2186,12 +2185,9 @@
"src/main/git/remotes/worktree-push-target-setup.test.ts": 491,
"src/main/ipc/worktree-symlink-reconciliation.real.test.ts": 410,
"src/main/ipc/worktree-symlinks.test.ts": 152,
"src/main/ipc/worktrees-delete-pty-teardown.test.ts": 1934,
"src/main/ipc/worktrees-issue-command-overrides.test.ts": 1594,
"src/main/ipc/worktrees-orphan-directory-cleanup.test.ts": 1486,
"src/main/ipc/worktrees-removal-recovery.test.ts": 1971,
"src/main/ipc/worktrees-remove-preflight.test.ts": 1415,
"src/main/ipc/worktrees-ssh-repo-owner-resolution.test.ts": 1447,
"src/main/ipc/worktrees/listing/detected-provider-listing-catalog-version.test.ts": 650,
"src/main/ipc/worktrees/listing/detected-worktree-scan-hygiene-gate.test.ts": 105,
"src/main/ipc/worktrees/listing/detected-worktree-scan-listing-distro.test.ts": 880,
@@ -1,49 +0,0 @@
import { build } from 'esbuild'
import { mkdtempSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join, resolve } from 'node:path'
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { smokeSessionScannerService } from './session-scanner-service-smoke.mjs'
import {
externalNativeAddons,
ORCAD_CHILD_ENTRY_POINTS,
ORCAD_EXTERNAL_MODULES,
orcadChildOutputFilename
} from './orcad-entry-build.mjs'
const ENTRY = orcadChildOutputFilename(ORCAD_CHILD_ENTRY_POINTS.sessionScanner)
const directories = []
let builtDirectory
function fixtureDirectory() {
const directory = mkdtempSync(join(tmpdir(), 'orca-session-scanner-smoke-test-'))
directories.push(directory)
return directory
}
beforeAll(async () => {
builtDirectory = fixtureDirectory()
await build({
entryPoints: [resolve(ORCAD_CHILD_ENTRY_POINTS.sessionScanner)],
outfile: join(builtDirectory, ENTRY),
bundle: true,
platform: 'node',
target: 'node18',
format: 'cjs',
external: ORCAD_EXTERNAL_MODULES,
plugins: [externalNativeAddons],
logLevel: 'silent'
})
}, 60_000)
afterAll(() => {
for (const directory of directories) {
rmSync(directory, { recursive: true, force: true })
}
})
describe('session scanner service build smoke', () => {
it('lists a seeded session through the built entry', () => {
expect(() => smokeSessionScannerService(builtDirectory)).not.toThrow()
}, 60_000)
})
@@ -1,192 +0,0 @@
import type * as WorktreeScanCacheModule from '../git/worktrees/catalog/worktree-scan-cache'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import {
listWorktreesMock,
removeWorktreeMock,
killAllProcessesForWorktreeMock
} from './worktrees-test-module-mocks'
import { handlers, setupWorktreeHandlers, store } from './worktrees-test-harness'
import { SshHostNotServedError } from '../providers/ssh-host-not-served-error'
vi.mock('../git/worktrees/catalog/worktree-scan-cache', async (importOriginal) => {
return {
...(await importOriginal<typeof WorktreeScanCacheModule>()),
listWorktrees: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
listWorktreesSharedStrictAllowingTrueEmpty: (await import('./worktrees-test-module-mocks'))
.listWorktreesMock,
listWorktreesSharedStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock
}
})
vi.mock('electron', async () =>
(await import('./worktrees-test-module-mocks')).electronModuleMock()
)
vi.mock('../../shared/git/worktrees/git-worktree-porcelain-parser', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
parseWorktreeList: (await import('./worktrees-test-module-mocks')).parseWorktreeListMock
}))
vi.mock('../git/worktrees/removal/worktree-removal-preflight', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
assertWorktreeCleanForRemoval: (await import('./worktrees-test-module-mocks'))
.assertWorktreeCleanForRemovalMock
}))
vi.mock('../git/worktrees/creation/worktree-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addWorktree: (await import('./worktrees-test-module-mocks')).addWorktreeMock
}))
vi.mock('../git/worktrees/creation/worktree-sparse-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addSparseWorktree: (await import('./worktrees-test-module-mocks')).addSparseWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
removeWorktree: (await import('./worktrees-test-module-mocks')).removeWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-branch-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
forceDeleteLocalBranch: (await import('./worktrees-test-module-mocks')).forceDeleteLocalBranchMock
}))
vi.mock('../git/worktrees/catalog/worktree-listing', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
listWorktreesStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
describeCreatedWorktree: (await import('./worktrees-test-module-mocks'))
.describeCreatedWorktreeMock
}))
const { getWorktreeRunnerMocks } = vi.hoisted(() => {
function createWorktreeRunnerMocks() {
return (async () => (await import('./worktrees-test-module-mocks')).gitRunnerModuleMock())()
}
let runner: ReturnType<typeof createWorktreeRunnerMocks> | undefined
return { getWorktreeRunnerMocks: () => (runner ??= createWorktreeRunnerMocks()) }
})
vi.mock('../git/command-runner/git-exec-file', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileAsync: (await getWorktreeRunnerMocks()).gitExecFileAsync
}))
vi.mock('../git/command-runner/git-exec-file-sync', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileSync: (await getWorktreeRunnerMocks()).gitExecFileSync
}))
vi.mock('../git/remotes/repo-remote-queries', async () => ({
getDefaultRemote: (await import('./worktrees-test-module-mocks')).getDefaultRemoteMock
}))
vi.mock('../git/refs/resolution/repo-branch-conflict', async () =>
(await import('./worktrees-test-module-mocks')).gitBranchConflictModuleMock()
)
vi.mock('../git/refs/resolution/repo-default-base-ref', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
getDefaultBaseRefAsync: (await import('./worktrees-test-module-mocks')).getBaseRefDefaultMock,
resolveDefaultBaseRefWithLocalGit: (await import('./worktrees-test-module-mocks'))
.resolveDefaultBaseRefWithLocalGitMock
}))
vi.mock('../git/repositories/git-username', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
resolveLocalGitUsername: (await import('./worktrees-test-module-mocks'))
.resolveLocalGitUsernameMock
}))
vi.mock('../github/client', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../github/client/lookup/get-pr-for-branch', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../source-control/hosted-review', async () =>
(await import('./worktrees-test-module-mocks')).hostedReviewModuleMock()
)
vi.mock('./worktree-symlinks', async () =>
(await import('./worktrees-test-module-mocks')).worktreeSymlinksModuleMock()
)
vi.mock('../git/worktrees/content-paths/worktree-symlink-detection', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
findExistingWorktreeSymlinkPaths: (await import('./worktrees-test-module-mocks'))
.findExistingWorktreeSymlinkPathsMock
}))
vi.mock('../workspace-hooks/hooks', async () =>
(await import('./worktrees-test-module-mocks')).hooksModuleMock()
)
vi.mock('../workspace-hooks/setup-runner-script-text', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupRunnerScriptTextModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/worktree-runner-script', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeRunnerScriptModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/effective-hook-config', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).effectiveHookConfigModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/setup-hook-env-vars', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupHookEnvVarsModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('./worktree-logic', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeLogicModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../pty/history/terminal-history-deletion', async () =>
(await import('./worktrees-test-module-mocks')).terminalHistoryDeletionModuleMock()
)
vi.mock('../ports/advertised-url-watcher', async () =>
(await import('./worktrees-test-module-mocks')).advertisedUrlWatcherModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-scan-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupScanSnapshotModuleMock()
)
vi.mock('../workspaces/space-analysis/workspace-space-analysis-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceSpaceAnalysisSnapshotModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-removal-snapshot-prune', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupRemovalSnapshotPruneModuleMock()
)
vi.mock('../runtime/workspaces/removal/worktree-teardown', async () =>
(await import('./worktrees-test-module-mocks')).worktreeTeardownModuleMock()
)
vi.mock('./pty/provider/registry', async () =>
(await import('./worktrees-test-module-mocks')).ptyRegistryModuleMock()
)
vi.mock('./pty/provider/state-cleanup', async () =>
(await import('./worktrees-test-module-mocks')).ptyStateCleanupModuleMock()
)
describe('registerWorktreeHandlers', () => {
beforeEach(() => {
setupWorktreeHandlers()
})
it('refuses an SSH worktree delete this process does not serve, never deleting here', async () => {
const repo = {
id: 'repo-ssh',
path: '/remote/repo',
displayName: 'ssh',
badgeColor: '#000',
addedAt: 0,
connectionId: 'conn-1',
worktreeBaseRef: null
}
store.getRepos.mockReturnValue([repo])
store.getRepo.mockReturnValue(repo)
await expect(
handlers['worktrees:remove'](null, { worktreeId: 'repo-ssh::/remote/feature-wt' })
).rejects.toThrow(SshHostNotServedError)
expect(listWorktreesMock).not.toHaveBeenCalled()
expect(removeWorktreeMock).not.toHaveBeenCalled()
expect(killAllProcessesForWorktreeMock).not.toHaveBeenCalled()
})
})
@@ -1,217 +0,0 @@
import type * as WorktreeScanCacheModule from '../git/worktrees/catalog/worktree-scan-cache'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { addWorktreeMock, getBranchConflictKindStrictMock } from './worktrees-test-module-mocks'
import { handlers, setupWorktreeHandlers, store } from './worktrees-test-harness'
import { SshHostNotServedError } from '../providers/ssh-host-not-served-error'
vi.mock('../git/worktrees/catalog/worktree-scan-cache', async (importOriginal) => {
return {
...(await importOriginal<typeof WorktreeScanCacheModule>()),
listWorktrees: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
listWorktreesSharedStrictAllowingTrueEmpty: (await import('./worktrees-test-module-mocks'))
.listWorktreesMock,
listWorktreesSharedStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock
}
})
vi.mock('electron', async () =>
(await import('./worktrees-test-module-mocks')).electronModuleMock()
)
vi.mock('../../shared/git/worktrees/git-worktree-porcelain-parser', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
parseWorktreeList: (await import('./worktrees-test-module-mocks')).parseWorktreeListMock
}))
vi.mock('../git/worktrees/removal/worktree-removal-preflight', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
assertWorktreeCleanForRemoval: (await import('./worktrees-test-module-mocks'))
.assertWorktreeCleanForRemovalMock
}))
vi.mock('../git/worktrees/creation/worktree-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addWorktree: (await import('./worktrees-test-module-mocks')).addWorktreeMock
}))
vi.mock('../git/worktrees/creation/worktree-sparse-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addSparseWorktree: (await import('./worktrees-test-module-mocks')).addSparseWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
removeWorktree: (await import('./worktrees-test-module-mocks')).removeWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-branch-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
forceDeleteLocalBranch: (await import('./worktrees-test-module-mocks')).forceDeleteLocalBranchMock
}))
vi.mock('../git/worktrees/catalog/worktree-listing', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
listWorktreesStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
describeCreatedWorktree: (await import('./worktrees-test-module-mocks'))
.describeCreatedWorktreeMock
}))
const { getWorktreeRunnerMocks } = vi.hoisted(() => {
function createWorktreeRunnerMocks() {
return (async () => (await import('./worktrees-test-module-mocks')).gitRunnerModuleMock())()
}
let runner: ReturnType<typeof createWorktreeRunnerMocks> | undefined
return { getWorktreeRunnerMocks: () => (runner ??= createWorktreeRunnerMocks()) }
})
vi.mock('../git/command-runner/git-exec-file', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileAsync: (await getWorktreeRunnerMocks()).gitExecFileAsync
}))
vi.mock('../git/command-runner/git-exec-file-sync', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileSync: (await getWorktreeRunnerMocks()).gitExecFileSync
}))
vi.mock('../git/remotes/repo-remote-queries', async () => ({
getDefaultRemote: (await import('./worktrees-test-module-mocks')).getDefaultRemoteMock
}))
vi.mock('../git/refs/resolution/repo-branch-conflict', async () =>
(await import('./worktrees-test-module-mocks')).gitBranchConflictModuleMock()
)
vi.mock('../git/refs/resolution/repo-default-base-ref', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
getDefaultBaseRefAsync: (await import('./worktrees-test-module-mocks')).getBaseRefDefaultMock,
resolveDefaultBaseRefWithLocalGit: (await import('./worktrees-test-module-mocks'))
.resolveDefaultBaseRefWithLocalGitMock
}))
vi.mock('../git/repositories/git-username', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
resolveLocalGitUsername: (await import('./worktrees-test-module-mocks'))
.resolveLocalGitUsernameMock
}))
vi.mock('../github/client', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../github/client/lookup/get-pr-for-branch', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../source-control/hosted-review', async () =>
(await import('./worktrees-test-module-mocks')).hostedReviewModuleMock()
)
vi.mock('./worktree-symlinks', async () =>
(await import('./worktrees-test-module-mocks')).worktreeSymlinksModuleMock()
)
vi.mock('../git/worktrees/content-paths/worktree-symlink-detection', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
findExistingWorktreeSymlinkPaths: (await import('./worktrees-test-module-mocks'))
.findExistingWorktreeSymlinkPathsMock
}))
vi.mock('../workspace-hooks/hooks', async () =>
(await import('./worktrees-test-module-mocks')).hooksModuleMock()
)
vi.mock('../workspace-hooks/setup-runner-script-text', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupRunnerScriptTextModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/worktree-runner-script', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeRunnerScriptModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/effective-hook-config', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).effectiveHookConfigModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/setup-hook-env-vars', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupHookEnvVarsModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('./worktree-logic', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeLogicModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../pty/history/terminal-history-deletion', async () =>
(await import('./worktrees-test-module-mocks')).terminalHistoryDeletionModuleMock()
)
vi.mock('../ports/advertised-url-watcher', async () =>
(await import('./worktrees-test-module-mocks')).advertisedUrlWatcherModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-scan-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupScanSnapshotModuleMock()
)
vi.mock('../workspaces/space-analysis/workspace-space-analysis-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceSpaceAnalysisSnapshotModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-removal-snapshot-prune', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupRemovalSnapshotPruneModuleMock()
)
vi.mock('../runtime/workspaces/removal/worktree-teardown', async () =>
(await import('./worktrees-test-module-mocks')).worktreeTeardownModuleMock()
)
vi.mock('./pty/provider/registry', async () =>
(await import('./worktrees-test-module-mocks')).ptyRegistryModuleMock()
)
vi.mock('./pty/provider/state-cleanup', async () =>
(await import('./worktrees-test-module-mocks')).ptyStateCleanupModuleMock()
)
const REMOTE_REPO_PATH = '/remote/repo'
function makeRepo(fields: Record<string, unknown>) {
return {
id: 'repo-1',
path: REMOTE_REPO_PATH,
displayName: 'repo',
badgeColor: '#000',
addedAt: 0,
worktreeBaseRef: 'origin/main',
...fields
}
}
function useRepo(repo: ReturnType<typeof makeRepo>): void {
store.getRepos.mockReturnValue([repo])
store.getRepo.mockReturnValue(repo)
store.setWorktreeMeta.mockImplementation((_target: unknown, meta: unknown) => meta)
}
describe('worktrees:create execution host routing', () => {
beforeEach(() => {
setupWorktreeHandlers()
})
it('refuses a row that names an SSH host only as executionHostId instead of creating locally', async () => {
useRepo(makeRepo({ executionHostId: 'ssh:target-a' }))
await expect(
handlers['worktrees:create'](null, { repoId: 'repo-1', name: 'wt' })
).rejects.toThrow(SshHostNotServedError)
expect(addWorktreeMock).not.toHaveBeenCalled()
})
})
describe('worktrees:create exact name', () => {
beforeEach(() => {
setupWorktreeHandlers()
})
// Electron flattens the error to its message, so the renderer reads the code from the trailing token.
it('refuses a taken name with the code token instead of suffixing', async () => {
getBranchConflictKindStrictMock.mockResolvedValue('local')
await expect(
handlers['worktrees:create'](null, {
repoId: 'repo-1',
name: 'Login fix',
branchIntent: 'create-exact'
})
).rejects.toThrow(/\nworktree_create_exact_name_taken$/)
expect(addWorktreeMock).not.toHaveBeenCalled()
})
})
@@ -228,45 +228,6 @@ describe('registerWorktreeHandlers', () => {
}
})
it('prompts for force before removing an Orca-created orphaned worktree directory', async () => {
const parentDir = await mkdtemp(join(tmpdir(), 'orca-ipc-orphan-'))
const repoPath = join(parentDir, 'repo')
const orphanPath = join(parentDir, 'orphan')
const adminWorktreePath = join(repoPath, '.git', 'worktrees', 'orphan')
await mkdir(orphanPath, { recursive: true })
await mkdir(adminWorktreePath, { recursive: true })
await writeFile(join(orphanPath, '.git'), `gitdir: ${adminWorktreePath}\n`)
await writeFile(join(adminWorktreePath, 'gitdir'), `${join(orphanPath, '.git')}\n`)
const repo = {
id: 'repo-1',
path: repoPath,
displayName: 'repo',
badgeColor: '#000',
addedAt: 0,
worktreeBaseRef: null
}
store.getRepo.mockReturnValue(repo)
store.getRepos.mockReturnValue([repo])
mockKnownFeatureWorktree(join(parentDir, 'real-feature'), repoPath)
store.getWorktreeMeta.mockReturnValue(
makeWorktreeMeta({ orcaCreatedAt: Date.now(), orcaCreationSource: 'runtime' })
)
try {
await expect(
handlers['worktrees:remove'](null, {
worktreeId: `repo-1::${orphanPath}`
})
).rejects.toThrow('Worktree is no longer registered with Git but its directory remains.')
await expect(lstat(orphanPath)).resolves.toBeTruthy()
expect(removeWorktreeMock).not.toHaveBeenCalled()
expect(store.removeWorktreeMeta).not.toHaveBeenCalled()
} finally {
await rm(parentDir, { recursive: true, force: true })
}
})
it('refuses an Orca-created unregistered directory with no git marker, even forced, until the user removes it', async () => {
const parentDir = await mkdtemp(join(tmpdir(), 'orca-ipc-leftover-'))
const repoPath = join(parentDir, 'repo')
@@ -316,69 +277,4 @@ describe('registerWorktreeHandlers', () => {
await rm(parentDir, { recursive: true, force: true })
}
})
it('rejects an Orca-created unregistered local directory with a git directory', async () => {
const parentDir = await mkdtemp(join(tmpdir(), 'orca-ipc-standalone-'))
const repoPath = join(parentDir, 'repo')
const standalonePath = join(parentDir, 'standalone')
await mkdir(join(standalonePath, '.git'), { recursive: true })
store.getRepo.mockReturnValue({
id: 'repo-1',
path: repoPath,
displayName: 'repo',
badgeColor: '#000',
addedAt: 0,
worktreeBaseRef: null
})
mockKnownFeatureWorktree(join(parentDir, 'real-feature'), repoPath)
store.getWorktreeMeta.mockReturnValue(
makeWorktreeMeta({ orcaCreatedAt: Date.now(), orcaCreationSource: 'runtime' })
)
try {
await expect(
handlers['worktrees:remove'](null, {
worktreeId: `repo-1::${standalonePath}`,
force: true
})
).rejects.toThrow(`Refusing to delete unregistered worktree path: ${standalonePath}`)
await expect(lstat(standalonePath)).resolves.toBeTruthy()
expect(removeWorktreeMock).not.toHaveBeenCalled()
expect(store.removeWorktreeMeta).not.toHaveBeenCalled()
} finally {
await rm(parentDir, { recursive: true, force: true })
}
})
it('does not inspect or delete a local path for an SSH orphan this process does not serve', async () => {
const localPath = await mkdtemp(join(tmpdir(), 'orca-ipc-ssh-missing-fs-'))
const repo = {
id: 'repo-ssh-missing-fs',
path: '/remote/repo',
displayName: 'ssh',
badgeColor: '#000',
addedAt: 0,
connectionId: 'conn-missing-fs'
}
store.getRepo.mockReturnValue(repo)
store.getWorktreeMeta.mockReturnValue(
makeWorktreeMeta({ orcaCreatedAt: Date.now(), orcaCreationSource: 'ssh' })
)
try {
await expect(
handlers['worktrees:remove'](null, {
worktreeId: `${repo.id}::${localPath}`,
force: true
})
).rejects.toThrow('isn’t served by Orca’s server')
await expect(lstat(localPath)).resolves.toBeTruthy()
expect(removeWorktreeMock).not.toHaveBeenCalled()
expect(store.removeWorktreeMeta).not.toHaveBeenCalled()
} finally {
await rm(localPath, { recursive: true, force: true })
}
})
})
@@ -1,260 +0,0 @@
import type * as WorktreeScanCacheModule from '../git/worktrees/catalog/worktree-scan-cache'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import type { ProviderRequestId } from '../../shared/detected-worktree-provider-contract'
import { toSshExecutionHostId } from '../../shared/execution-host'
import { getSshProviderAuthority } from '../ssh/connection/authority/ssh-provider-authority'
import { listWorktreesMock } from './worktrees-test-module-mocks'
import { handlers, ipcEvent, setupWorktreeHandlers, store } from './worktrees-test-harness'
vi.mock('../git/worktrees/catalog/worktree-scan-cache', async (importOriginal) => {
return {
...(await importOriginal<typeof WorktreeScanCacheModule>()),
listWorktrees: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
listWorktreesSharedStrictAllowingTrueEmpty: (await import('./worktrees-test-module-mocks'))
.listWorktreesMock,
listWorktreesSharedStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock
}
})
vi.mock('electron', async () =>
(await import('./worktrees-test-module-mocks')).electronModuleMock()
)
vi.mock('../../shared/git/worktrees/git-worktree-porcelain-parser', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
parseWorktreeList: (await import('./worktrees-test-module-mocks')).parseWorktreeListMock
}))
vi.mock('../git/worktrees/removal/worktree-removal-preflight', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
assertWorktreeCleanForRemoval: (await import('./worktrees-test-module-mocks'))
.assertWorktreeCleanForRemovalMock
}))
vi.mock('../git/worktrees/creation/worktree-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addWorktree: (await import('./worktrees-test-module-mocks')).addWorktreeMock
}))
vi.mock('../git/worktrees/creation/worktree-sparse-add', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
addSparseWorktree: (await import('./worktrees-test-module-mocks')).addSparseWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
removeWorktree: (await import('./worktrees-test-module-mocks')).removeWorktreeMock
}))
vi.mock('../git/worktrees/removal/worktree-branch-removal', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
forceDeleteLocalBranch: (await import('./worktrees-test-module-mocks')).forceDeleteLocalBranchMock
}))
vi.mock('../git/worktrees/catalog/worktree-listing', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
listWorktreesStrict: (await import('./worktrees-test-module-mocks')).listWorktreesMock,
describeCreatedWorktree: (await import('./worktrees-test-module-mocks'))
.describeCreatedWorktreeMock
}))
const { getWorktreeRunnerMocks } = vi.hoisted(() => {
function createWorktreeRunnerMocks() {
return (async () => (await import('./worktrees-test-module-mocks')).gitRunnerModuleMock())()
}
let runner: ReturnType<typeof createWorktreeRunnerMocks> | undefined
return { getWorktreeRunnerMocks: () => (runner ??= createWorktreeRunnerMocks()) }
})
vi.mock('../git/command-runner/git-exec-file', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileAsync: (await getWorktreeRunnerMocks()).gitExecFileAsync
}))
vi.mock('../git/command-runner/git-exec-file-sync', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
gitExecFileSync: (await getWorktreeRunnerMocks()).gitExecFileSync
}))
vi.mock('../git/remotes/repo-remote-queries', async () => ({
getDefaultRemote: (await import('./worktrees-test-module-mocks')).getDefaultRemoteMock
}))
vi.mock('../git/refs/resolution/repo-branch-conflict', async () =>
(await import('./worktrees-test-module-mocks')).gitBranchConflictModuleMock()
)
vi.mock('../git/refs/resolution/repo-default-base-ref', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
getDefaultBaseRefAsync: (await import('./worktrees-test-module-mocks')).getBaseRefDefaultMock,
resolveDefaultBaseRefWithLocalGit: (await import('./worktrees-test-module-mocks'))
.resolveDefaultBaseRefWithLocalGitMock
}))
vi.mock('../git/repositories/git-username', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
resolveLocalGitUsername: (await import('./worktrees-test-module-mocks'))
.resolveLocalGitUsernameMock
}))
vi.mock('../github/client', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../github/client/lookup/get-pr-for-branch', async () =>
(await import('./worktrees-test-module-mocks')).githubClientModuleMock()
)
vi.mock('../source-control/hosted-review', async () =>
(await import('./worktrees-test-module-mocks')).hostedReviewModuleMock()
)
vi.mock('./worktree-symlinks', async () =>
(await import('./worktrees-test-module-mocks')).worktreeSymlinksModuleMock()
)
vi.mock('../git/worktrees/content-paths/worktree-symlink-detection', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
findExistingWorktreeSymlinkPaths: (await import('./worktrees-test-module-mocks'))
.findExistingWorktreeSymlinkPathsMock
}))
vi.mock('../workspace-hooks/hooks', async () =>
(await import('./worktrees-test-module-mocks')).hooksModuleMock()
)
vi.mock('../workspace-hooks/setup-runner-script-text', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupRunnerScriptTextModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/worktree-runner-script', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeRunnerScriptModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/effective-hook-config', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).effectiveHookConfigModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../workspace-hooks/setup-hook-env-vars', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).setupHookEnvVarsModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('./worktree-logic', async (importOriginal) =>
(await import('./worktrees-test-module-mocks')).worktreeLogicModuleMock(
(await importOriginal()) as Record<string, unknown>
)
)
vi.mock('../pty/history/terminal-history-deletion', async () =>
(await import('./worktrees-test-module-mocks')).terminalHistoryDeletionModuleMock()
)
vi.mock('../ports/advertised-url-watcher', async () =>
(await import('./worktrees-test-module-mocks')).advertisedUrlWatcherModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-scan-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupScanSnapshotModuleMock()
)
vi.mock('../workspaces/space-analysis/workspace-space-analysis-snapshot', async () =>
(await import('./worktrees-test-module-mocks')).workspaceSpaceAnalysisSnapshotModuleMock()
)
vi.mock('../workspaces/cleanup/workspace-cleanup-removal-snapshot-prune', async () =>
(await import('./worktrees-test-module-mocks')).workspaceCleanupRemovalSnapshotPruneModuleMock()
)
vi.mock('../runtime/workspaces/removal/worktree-teardown', async () =>
(await import('./worktrees-test-module-mocks')).worktreeTeardownModuleMock()
)
vi.mock('./pty/provider/registry', async () =>
(await import('./worktrees-test-module-mocks')).ptyRegistryModuleMock()
)
vi.mock('./pty/provider/state-cleanup', async () =>
(await import('./worktrees-test-module-mocks')).ptyStateCleanupModuleMock()
)
describe('registerWorktreeHandlers', () => {
beforeEach(() => {
setupWorktreeHandlers()
})
// Runtime rows bypass local stale GC too, so only authoritative host scans retire them (#17776).
// Runtime ownership plus a connectionId is contradictory; findExactRepoOwner must refuse it.
it('fails closed for duplicate exact owners and ambiguous legacy repo IDs', async () => {
const sshRepo = {
id: 'shared-repo',
path: '/remote/repo-a',
displayName: 'remote repo',
badgeColor: '#000',
addedAt: 0,
connectionId: 'target-a'
}
const duplicateSshRepo = { ...sshRepo, path: '/remote/repo-b' }
const localRepo = { ...sshRepo, path: '/local/repo', connectionId: undefined }
store.getRepos.mockReturnValue([sshRepo, duplicateSshRepo, localRepo])
const expectedAuthority = getSshProviderAuthority('target-a')
const qualified = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: 'request-1' as ProviderRequestId,
repoId: 'shared-repo',
executionHostId: toSshExecutionHostId('target-a'),
expectedAuthority
})
const legacy = await handlers['worktrees:listDetected'](null, { repoId: 'shared-repo' })
expect(qualified).toMatchObject({
status: 'ambiguous-owner',
providerRequestId: 'request-1',
executionHostId: 'ssh:target-a'
})
expect(legacy).toEqual({
repoId: 'shared-repo',
authoritative: false,
source: 'metadata-fallback',
worktrees: []
})
expect(listWorktreesMock).not.toHaveBeenCalled()
})
it('rejects runtime hosts, wrong SSH targets, and missing authority', async () => {
const requestId = 'request-1' as ProviderRequestId
const expectedAuthority = getSshProviderAuthority('target-a')
const runtimeResult = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: requestId,
repoId: 'repo-1',
executionHostId: 'runtime:runtime-a'
})
const wrongTargetResult = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: requestId,
repoId: 'repo-1',
executionHostId: toSshExecutionHostId('target-b'),
expectedAuthority
})
const missingAuthorityResult = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: requestId,
repoId: 'repo-1',
executionHostId: toSshExecutionHostId('target-a')
})
const zeroOwnerResult = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: requestId,
repoId: 'repo-1',
executionHostId: toSshExecutionHostId('target-a'),
expectedAuthority
})
store.getRepos.mockReturnValue([
{
id: 'repo-1',
path: '/remote/repo',
displayName: 'repo',
badgeColor: '#000',
addedAt: 0,
connectionId: 'target-b',
executionHostId: toSshExecutionHostId('target-a')
}
])
const wrongProviderOwnerResult = await handlers['worktrees:listDetected'](ipcEvent, {
providerRequestId: requestId,
repoId: 'repo-1',
executionHostId: toSshExecutionHostId('target-a'),
expectedAuthority
})
expect(runtimeResult).toMatchObject({ status: 'rejected' })
expect(wrongTargetResult).toMatchObject({ status: 'rejected' })
expect(missingAuthorityResult).toMatchObject({ status: 'rejected' })
expect(zeroOwnerResult).toMatchObject({ status: 'ambiguous-owner' })
expect(wrongProviderOwnerResult).toMatchObject({ status: 'rejected' })
expect(listWorktreesMock).not.toHaveBeenCalled()
})
})
@@ -6,14 +6,12 @@ import { AtRestCommandCatalog } from '../at-rest-command-catalog'
function catalogWithSkills() {
let stamp = 'a'
let skills = ['old-skill']
let scans = 0
const catalog = new AtRestCommandCatalog({
label: 'test',
accepts: () => true,
resolveWorkspacePath: async () => tmpdir(),
stamp: async () => stamp,
scan: async () => {
scans += 1
return {
commands: skills.map((name) => ({ name, kind: 'skill' as const, path: `/s/${name}` })),
fromAgent: true
@@ -22,7 +20,6 @@ function catalogWithSkills() {
})
return {
catalog,
scans: () => scans,
install: (name: string, nextStamp: string) => {
skills = [...skills, name]
stamp = nextStamp
@@ -34,13 +31,12 @@ const names = (commands: { name: string }[] | undefined) => commands?.map(({ nam
describe('at-rest commands before the TTL', () => {
it('rescans on a menu open once the skill sources changed', async () => {
const { catalog, scans, install } = catalogWithSkills()
const { catalog, install } = catalogWithSkills()
const record = hostTestRestingOptionsRecord()
expect(names(await catalog.settled(record, 1_000, true))).toEqual(['old-skill'])
install('perf-scan', 'b')
expect(names(await catalog.settled(record, 1_000, true))).toEqual(['old-skill', 'perf-scan'])
expect(scans()).toBe(2)
catalog.dispose()
})
})
@@ -70,28 +70,6 @@ function rig(
}
}
it('tries CLI reuse once while independent generation retries, and skips it on manual regeneration', async () => {
const reuse = vi.fn()
const generate = vi.fn<StructuredChatNamingDeps['generate']>(
async (_record, _prompt, _current, automatic) => {
if (automatic) {
reuse()
}
return generate.mock.calls.length === 1
? { error: 'Retry independent generation' }
: { name: 'Login repair' }
}
)
const state = rig(generate)
state.start()
await state.done()
expect(state.record().conversationName).toBe('Login repair')
expect(reuse).toHaveBeenCalledOnce()
state.handler.regenerate('chat-1')
await state.done()
expect(reuse).toHaveBeenCalledOnce()
})
it.each(['owner', 'same-text rename'] as const)(
'rejects a queued title write after %s changes',
async (change) => {
@@ -21,15 +21,6 @@ describe('planOpenCodeRootModelRewrite', () => {
).toBe(`& opencode --standalone${tail}`)
})
it('uses the last of repeated models and an existing --standalone', () => {
expect(
planOpenCodeRootModelRewrite(
`opencode2 --standalone ${q(['--model', 'a/b', '--model=c/d'], 'posix')}`,
'posix'
)
).toMatchObject({ command: 'opencode2 --standalone', model: 'c/d' })
})
it.each([
['posix', `opencode ${q(['run', '--model', 'a/b'], 'posix')}`],
['posix', `opencode ${q(['./pkg', '--model', 'a/b'], 'posix')}`],
@@ -51,13 +42,4 @@ describe('planOpenCodeRootModelRewrite', () => {
] as const)('leaves %s `%s` as typed', (shell, command) => {
expect(planOpenCodeRootModelRewrite(command, shell, 'C:\\')).toBeNull()
})
it('probes the primary agent only for a new session on it', () => {
expect(
planOpenCodeRootModelRewrite(
`opencode ${q(['-s', 'ses_1', '--model', 'a/b'], 'posix')}`,
'posix'
)?.probeExecutable
).toBeUndefined()
})
})