Files
archived-orca/src/main/runtime/runtime-local-worktree-create.test.ts
T
Neil f5a4a7218a fix(worktrees): use a typed workspace name as its branch again (#35815)
#32919 gave typed workspace names a creature placeholder branch so
first-work naming could rename it. When generation fails or never runs,
users are left on branches like geoduck instead of the name they typed.
Typed names are valid branches in any script, so use them directly;
auto-rename keeps applying to Orca-generated creature names only.
2026-10-29 01:04:20 -07:00

728 lines
28 KiB
TypeScript

import type * as RuntimeWorktreeCreateGit from './runtime-worktree-create-git'
import {
generatedNameCreateRequest,
renameCreatedWorktreeOnFirstWork,
typedLabelCreateRequests
} from '../worktree-create-first-work-test-harness'
import { creatureNameTier } from '../../shared/worktree/retired-name-registry'
import { resolveWorkerWorktreeName } from './rpc/methods/orchestration/worker/worker-worktree-creation'
import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import { basename, resolve } from 'node:path'
import type { Repo } from '../../shared/repo-types'
import { getDefaultRepoHookSettings } from '../../shared/constants'
import type { AddWorktreeOptions } from '../git/worktree'
import {
acquireGitAdmission,
GitAdmissionScheduler,
_resetGitAdmissionForTests
} from '../git/command-runner/git-subprocess-admission'
const {
runtimeCreateMocks: mocks,
worktreePath,
pickedBranch,
writtenMeta,
readSparsePresets,
createWorktree,
resetRuntimeCreateMocks
} = await vi.hoisted(async () => await import('./runtime-local-worktree-create-test-harness'))
vi.mock('../text-generation/commit-message-text-generation', () => ({
resolveTextGenerationParams: () => ({
ok: true,
params: { agentId: 'claude', model: 'fixture' }
}),
generateBranchNameFromContext: async () => ({ success: true, slug: 'fix-auth' })
}))
vi.mock('../text-generation/commit-message-agent-environment', () => ({
prepareLocalCommitMessageAgentEnv: async () => ({ ok: true })
}))
vi.mock('../git/runner', () => ({ gitExecFileAsync: mocks.git }))
vi.mock('../project-runtime-git-options', () => ({
getLocalProjectGitExecOptions: () => ({ cwd: '/repo', ...mocks.routing() }),
getLocalProjectWorktreeGitOptions: mocks.routing,
getWorktreeMirrorDistro: () => undefined
}))
vi.mock('../git/repo', () => ({
getBaseRefDefault: mocks.defaultBase,
resolveDefaultBaseRefWithLocalGit: mocks.defaultBase,
getBranchConflictKind: mocks.branchConflict
}))
vi.mock('../git/git-username', () => ({ resolveLocalGitUsername: async () => '' }))
vi.mock('../hooks', () => ({ getEffectiveHooks: mocks.effectiveHooks }))
vi.mock('../git/worktree-base-ref-probe', () => ({ hasLocalWorktreeBaseRef: mocks.hasBase }))
vi.mock('./runtime-worktree-create-git', () => ({
resolveCreateBranchName: mocks.branchName,
canCheckoutExistingLocalBranch: mocks.canCheckout,
getLocalGitHubPrForBranch: mocks.githubPr,
getSelectedHostedReviewForBranch: vi.fn()
}))
vi.mock('./runtime-worktree-filesystem', () => ({ runtimePathExists: mocks.pathExists }))
vi.mock('../worktree-create-preparation', () => ({ consumePreparedWorktreeCreate: mocks.consume }))
vi.mock('../git/worktree', () => ({ addWorktree: mocks.add, addSparseWorktree: mocks.addSparse }))
vi.mock('../ipc/worktree-remote', () => ({ configureCreatedWorktreePushTarget: mocks.pushTarget }))
vi.mock('../ipc/created-worktree-reconciliation', () => ({ resolveCreatedWorktree: mocks.listing }))
vi.mock('../worktree-name-retirement', () => ({
failedWorktreeCreationNeedsRetirement: vi.fn(),
retireGeneratedWorktreeName: vi.fn()
}))
vi.mock('../git/worktree-shared-directories', () => ({
resolveWorktreeSharedDirectories: mocks.resolveShared
}))
vi.mock('../git/worktree-include-file', () => ({
resolveWorktreeIncludePaths: mocks.resolveInclude
}))
vi.mock('../ipc/worktree-symlinks', () => ({
createWorktreeCopiedPaths: mocks.copyPaths,
createWorktreeLinkedPaths: vi.fn(),
createWorktreeSharedPaths: vi.fn()
}))
import { WorktreeCreateSetupChoiceRefusedError } from './worktree-create-setup-choice-refusal'
import type { PreparationRearmHolder } from '../worktree-create-preparation'
import { createWorktreeCreateTimingRecorder } from '../worktree-create-timing'
import { withoutInFlightWorktreeCreates } from '../worktree-create-in-flight'
beforeEach(resetRuntimeCreateMocks)
describe('runtime create listing hold', () => {
const rows = [{ path: worktreePath }]
it('holds the checkout during Git creation and releases it once metadata is saved', async () => {
mocks.consume.mockImplementation(async () => {
expect(withoutInFlightWorktreeCreates('repo-1', rows)).toEqual([])
return { status: 'hit', result: {}, rearm: mocks.rearm }
})
mocks.resolveShared.mockImplementation(async () => {
expect(withoutInFlightWorktreeCreates('repo-1', rows)).toBe(rows)
return []
})
await createWorktree()
expect(mocks.resolveShared).toHaveBeenCalledOnce()
})
it('releases the checkout when Git creation fails', async () => {
mocks.consume.mockRejectedValue(new Error('checkout failed'))
await expect(createWorktree()).rejects.toThrow('checkout failed')
expect(withoutInFlightWorktreeCreates('repo-1', rows)).toBe(rows)
})
})
describe('runtime concurrent creates on one name', () => {
const addedPaths = (): string[] => mocks.add.mock.calls.map((call) => String(call[1]))
beforeEach(() => {
mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm })
let reached = 0
let bothAdding: () => void = () => {}
const gate = new Promise<void>((resolveGate) => (bothAdding = resolveGate))
// Hold both creates inside Git's add, where neither checkout exists on disk yet.
mocks.add.mockImplementation(async () => {
if (++reached === 2) {
bothAdding()
}
await gate
return {}
})
})
it.each([
{ request: { name: 'app' }, second: 'app-2' },
{ request: { name: 'nautilus', nameWasGenerated: true }, second: null }
])('gives the second create of $request.name its next candidate', async ({ request, second }) => {
await Promise.all([createWorktree(request), createWorktree(request)])
// Claims are ordered, but each create resolves its path's realpath before Git's add, so on a
// loaded runner either create can reach add first. Check the names, not the call order.
const names = addedPaths().map((path) => basename(path))
expect(names.filter((name) => name === request.name)).toHaveLength(1)
const other = names.find((name) => name !== request.name) ?? ''
if (second) {
expect(other).toBe(second)
} else {
expect(creatureNameTier(other)).toBe(2)
}
// Both claims settled with their creates, so the name is free to check again.
mocks.add.mockResolvedValue({})
await createWorktree(request)
expect(basename(addedPaths()[2])).toBe(request.name)
})
it('releases the claim when the create fails', async () => {
mocks.add.mockRejectedValueOnce(new Error('add failed'))
await expect(createWorktree({ name: 'app' })).rejects.toThrow('add failed')
mocks.add.mockResolvedValue({})
await createWorktree({ name: 'app' })
expect(addedPaths().map((path) => basename(path))).toEqual(['app', 'app'])
})
})
describe('runtime nested-workspaces layout', () => {
const addedPath = (): string => String(mocks.add.mock.calls[0]?.[1])
it('honors the client choice over the host default', async () => {
mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm })
await createWorktree({ nestWorkspaces: true })
expect(addedPath()).toBe(resolve('/worktrees', 'repo', 'app'))
})
it('falls back to the host setting when the client sends none', async () => {
mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm })
await createWorktree({})
expect(addedPath()).toBe(worktreePath)
})
})
describe('runtime keep-local-main-up-to-date choice', () => {
const addRefreshArg = (): unknown => mocks.add.mock.calls[0]?.[4]
const addOptions = (): AddWorktreeOptions | undefined => mocks.add.mock.calls[0]?.[6]
beforeEach(() => {
mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm })
mocks.remoteBase.mockResolvedValue({
remote: 'origin',
branch: 'main',
ref: 'refs/remotes/origin/main',
base: 'origin/main'
})
})
it('refreshes local main when the client turned it on, over the host default', async () => {
await createWorktree({ refreshLocalBaseRefOnWorktreeCreate: true })
expect(mocks.consume).toHaveBeenCalledWith(
expect.objectContaining({ refreshLocalBaseRef: true })
)
expect(addRefreshArg()).toBe(true)
expect(addOptions()?.suggestLocalBaseRefUpdate).toBeUndefined()
})
it('suppresses the suggestion the client already dismissed', async () => {
await createWorktree({ localBaseRefSuggestionDismissed: true })
expect(addRefreshArg()).toBe(false)
expect(addOptions()?.suggestLocalBaseRefUpdate).toBeUndefined()
})
it('keeps the host setting and suggestion when the client sends neither', async () => {
await createWorktree({})
expect(addRefreshArg()).toBe(false)
expect(addOptions()?.suggestLocalBaseRefUpdate).toBe(true)
})
})
describe('runtime prepared-worktree replenishment', () => {
it('keeps a failed claim reserved through the normal-add fallback', async () => {
mocks.consume.mockResolvedValue({
status: 'miss',
reason: 'finalize_failed',
rearm: mocks.rearm
})
const rearm: PreparationRearmHolder = { fire: () => {} }
await createWorktree({}, rearm)
expect(mocks.add).toHaveBeenCalledOnce()
expect(mocks.rearm).not.toHaveBeenCalled()
rearm.fire()
expect(mocks.rearm).toHaveBeenCalledOnce()
})
it('keeps the failed claim release available when the fallback also fails', async () => {
mocks.consume.mockResolvedValue({
status: 'miss',
reason: 'prepare_failed',
rearm: mocks.rearm
})
mocks.add.mockRejectedValue(new Error('normal add failed'))
const rearm: PreparationRearmHolder = { fire: () => {} }
await expect(createWorktree({}, rearm)).rejects.toThrow('normal add failed')
expect(mocks.rearm).not.toHaveBeenCalled()
rearm.fire()
expect(mocks.rearm).toHaveBeenCalledOnce()
})
it('leaves the re-arm holder armed but unfired once probes and include copies finish', async () => {
const rearm: PreparationRearmHolder = { fire: () => {} }
let finishProbe!: (paths: string[]) => void
mocks.resolveShared.mockImplementation(
() =>
new Promise<string[]>((resolve) => {
finishProbe = resolve
})
)
let finishCopy!: (paths: string[]) => void
mocks.copyPaths.mockImplementation(
() =>
new Promise<string[]>((resolve) => {
finishCopy = resolve
})
)
const creation = createWorktree({}, rearm)
await vi.waitFor(() => expect(mocks.resolveShared).toHaveBeenCalledOnce())
expect(mocks.rearm).not.toHaveBeenCalled()
finishProbe([])
await vi.waitFor(() => expect(mocks.copyPaths).toHaveBeenCalledOnce())
expect(mocks.rearm).not.toHaveBeenCalled()
finishCopy([])
await creation
// The caller launches terminals before arming, so create must not fire it itself.
expect(mocks.rearm).not.toHaveBeenCalled()
rearm.fire()
expect(mocks.rearm).toHaveBeenCalledOnce()
})
it('arms the holder even when materialization fails', async () => {
mocks.copyPaths.mockRejectedValue(new Error('copy failed'))
const rearm: PreparationRearmHolder = { fire: () => {} }
await expect(createWorktree({}, rearm)).rejects.toThrow('copy failed')
// The slot was consumed before the failure, so the caller's `finally` must find a real thunk.
rearm.fire()
expect(mocks.rearm).toHaveBeenCalledOnce()
})
})
describe('runtime create timing', () => {
it('times the add with the prepared-checkout consume inside it, and lists the worktrees', async () => {
mocks.listing.mockResolvedValue({
created: mocks.created,
worktrees: [mocks.created, mocks.created, mocks.created],
listingComplete: true
})
const timing = createWorktreeCreateTimingRecorder()
mocks.branchName.mockResolvedValue('main')
await createWorktree({ ...pickedBranch, branchIntent: undefined }, undefined, timing)
expect(mocks.consume).toHaveBeenCalledWith(
expect.objectContaining({ timing, branch: 'main', baseBranch: 'origin/main' })
)
expect(mocks.add).not.toHaveBeenCalled()
expect(mocks.consume.mock.calls[0][0].options).toEqual({})
const finished = timing.finish()
expect(finished.phases.map((phase) => phase.phase)).toEqual(
expect.arrayContaining([
'resolve_name',
'git_worktree_add',
'list_created_worktree',
'persist_metadata',
'copy_worktreeinclude'
])
)
expect(finished).toMatchObject({ executionHost: 'local', worktreeCount: 3 })
})
it('materializes remote reuse with tracking instead of consuming a prepared checkout', async () => {
mocks.branchName.mockResolvedValue('main')
mocks.remoteBase.mockResolvedValue({
remote: 'origin',
branch: 'main',
base: 'origin/main',
ref: 'refs/remotes/origin/main'
})
await createWorktree(pickedBranch)
expect(mocks.consume).not.toHaveBeenCalled()
expect(mocks.add).toHaveBeenCalledWith(
'/repo',
worktreePath,
'main',
'origin/main',
false,
false,
expect.objectContaining({ trackRemoteBranch: true })
)
expect(writtenMeta).toEqual(
expect.arrayContaining([expect.objectContaining({ preserveBranchOnDelete: true })])
)
})
it('records a sparse create as a miss without consulting the prepared checkout', async () => {
const timing = createWorktreeCreateTimingRecorder()
await createWorktree({ sparseCheckout: { directories: ['src'] } }, undefined, timing)
expect(mocks.consume).not.toHaveBeenCalled()
expect(timing.finish().preparedCheckout).toEqual({ status: 'miss', reason: 'sparse_checkout' })
})
})
describe('runtime create Git priority', () => {
it.each([undefined, 'Ubuntu'])(
'preserves interactive priority and routing on %s',
async (wslDistro) => {
const routing = wslDistro ? { wslDistro } : {}
mocks.routing.mockReturnValue(routing)
const options = routing
const target = { remoteName: 'origin', branchName: 'app' }
await createWorktree({ baseBranch: undefined, branchNameOverride: 'app', pushTarget: target })
expect(mocks.defaultBase).toHaveBeenCalledWith({ cwd: '/repo', ...options })
expect(mocks.branchName).toHaveBeenCalledWith(
'/repo',
'app',
'app',
expect.anything(),
'',
options
)
expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'main', options)
expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'main', options, undefined)
expect(mocks.githubPr).toHaveBeenCalledWith('/repo', 'app', routing)
expect(mocks.remoteBase).toHaveBeenCalledWith('/repo', 'main', options)
expect(mocks.hasBase).toHaveBeenCalledWith('/repo', 'main', options)
expect(mocks.consume).toHaveBeenCalledWith(expect.objectContaining({ options }))
expect(mocks.pushTarget).toHaveBeenCalledWith(worktreePath, 'app', target, options)
expect(mocks.listing).toHaveBeenCalledWith('/repo', worktreePath, 'app', options)
expect(mocks.resolveShared).toHaveBeenCalledWith('/repo', options)
expect(mocks.resolveInclude).toHaveBeenCalledWith('/repo', options)
}
)
it('creates through interactive headroom when regular Git capacity is occupied', async () => {
mocks.consume.mockResolvedValue({ status: 'miss', reason: 'none_armed' })
const scheduler = new GitAdmissionScheduler({ generalCap: 1, generalHeadroom: 1 })
_resetGitAdmissionForTests(scheduler)
const blocker = await acquireGitAdmission({ args: ['status'], cwd: '/repo' })
mocks.add.mockImplementation(
async (
_repo: string,
_path: string,
_branch: string,
_base: string,
_refresh: boolean,
_existing: boolean,
options?: AddWorktreeOptions
) => {
const grant = await acquireGitAdmission({
args: ['worktree', 'add'],
cwd: '/repo',
tier: options?.admissionTier,
signal: AbortSignal.timeout(200)
})
grant.release()
return {}
}
)
try {
await expect(createWorktree()).resolves.toHaveProperty('worktreePath', worktreePath)
expect(mocks.add).toHaveBeenCalledOnce()
} finally {
blocker.release()
_resetGitAdmissionForTests()
}
})
it.each([
['exactly its directories', ['packages/ui', 'apps/web'], 'preset-web'],
['an edited selection', ['apps/web'], undefined]
])('records the sparse preset only for %s', async (_case, directories, recorded) => {
writtenMeta.length = 0
await createWorktree({ sparseCheckout: { directories, presetId: 'preset-web' } })
expect(writtenMeta.find((meta) => meta.sparseDirectories)?.sparsePresetId).toBe(recorded)
})
it('still creates the worktree, with no sparse preset, when presets cannot be read', async () => {
writtenMeta.length = 0
readSparsePresets.mockImplementation(() => {
throw new Error('corrupt presets')
})
await createWorktree({
sparseCheckout: { directories: ['apps/web', 'packages/ui'], presetId: 'preset-web' }
})
const sparseMeta = writtenMeta.find((meta) => meta.sparseDirectories)
expect(sparseMeta?.sparseDirectories).toEqual(['apps/web', 'packages/ui'])
expect(sparseMeta?.sparsePresetId).toBeUndefined()
})
it('preserves priority for sparse creates and remote base refreshes', async () => {
const base = {
remote: 'origin',
branch: 'main',
ref: 'refs/remotes/origin/main',
base: 'origin/main'
}
mocks.remoteBase.mockResolvedValue(base)
await createWorktree({ baseBranch: 'origin/main', sparseCheckout: { directories: ['src'] } })
const options = {}
expect(mocks.hasRemoteRef).toHaveBeenCalledWith('/repo', base, options)
expect(mocks.refresh).toHaveBeenCalledWith('/repo', base, options)
expect(mocks.addSparse).toHaveBeenCalledWith(
'/repo',
worktreePath,
'app',
['src'],
'origin/main',
false,
expect.objectContaining(options)
)
expect(mocks.consume).not.toHaveBeenCalled()
})
})
describe('runtime create base without a tracking ref', () => {
const originMain = {
remote: 'origin',
branch: 'main',
ref: 'refs/remotes/origin/main',
base: 'origin/main'
}
beforeEach(() => {
mocks.remoteBase.mockResolvedValue(originMain)
mocks.hasRemoteRef.mockResolvedValue(false)
// Only the local branch the remote names exists; `origin/main` itself does not resolve.
mocks.hasBase.mockImplementation(async (_repo: string, ref: string) => ref === 'main')
})
it('fetches the remote base first and creates from it when the fetch works', async () => {
mocks.refresh.mockImplementation(async () => {
mocks.hasRemoteRef.mockResolvedValue(true)
return { ok: true }
})
const result = await createWorktree({ baseBranch: 'origin/main' })
expect(mocks.refresh).toHaveBeenCalledOnce()
expect(mocks.consume).toHaveBeenCalledWith(
expect.objectContaining({
baseBranch: 'origin/main',
options: expect.objectContaining({ remoteTrackingBase: originMain })
})
)
expect(result).not.toHaveProperty('baseFallback')
expect(result.worktree.baseRef).toBe('refs/remotes/origin/main')
})
it('names the workspace only after the fetch has settled', async () => {
let refreshSettled = false
mocks.refresh.mockImplementation(async () => {
await Promise.resolve()
mocks.hasRemoteRef.mockResolvedValue(true)
refreshSettled = true
return { ok: true }
})
const settledAtNaming: boolean[] = []
mocks.canCheckout.mockImplementation(async () => {
settledAtNaming.push(refreshSettled)
return false
})
await createWorktree({ baseBranch: 'origin/main', branchNameOverride: 'app' })
expect(settledAtNaming).toEqual([true])
expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'origin/main', {})
expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'origin/main', {}, undefined)
})
it('keeps the not-found error when the fetch works but the tracking ref is still missing', async () => {
mocks.hasBase.mockResolvedValue(false)
mocks.refresh.mockResolvedValue({ ok: true })
await expect(createWorktree({ baseBranch: 'origin/main' })).rejects.toThrow(
'Base ref "origin/main" was not found after fetching.'
)
expect(mocks.consume).not.toHaveBeenCalled()
})
it('creates from the local branch and reports it when the fetch fails', async () => {
mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' })
const result = await createWorktree({ baseBranch: 'origin/main', allowLocalBaseFallback: true })
expect(mocks.consume).toHaveBeenCalledWith(
expect.objectContaining({
baseBranch: 'main',
options: expect.not.objectContaining({ remoteTrackingBase: expect.anything() })
})
)
expect(result.baseFallback).toEqual({ requestedRef: 'origin/main', localRef: 'main' })
expect(result.addResult).not.toHaveProperty('baseFallback')
expect(result.worktree.baseRef).toBe('main')
})
it('decides the base before branch reuse and conflict checks', async () => {
mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' })
await createWorktree({
baseBranch: 'origin/main',
branchNameOverride: 'app',
allowLocalBaseFallback: true
})
expect(mocks.refresh.mock.invocationCallOrder[0]).toBeLessThan(
mocks.canCheckout.mock.invocationCallOrder[0]
)
expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'main', {})
expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'main', {}, undefined)
})
it("keeps the network error when the fetch fails and there's no local branch", async () => {
mocks.hasBase.mockResolvedValue(false)
mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' })
await expect(
createWorktree({ baseBranch: 'origin/main', allowLocalBaseFallback: true })
).rejects.toThrow(
'Could not refresh base ref "origin/main" from "origin". Check your network and try again.'
)
expect(mocks.branchName).not.toHaveBeenCalled()
expect(mocks.consume).not.toHaveBeenCalled()
})
it('keeps the network error for a create that did not opt into the fallback', async () => {
mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' })
await expect(createWorktree({ baseBranch: 'origin/main' })).rejects.toThrow(
'Could not refresh base ref "origin/main" from "origin". Check your network and try again.'
)
expect(mocks.consume).not.toHaveBeenCalled()
})
it('uses a local ref of the requested name without fetching or reporting a fallback', async () => {
mocks.hasBase.mockResolvedValue(true)
const result = await createWorktree({ baseBranch: 'origin/main' })
expect(mocks.refresh).not.toHaveBeenCalled()
expect(mocks.consume).toHaveBeenCalledWith(
expect.objectContaining({ baseBranch: 'origin/main' })
)
expect(result).not.toHaveProperty('baseFallback')
})
})
describe('runtime create setup decision', () => {
const askRepo: Partial<Repo> = {
hookSettings: { ...getDefaultRepoHookSettings(), setupRunPolicy: 'ask' }
}
beforeEach(() => {
mocks.effectiveHooks.mockReturnValue({ scripts: { setup: 'pnpm install' } })
})
it('refuses an ask repo with no decision before any git work', async () => {
const timing = createWorktreeCreateTimingRecorder()
// No requested base, so a create that got past the check would resolve the default base.
const request = { baseBranch: undefined }
const refusal = await createWorktree(request, undefined, timing, askRepo).catch(
(error: unknown) => error
)
expect(refusal).toBeInstanceOf(WorktreeCreateSetupChoiceRefusedError)
expect(refusal).toMatchObject({ message: 'Setup decision required for this repository' })
// Hooks come from the main checkout (no worktree path): the new worktree doesn't exist yet.
expect(mocks.effectiveHooks.mock.calls).toEqual([[expect.objectContaining({ path: '/repo' })]])
for (const gitWork of [mocks.defaultBase, mocks.remoteBase, mocks.hasBase, mocks.refresh]) {
expect(gitWork).not.toHaveBeenCalled()
}
expect(mocks.fetch).not.toHaveBeenCalled()
expect(mocks.branchName).not.toHaveBeenCalled()
expect(mocks.consume).not.toHaveBeenCalled()
expect(mocks.add).not.toHaveBeenCalled()
// The refusal's failure telemetry still says where the create ran.
expect(timing.finish().executionHost).toBe('local')
})
it.each([
['an explicit decision', { setupDecision: 'skip' as const }],
['runHooks', { runHooks: true }]
])('creates an ask repo once the request carries %s', async (_label, request) => {
await createWorktree(request, undefined, undefined, askRepo)
expect(mocks.consume).toHaveBeenCalledOnce()
})
})
describe('runtime worktree naming through first work', () => {
let actual: typeof RuntimeWorktreeCreateGit
// Load the real module graph before any test timeout starts.
beforeAll(async () => {
actual = await vi.importActual<typeof RuntimeWorktreeCreateGit>('./runtime-worktree-create-git')
})
function useRealBranchSelection() {
mocks.branchName.mockImplementation(actual.resolveCreateBranchName)
mocks.listing.mockImplementation(async (_repoPath, path, branch) => ({
created: { ...mocks.created, path, branch: `refs/heads/${branch}` }
}))
}
it.each(typedLabelCreateRequests)(
'keeps typed label $name as its branch through first work',
async (request) => {
useRealBranchSelection()
const { worktree } = await createWorktree(request, undefined, undefined, {}, true)
const expected = {
branch: `refs/heads/${request.name}`,
displayName: request.name,
displayNameMode: 'fixed'
}
expect(worktree).toMatchObject(expected)
const afterWork = await renameCreatedWorktreeOnFirstWork(worktree, writtenMeta[0], mocks.git)
expect(afterWork).toMatchObject(expected)
}
)
it('renames a generated creature branch on first work', async () => {
useRealBranchSelection()
const { worktree } = await createWorktree(
generatedNameCreateRequest,
undefined,
undefined,
{},
true
)
expect(worktree).toMatchObject({ branch: 'refs/heads/nautilus', displayNameMode: 'automatic' })
const renamed = await renameCreatedWorktreeOnFirstWork(worktree, writtenMeta[0], mocks.git)
expect(renamed).toMatchObject({
branch: 'refs/heads/fix-auth',
displayName: 'Fix auth',
displayNameMode: 'fixed'
})
})
it('renames the workspace a nameless orchestration worker creates on its first work', async () => {
useRealBranchSelection()
const request = await resolveWorkerWorktreeName(
{
listManagedWorktrees: async () => ({ worktrees: [] }),
listRetiredWorktreeNames: async () => ({
retiredNamesByRepo: {},
retiredNameTiersByRepo: {}
})
},
'repo-1',
undefined
)
const { worktree } = await createWorktree(request, undefined, undefined, {}, true)
expect(writtenMeta[0]).toMatchObject({ orcaCreationSource: 'runtime' })
const renamed = await renameCreatedWorktreeOnFirstWork(worktree, writtenMeta[0], mocks.git)
expect(renamed).toMatchObject({ branch: 'refs/heads/fix-auth', displayName: 'Fix auth' })
})
it.each([
{
request: { name: 'typed-label', branchNameOverride: 'feature/exact' },
enabled: true,
branch: 'feature/exact'
},
{
request: {
name: 'cli-exact',
cliProvenance: { kind: 'created-by-cli' as const, createdAt: 1 }
},
enabled: true,
branch: 'cli-exact'
}
])(
'preserves branch choice $branch (automatic=$enabled)',
async ({ request, enabled, branch }) => {
useRealBranchSelection()
const { worktree } = await createWorktree(request, undefined, undefined, {}, enabled)
expect(worktree).toMatchObject({
branch: `refs/heads/${branch}`,
displayName: request.name,
displayNameMode: 'fixed'
})
}
)
})