mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 19:34:29 +00:00
test: remove 131 low-value renderer store tests (#37648)
This commit is contained in:
@@ -498,7 +498,6 @@
|
||||
1 test-no-real-time-wait:src/renderer/src/lib/orca-yaml-trust-prompt-slot-eviction.test.ts
|
||||
1 test-no-real-time-wait:src/renderer/src/store/slices/github-pr-checks-fetch.test.ts
|
||||
2 test-no-real-time-wait:src/renderer/src/store/slices/workspace-cleanup-removal-preflight.test.ts
|
||||
2 test-no-real-time-wait:src/renderer/src/store/slices/worktrees-hydration-purge.test.ts
|
||||
1 test-no-real-time-wait:src/renderer/src/store/terminals/legacy-relay-bridged-tab-close.test.ts
|
||||
2 test-no-real-time-wait:src/shared/__tests__/process-host/windows-tree-kill-late-taskkill.win32.test.ts
|
||||
3 test-no-real-time-wait:src/shared/darwin-process-table-capture.test.ts
|
||||
|
||||
@@ -11472,11 +11472,7 @@
|
||||
"src/renderer/src/store/slices/worktrees/host-scoped-row-merges.test.ts": 1805,
|
||||
"src/renderer/src/store/slices/worktrees/listing/detected-worktree-meta.test.ts": 318,
|
||||
"src/renderer/src/store/slices/worktrees/listing/stale-listing-purges-created-worktree.test.ts": 1828,
|
||||
"src/renderer/src/store/slices/worktrees/listing/worktree-host-ownership-repo-host.test.ts": 289,
|
||||
"src/renderer/src/store/slices/worktrees/listing/worktree-host-ownership-unstamped.test.ts": 112,
|
||||
"src/renderer/src/store/slices/worktrees/listing/worktree-sort-order-patch.test.ts": 106,
|
||||
"src/renderer/src/store/slices/worktrees/metadata/worktree-meta-persist.test.ts": 361,
|
||||
"src/renderer/src/store/slices/worktrees/session/worktree-identity-rename-main-agreement.test.ts": 1677,
|
||||
"src/renderer/src/store/slices/worktrees/session/worktree-no-op-notifications.test.ts": 1129,
|
||||
"src/renderer/src/store/slices/worktrees/teardown/host-qualified-removal-refusal.test.ts": 518,
|
||||
"src/renderer/src/store/slices/worktrees/teardown/remove-worktree-shared-records.test.ts": 2086,
|
||||
|
||||
@@ -9,10 +9,9 @@ import { makeDetectedResult, qualifyDetectedResult } from './worktrees-detected-
|
||||
import { purgeHydratedWorktrees } from './worktrees/listing/hydrated-worktree-purge'
|
||||
import { worktreeCatalogVersionKey } from './worktrees/listing/worktree-catalog-version-state'
|
||||
import { makeTab } from './store-session-test-harness'
|
||||
import { makeFolderWorkspace, makeLineage, makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import { makeFolderWorkspace, makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import {
|
||||
createTestStore,
|
||||
listKnownForExecutionHostMock,
|
||||
mockApi,
|
||||
resetRemoteRuntimeMocks,
|
||||
resetWorktreeSliceModuleMemory,
|
||||
@@ -165,121 +164,6 @@ describe('fetchAllWorktrees hydration-time purge (design §4.4)', () => {
|
||||
expect(store.getState().unifiedTabsByWorktree[moved]).toEqual([chat])
|
||||
})
|
||||
|
||||
it.each([false, true])(
|
||||
'hydrates connecting SSH worktrees with hydration purge completed=%s',
|
||||
async (hasHydratedWorktreePurge) => {
|
||||
const store = createTestStore()
|
||||
const sshRepo = {
|
||||
id: 'repo-ssh',
|
||||
path: '/home/orca/repo',
|
||||
displayName: 'SSH Repo',
|
||||
badgeColor: '#000',
|
||||
addedAt: 0,
|
||||
connectionId: 'ssh-1'
|
||||
}
|
||||
const queued = makeWorktree({
|
||||
id: 'repo-ssh::/home/orca/queued',
|
||||
repoId: 'repo-ssh',
|
||||
path: '/home/orca/queued',
|
||||
displayName: 'queued'
|
||||
})
|
||||
listKnownForExecutionHostMock.mockResolvedValueOnce({
|
||||
status: 'complete',
|
||||
repoId: sshRepo.id,
|
||||
executionHostId: 'ssh:ssh-1',
|
||||
result: makeDetectedResult(sshRepo.id, [queued], {
|
||||
authoritative: false,
|
||||
source: 'metadata-fallback'
|
||||
})
|
||||
})
|
||||
store.setState({
|
||||
repos: [sshRepo],
|
||||
hasHydratedWorktreePurge,
|
||||
sshConnectionStates: new Map([
|
||||
[
|
||||
'ssh-1',
|
||||
{
|
||||
targetId: 'ssh-1',
|
||||
status: 'connecting',
|
||||
error: null,
|
||||
reconnectAttempt: 0,
|
||||
providerEpoch: null
|
||||
}
|
||||
]
|
||||
])
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
expect(store.getState().worktreesByRepo[sshRepo.id]).toEqual([
|
||||
{ ...queued, hostId: 'ssh:ssh-1' }
|
||||
])
|
||||
expect(listKnownForExecutionHostMock).toHaveBeenCalledWith({
|
||||
repoId: sshRepo.id,
|
||||
executionHostId: 'ssh:ssh-1'
|
||||
})
|
||||
expect(mockApi.worktrees.listDetected).not.toHaveBeenCalled()
|
||||
}
|
||||
)
|
||||
|
||||
it('preserves resolved inline legacy lineage when side-map hydration is absent', async () => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repoA::/a/parent',
|
||||
instanceId: 'parent-instance',
|
||||
repoId: 'repoA',
|
||||
path: '/a/parent'
|
||||
})
|
||||
const child = makeWorktree({
|
||||
id: 'repoA::/a/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repoA',
|
||||
path: '/a/child'
|
||||
})
|
||||
const lineage = makeLineage({
|
||||
worktreeId: child.id,
|
||||
worktreeInstanceId: child.instanceId!,
|
||||
parentWorktreeId: parent.id,
|
||||
parentWorktreeInstanceId: parent.instanceId!
|
||||
})
|
||||
const resolvedParent = {
|
||||
...parent,
|
||||
parentWorktreeId: null,
|
||||
childWorktreeIds: [child.id],
|
||||
lineage: null,
|
||||
workspaceLineage: null
|
||||
}
|
||||
const resolvedChild = {
|
||||
...child,
|
||||
parentWorktreeId: parent.id,
|
||||
childWorktreeIds: [],
|
||||
lineage,
|
||||
workspaceLineage: null
|
||||
}
|
||||
mockApi.worktrees.listDetected.mockResolvedValueOnce(
|
||||
makeDetectedResult('repoA', [resolvedParent, resolvedChild])
|
||||
)
|
||||
store.setState({
|
||||
repos: [repoA],
|
||||
hasHydratedWorktreePurge: true,
|
||||
worktreeLineageById: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
expect(store.getState().worktreeLineageById).toEqual({})
|
||||
expect(store.getState().worktreesByRepo.repoA).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
id: child.id,
|
||||
parentWorktreeId: parent.id,
|
||||
lineage,
|
||||
workspaceLineage: null
|
||||
})
|
||||
])
|
||||
)
|
||||
})
|
||||
|
||||
it('defers the purge when a sibling repo fetch fails (F1 regression)', async () => {
|
||||
const store = createTestStore()
|
||||
const wtA = makeWorktree({ id: 'repoA::/a/wt1', repoId: 'repoA', path: '/a/wt1' })
|
||||
@@ -404,38 +288,6 @@ describe('fetchAllWorktrees hydration-time purge (design §4.4)', () => {
|
||||
expect(store.getState().tabsByWorktree['repoA::/a/new-zombie']).toBeDefined()
|
||||
})
|
||||
|
||||
it('can defer the first successful purge during local-only startup refresh', async () => {
|
||||
const store = createTestStore()
|
||||
const wtA = makeWorktree({ id: 'repoA::/a/wt1', repoId: 'repoA', path: '/a/wt1' })
|
||||
const wtB = makeWorktree({ id: 'repoB::/b/wt1', repoId: 'repoB', path: '/b/wt1' })
|
||||
|
||||
worktreeListMock.mockImplementation(async ({ repoId }: { repoId: string }) =>
|
||||
repoId === 'repoA' ? [wtA] : [wtB]
|
||||
)
|
||||
|
||||
store.setState({
|
||||
repos: [repoA, repoB],
|
||||
tabsByWorktree: {
|
||||
'repoA::/a/wt1': [{ id: 'tab-A', worktreeId: 'repoA::/a/wt1' }],
|
||||
'repoA::/a/zombie': [{ id: 'tab-zombie', worktreeId: 'repoA::/a/zombie' }],
|
||||
'repoB::/b/wt1': [{ id: 'tab-B', worktreeId: 'repoB::/b/wt1' }]
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees({ hydrationPurge: 'defer' })
|
||||
|
||||
expect(store.getState().hasHydratedWorktreePurge).toBe(false)
|
||||
expect(store.getState().tabsByWorktree['repoA::/a/zombie']).toBeDefined()
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
expect(store.getState().hasHydratedWorktreePurge).toBe(true)
|
||||
expect(store.getState().tabsByWorktree).toEqual({
|
||||
'repoA::/a/wt1': [{ id: 'tab-A', worktreeId: 'repoA::/a/wt1' }],
|
||||
'repoB::/b/wt1': [{ id: 'tab-B', worktreeId: 'repoB::/b/wt1' }]
|
||||
})
|
||||
})
|
||||
|
||||
it('does not consume the one-shot purge before clean workspace session hydration', async () => {
|
||||
const store = createTestStore()
|
||||
const wtA = makeWorktree({ id: 'repoA::/a/wt1', repoId: 'repoA', path: '/a/wt1' })
|
||||
@@ -477,51 +329,6 @@ describe('fetchAllWorktrees hydration-time purge (design §4.4)', () => {
|
||||
})
|
||||
})
|
||||
|
||||
// Why: multi-host regression — after hydration a mid-session fetch must never purge, even if a host reports zero worktrees.
|
||||
it('does not purge another host tab state when hasHydratedWorktreePurge is already true and a host reports zero worktrees', async () => {
|
||||
const store = createTestStore()
|
||||
const wtA = makeWorktree({ id: 'repoA::/a/wt1', repoId: 'repoA', path: '/a/wt1' })
|
||||
|
||||
// repoB reports zero worktrees this round (host briefly empty), repoA fine.
|
||||
worktreeListMock.mockImplementation(async ({ repoId }: { repoId: string }) =>
|
||||
repoId === 'repoA' ? [wtA] : []
|
||||
)
|
||||
|
||||
store.setState({
|
||||
hasHydratedWorktreePurge: true,
|
||||
repos: [repoA, repoB],
|
||||
tabsByWorktree: {
|
||||
'repoB::/b/wt1': [{ id: 'tab-B', worktreeId: 'repoB::/b/wt1' }]
|
||||
},
|
||||
ptyIdsByTabId: { 'tab-B': ['remote:env-b@@terminal-b'] },
|
||||
terminalLayoutsByTabId: {
|
||||
'tab-B': {
|
||||
root: null,
|
||||
activeLeafId: null,
|
||||
expandedLeafId: null,
|
||||
ptyIdsByLeafId: { 'pane:1': 'remote:env-b@@terminal-b' }
|
||||
}
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
// The zero-worktree host's live tab/terminal state is untouched.
|
||||
expect(store.getState().tabsByWorktree).toEqual({
|
||||
'repoB::/b/wt1': [{ id: 'tab-B', worktreeId: 'repoB::/b/wt1' }]
|
||||
})
|
||||
expect(store.getState().ptyIdsByTabId).toEqual({ 'tab-B': ['remote:env-b@@terminal-b'] })
|
||||
expect(store.getState().terminalLayoutsByTabId).toEqual({
|
||||
'tab-B': {
|
||||
root: null,
|
||||
activeLeafId: null,
|
||||
expandedLeafId: null,
|
||||
ptyIdsByLeafId: { 'pane:1': 'remote:env-b@@terminal-b' }
|
||||
}
|
||||
})
|
||||
expect(store.getState().hasHydratedWorktreePurge).toBe(true)
|
||||
})
|
||||
|
||||
it('preserves sibling host worktrees during hydrated refresh when repo ids are duplicated', async () => {
|
||||
const store = createTestStore()
|
||||
const localRepo = {
|
||||
@@ -614,67 +421,6 @@ describe('fetchAllWorktrees hydration-time purge (design §4.4)', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('bounds concurrent repo scans during hydration-time refresh', async () => {
|
||||
const store = createTestStore()
|
||||
const repos = Array.from({ length: WORKTREE_REFRESH_CONCURRENCY + 2 }, (_, index) => ({
|
||||
id: `repo-${index}`,
|
||||
path: `/repos/${index}`,
|
||||
displayName: `repo-${index}`,
|
||||
badgeColor: '#000',
|
||||
addedAt: 0
|
||||
}))
|
||||
let activeScans = 0
|
||||
let maxActiveScans = 0
|
||||
|
||||
worktreeListMock.mockImplementation(async ({ repoId }: { repoId: string }) => {
|
||||
activeScans += 1
|
||||
maxActiveScans = Math.max(maxActiveScans, activeScans)
|
||||
await new Promise((resolve) => setTimeout(resolve, 5))
|
||||
activeScans -= 1
|
||||
return [makeWorktree({ id: `${repoId}::/wt`, repoId, path: `/wt/${repoId}` })]
|
||||
})
|
||||
|
||||
store.setState({ repos } as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
expect(maxActiveScans).toBeLessThanOrEqual(WORKTREE_REFRESH_CONCURRENCY)
|
||||
expect(worktreeListMock).toHaveBeenCalledTimes(repos.length)
|
||||
expect(store.getState().hasHydratedWorktreePurge).toBe(true)
|
||||
})
|
||||
|
||||
it('bounds concurrent repo scans after the hydration purge has run', async () => {
|
||||
const store = createTestStore()
|
||||
const repos = Array.from({ length: WORKTREE_REFRESH_CONCURRENCY + 2 }, (_, index) => ({
|
||||
id: `repo-${index}`,
|
||||
path: `/repos/${index}`,
|
||||
displayName: `repo-${index}`,
|
||||
badgeColor: '#000',
|
||||
addedAt: 0
|
||||
}))
|
||||
let activeScans = 0
|
||||
let maxActiveScans = 0
|
||||
|
||||
worktreeListMock.mockImplementation(async ({ repoId }: { repoId: string }) => {
|
||||
activeScans += 1
|
||||
maxActiveScans = Math.max(maxActiveScans, activeScans)
|
||||
await new Promise((resolve) => setTimeout(resolve, 5))
|
||||
activeScans -= 1
|
||||
return [makeWorktree({ id: `${repoId}::/wt`, repoId, path: `/wt/${repoId}` })]
|
||||
})
|
||||
|
||||
store.setState({
|
||||
hasHydratedWorktreePurge: true,
|
||||
repos
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchAllWorktrees()
|
||||
|
||||
expect(maxActiveScans).toBeLessThanOrEqual(WORKTREE_REFRESH_CONCURRENCY)
|
||||
expect(worktreeListMock).toHaveBeenCalledTimes(repos.length)
|
||||
expect(store.getState().hasHydratedWorktreePurge).toBe(true)
|
||||
})
|
||||
|
||||
it('reuses an offline runtime preflight across hydrated all-worktree refresh repos', async () => {
|
||||
const store = createTestStore()
|
||||
const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
@@ -717,58 +463,6 @@ describe('fetchAllWorktrees hydration-time purge (design §4.4)', () => {
|
||||
expect(mockApi.worktrees.listDetected).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('does not coalesce a foreground re-probe onto a background reuse:true scan for a remote repo', async () => {
|
||||
// Why: reuse is part of the coalescing key, so a foreground reuse:false scan must re-probe, not reuse a stale background failure.
|
||||
const store = createTestStore()
|
||||
const remote = makeWorktree({ id: 'repo1::/remote/wt', repoId: 'repo1', path: '/remote/wt' })
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
hasHydratedWorktreePurge: true,
|
||||
repos: [
|
||||
{
|
||||
id: 'repo1',
|
||||
path: '/r1',
|
||||
displayName: 'R1',
|
||||
badgeColor: '#000',
|
||||
addedAt: 0,
|
||||
executionHostId: 'runtime:env-1'
|
||||
}
|
||||
]
|
||||
} as Partial<AppState>)
|
||||
|
||||
let scanStartedCount = 0
|
||||
const scanReleases: (() => void)[] = []
|
||||
runtimeEnvironmentCall.mockImplementation(({ method }: RuntimeEnvironmentCallRequest) => {
|
||||
if (method === 'worktree.detectedList') {
|
||||
scanStartedCount += 1
|
||||
return new Promise((resolve) => {
|
||||
scanReleases.push(() =>
|
||||
resolve({
|
||||
id: 'rpc',
|
||||
ok: true,
|
||||
result: makeDetectedResult('repo1', [remote]),
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
)
|
||||
})
|
||||
}
|
||||
return Promise.resolve({ id: method, ok: true, result: {}, _meta: {} })
|
||||
})
|
||||
|
||||
const background = store.getState().fetchAllWorktrees()
|
||||
const foreground = store.getState().fetchWorktrees('repo1')
|
||||
// Flush microtasks so both compat preflights settle and both scans block.
|
||||
await new Promise((resolve) => setTimeout(resolve, 0))
|
||||
|
||||
expect(scanStartedCount).toBe(2)
|
||||
|
||||
scanReleases.forEach((release) => release())
|
||||
await Promise.all([background, foreground])
|
||||
expect(store.getState().worktreesByRepo.repo1?.map((worktree) => worktree.id)).toEqual([
|
||||
remote.id
|
||||
])
|
||||
})
|
||||
|
||||
it('preserves floating workspace state while purging a real stale worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wtA = makeWorktree({ id: 'repoA::/a/wt1', repoId: 'repoA', path: '/a/wt1' })
|
||||
|
||||
@@ -6,11 +6,7 @@ import {
|
||||
hasDismissedHugeRepoWarning,
|
||||
markHugeRepoWarningDismissed
|
||||
} from '@/lib/source-control-huge-repo-warning-dismissals'
|
||||
import {
|
||||
getHostedReviewLinkMutationGenerationForTests,
|
||||
getHostedReviewLinkWorktreeAliasCountForTests,
|
||||
resetHostedReviewLinkMutationGenerationForTests
|
||||
} from './worktrees'
|
||||
import { resetHostedReviewLinkMutationGenerationForTests } from './worktrees'
|
||||
import { worktreeWorkspaceKey } from '../../../../shared/workspace-scope'
|
||||
import { makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import {
|
||||
@@ -205,92 +201,6 @@ describe('migrateWorktreeIdentity', () => {
|
||||
expect(s.terminalLayoutsByTabId.tab1).toBeDefined()
|
||||
})
|
||||
|
||||
it('is a no-op when the ids match', () => {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
activeWorktreeId: OLD,
|
||||
tabsByWorktree: { [OLD]: [{ id: 'tab1' }] }
|
||||
} as unknown as Partial<AppState>)
|
||||
store.getState().migrateWorktreeIdentity(OLD, OLD)
|
||||
expect(store.getState().tabsByWorktree[OLD]).toEqual([{ id: 'tab1' }])
|
||||
expect(store.getState().activeWorktreeId).toBe(OLD)
|
||||
})
|
||||
|
||||
it('leaves an unrelated active worktree pointer alone', () => {
|
||||
const store = createTestStore()
|
||||
const OTHER = 'repo1::/ws/other'
|
||||
store.setState({
|
||||
activeWorktreeId: OTHER,
|
||||
tabsByWorktree: { [OLD]: [{ id: 'tab1' }] }
|
||||
} as unknown as Partial<AppState>)
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
expect(store.getState().activeWorktreeId).toBe(OTHER)
|
||||
expect(store.getState().tabsByWorktree[NEW]).toEqual([{ id: 'tab1' }])
|
||||
})
|
||||
|
||||
it('does not track hosted review aliases for migrations without hosted-review bookkeeping', () => {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
tabsByWorktree: { [OLD]: [{ id: 'tab1' }] }
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
|
||||
expect(getHostedReviewLinkWorktreeAliasCountForTests()).toBe(0)
|
||||
})
|
||||
|
||||
it('re-keys hosted review link generation and clear tombstones', async () => {
|
||||
const store = createTestStore()
|
||||
const oldWorktree = makeWorktree({
|
||||
id: OLD,
|
||||
repoId: 'repo1',
|
||||
path: '/ws/cunner',
|
||||
branch: 'refs/heads/stack/one',
|
||||
linkedPR: 101,
|
||||
pushTarget: { remoteName: 'fork', branchName: 'old/review-head' }
|
||||
})
|
||||
|
||||
store.setState({ worktreesByRepo: { repo1: [oldWorktree] } } as Partial<AppState>)
|
||||
store.getState().updateWorktreeGitIdentity(OLD, { branch: 'refs/heads/stack/two' }, null)
|
||||
await vi.waitFor(() => {
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(OLD)).toBe(0)
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: OLD,
|
||||
updates: {
|
||||
linkedPR: null,
|
||||
linkedGitLabMR: null,
|
||||
linkedBitbucketPR: null,
|
||||
linkedAzureDevOpsPR: null,
|
||||
linkedGiteaPR: null,
|
||||
pushTarget: undefined
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
const switched = store.getState().worktreesByRepo.repo1[0]
|
||||
store.setState({ worktreesByRepo: { repo1: [{ ...switched, id: NEW }] } } as Partial<AppState>)
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
worktreeListMock.mockResolvedValue([
|
||||
{
|
||||
...switched,
|
||||
id: NEW,
|
||||
path: '/ws/worktree-creation-spinner',
|
||||
linkedPR: 101,
|
||||
pushTarget: { remoteName: 'fork', branchName: 'old/review-head' }
|
||||
}
|
||||
])
|
||||
|
||||
await store.getState().fetchWorktrees('repo1')
|
||||
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(OLD)).toBe(0)
|
||||
expect(store.getState().worktreesByRepo.repo1[0]).toMatchObject({
|
||||
id: NEW,
|
||||
branch: 'refs/heads/stack/two',
|
||||
linkedPR: null,
|
||||
pushTarget: undefined
|
||||
})
|
||||
})
|
||||
|
||||
it('sanitizes lagging old-id worktree refresh rows after hosted review bookkeeping migrates', async () => {
|
||||
const store = createTestStore()
|
||||
const oldWorktree = makeWorktree({
|
||||
@@ -341,76 +251,6 @@ describe('migrateWorktreeIdentity', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('prunes hosted review aliases when manual hosted-review updates supersede a migrated clear', async () => {
|
||||
const store = createTestStore()
|
||||
const oldWorktree = makeWorktree({
|
||||
id: OLD,
|
||||
repoId: 'repo1',
|
||||
path: '/ws/cunner',
|
||||
branch: 'refs/heads/stack/one',
|
||||
linkedPR: 101
|
||||
})
|
||||
|
||||
store.setState({ worktreesByRepo: { repo1: [oldWorktree] } } as Partial<AppState>)
|
||||
store.getState().updateWorktreeGitIdentity(OLD, { branch: 'refs/heads/stack/two' }, null)
|
||||
await vi.waitFor(() => {
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: OLD,
|
||||
updates: expect.objectContaining({ linkedPR: null })
|
||||
})
|
||||
})
|
||||
const switched = store.getState().worktreesByRepo.repo1[0]
|
||||
store.setState({ worktreesByRepo: { repo1: [{ ...switched, id: NEW }] } } as Partial<AppState>)
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
expect(getHostedReviewLinkWorktreeAliasCountForTests()).toBeGreaterThan(0)
|
||||
|
||||
await store.getState().updateWorktreeMeta(NEW, { linkedPR: 202 })
|
||||
|
||||
expect(getHostedReviewLinkWorktreeAliasCountForTests()).toBe(0)
|
||||
})
|
||||
|
||||
it('persists a queued branch-switch clear after worktree id migration', async () => {
|
||||
const store = createTestStore()
|
||||
const oldWorktree = makeWorktree({
|
||||
id: OLD,
|
||||
repoId: 'repo1',
|
||||
path: '/ws/cunner',
|
||||
branch: 'refs/heads/stack/one',
|
||||
linkedPR: 101,
|
||||
pushTarget: { remoteName: 'fork', branchName: 'old/review-head' }
|
||||
})
|
||||
|
||||
store.setState({ worktreesByRepo: { repo1: [oldWorktree] } } as Partial<AppState>)
|
||||
store.getState().updateWorktreeGitIdentity(OLD, { branch: 'refs/heads/stack/two' }, null)
|
||||
const switched = store.getState().worktreesByRepo.repo1[0]
|
||||
store.setState({
|
||||
worktreesByRepo: {
|
||||
repo1: [
|
||||
{
|
||||
...switched,
|
||||
id: NEW,
|
||||
path: '/ws/worktree-creation-spinner'
|
||||
}
|
||||
]
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
|
||||
await vi.waitFor(() => {
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: NEW,
|
||||
updates: {
|
||||
linkedPR: null,
|
||||
linkedGitLabMR: null,
|
||||
linkedBitbucketPR: null,
|
||||
linkedAzureDevOpsPR: null,
|
||||
linkedGiteaPR: null,
|
||||
pushTarget: undefined
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('persists a queued branch-switch clear when migration happens during the old-id write', async () => {
|
||||
const store = createTestStore()
|
||||
const oldWorktree = makeWorktree({
|
||||
|
||||
@@ -37,83 +37,6 @@ describe('worktree lineage state', () => {
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it('fetches persisted lineage into the renderer store', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({ [lineage.worktreeId]: lineage })
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
|
||||
expect(mockApi.worktrees.listLineage).toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().workspaceLineageByChildKey).toEqual({})
|
||||
})
|
||||
|
||||
it('fetches workspace lineage from the expanded local lineage response', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
const workspaceLineage = makeWorkspaceLineage()
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({
|
||||
lineage: { [lineage.worktreeId]: lineage },
|
||||
workspaceLineage: { [workspaceLineage.childWorkspaceKey]: workspaceLineage }
|
||||
})
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().workspaceLineageByChildKey).toEqual({
|
||||
[workspaceLineage.childWorkspaceKey]: workspaceLineage
|
||||
})
|
||||
})
|
||||
|
||||
it('keeps lineage map and entry identity across a cloned no-op refresh', async () => {
|
||||
const lineage = makeLineage({
|
||||
capture: { source: 'orchestration-context', confidence: 'explicit' },
|
||||
taskId: 'task-42',
|
||||
coordinatorHandle: 'coord-1'
|
||||
})
|
||||
const workspaceLineage = makeWorkspaceLineage({
|
||||
childWorkspaceKey: worktreeWorkspaceKey(lineage.worktreeId),
|
||||
parentWorkspaceKey: worktreeWorkspaceKey(lineage.parentWorktreeId),
|
||||
childInstanceId: lineage.worktreeInstanceId,
|
||||
parentInstanceId: lineage.parentWorktreeInstanceId,
|
||||
origin: lineage.origin,
|
||||
capture: lineage.capture,
|
||||
taskId: lineage.taskId,
|
||||
coordinatorHandle: lineage.coordinatorHandle,
|
||||
createdAt: lineage.createdAt
|
||||
})
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
const payload = {
|
||||
lineage: { [lineage.worktreeId]: lineage },
|
||||
workspaceLineage: { [workspaceLineage.childWorkspaceKey]: workspaceLineage }
|
||||
}
|
||||
mockApi.worktrees.listLineage.mockImplementation(async () => structuredClone(payload))
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
const afterFirst = store.getState()
|
||||
const lineageById = afterFirst.worktreeLineageById
|
||||
const workspaceByKey = afterFirst.workspaceLineageByChildKey
|
||||
const lineageEntry = lineageById[lineage.worktreeId]
|
||||
const workspaceEntry = workspaceByKey[workspaceLineage.childWorkspaceKey]
|
||||
expect(lineageEntry).toEqual(lineage)
|
||||
expect(lineageEntry).not.toBe(lineage)
|
||||
const subscriber = vi.fn()
|
||||
const unsubscribe = store.subscribe(subscriber)
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
unsubscribe()
|
||||
|
||||
expect(store.getState().worktreeLineageById).toBe(lineageById)
|
||||
expect(store.getState().workspaceLineageByChildKey).toBe(workspaceByKey)
|
||||
expect(store.getState().worktreeLineageById[lineage.worktreeId]).toBe(lineageEntry)
|
||||
expect(store.getState().workspaceLineageByChildKey[workspaceLineage.childWorkspaceKey]).toBe(
|
||||
workspaceEntry
|
||||
)
|
||||
expect(subscriber).not.toHaveBeenCalled()
|
||||
expect(mockApi.worktrees.listLineage).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
|
||||
it('preserves other-host lineage row identity across a cloned same-host refresh', async () => {
|
||||
const store = createTestStore()
|
||||
const localWorktree = makeWorktree({
|
||||
@@ -195,59 +118,6 @@ describe('worktree lineage state', () => {
|
||||
)
|
||||
})
|
||||
|
||||
it('clears workspace lineage on successful old-shape lineage refresh', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
const workspaceLineage = makeWorkspaceLineage()
|
||||
store.setState({
|
||||
workspaceLineageByChildKey: { [workspaceLineage.childWorkspaceKey]: workspaceLineage }
|
||||
} as Partial<AppState>)
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({ [lineage.worktreeId]: lineage })
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().workspaceLineageByChildKey).toEqual({})
|
||||
})
|
||||
|
||||
it('updates a child lineage entry and bumps sortEpoch', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
mockApi.worktrees.updateLineage.mockResolvedValue(lineage)
|
||||
store.setState({ sortEpoch: 3 } as Partial<AppState>)
|
||||
|
||||
await store.getState().updateWorktreeLineage(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
|
||||
expect(mockApi.worktrees.updateLineage).toHaveBeenCalledWith({
|
||||
worktreeId: lineage.worktreeId,
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().sortEpoch).toBe(4)
|
||||
})
|
||||
|
||||
it('removes child lineage entries when the backend clears the parent link', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
const workspaceLineage = makeWorkspaceLineage({
|
||||
childWorkspaceKey: worktreeWorkspaceKey(lineage.worktreeId)
|
||||
})
|
||||
mockApi.worktrees.updateLineage.mockResolvedValue(null)
|
||||
store.setState({
|
||||
worktreeLineageById: { [lineage.worktreeId]: lineage },
|
||||
workspaceLineageByChildKey: { [workspaceLineage.childWorkspaceKey]: workspaceLineage },
|
||||
sortEpoch: 3
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().updateWorktreeLineage(lineage.worktreeId, { noParent: true })
|
||||
|
||||
expect(store.getState().worktreeLineageById).toEqual({})
|
||||
expect(store.getState().workspaceLineageByChildKey).toEqual({})
|
||||
expect(store.getState().sortEpoch).toBe(4)
|
||||
})
|
||||
|
||||
it('clears inline local lineage immediately when an inline-only child is unnested', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
@@ -316,153 +186,6 @@ describe('worktree lineage state', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('refetches lineage and rethrows after an update failure', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
mockApi.worktrees.updateLineage.mockRejectedValueOnce(new Error('stale parent'))
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({ [lineage.worktreeId]: lineage })
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
|
||||
await expect(
|
||||
store.getState().updateWorktreeLineage(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
).rejects.toThrow('stale parent')
|
||||
|
||||
expect(mockApi.worktrees.listLineage).toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
})
|
||||
|
||||
it('refetches lineage and rethrows when explicit parent assignment fails', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
mockApi.worktrees.updateLineage.mockRejectedValueOnce(new Error('stale parent'))
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({ [lineage.worktreeId]: lineage })
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
|
||||
await expect(
|
||||
store.getState().assignWorktreeParent(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
).rejects.toThrow('stale parent')
|
||||
|
||||
expect(mockApi.worktrees.listLineage).toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
})
|
||||
|
||||
it('fetches raw lineage from the active remote runtime environment', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-lineage-list',
|
||||
ok: true,
|
||||
result: { lineage: { [lineage.worktreeId]: lineage } },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchWorktreeLineage()
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.lineageList',
|
||||
params: undefined,
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
expect(mockApi.worktrees.listLineage).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
})
|
||||
|
||||
it('pins lineage refresh to the event runtime when the default is local', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-lineage-list',
|
||||
ok: true,
|
||||
result: { lineage: { [lineage.worktreeId]: lineage } },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: null } as never,
|
||||
worktreesByRepo: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().fetchWorktreeLineage({ executionHostId: 'runtime:env-1' })
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.lineageList',
|
||||
params: undefined,
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
expect(mockApi.worktrees.listLineage).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('pins lineage refresh to the local host when forceLocalOwner is set', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: {}
|
||||
} as Partial<AppState>)
|
||||
mockApi.worktrees.listLineage.mockResolvedValue({ [lineage.worktreeId]: lineage })
|
||||
|
||||
await store.getState().fetchWorktreeLineage({ forceLocalOwner: true })
|
||||
|
||||
expect(mockApi.worktrees.listLineage).toHaveBeenCalledTimes(1)
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
})
|
||||
|
||||
it('updates lineage through the active remote runtime environment', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
const child = makeWorktree({
|
||||
id: lineage.worktreeId,
|
||||
repoId: 'repo1',
|
||||
path: '/remote/child',
|
||||
// Why: ingest stamps a server's rows; routing follows the stamp, not focus.
|
||||
hostId: 'runtime:env-1'
|
||||
})
|
||||
const updatedChild = { ...child, lineage }
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-set-lineage',
|
||||
ok: true,
|
||||
result: { worktree: updatedChild },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [child] },
|
||||
sortEpoch: 3
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().updateWorktreeLineage(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.set',
|
||||
params: {
|
||||
worktree: `id:${lineage.worktreeId}`,
|
||||
parentWorktree: `id:${lineage.parentWorktreeId}`
|
||||
},
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
expect(mockApi.worktrees.updateLineage).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().worktreesByRepo.repo1?.[0]).toEqual({
|
||||
...updatedChild,
|
||||
hostId: 'runtime:env-1',
|
||||
runtimeOwnerEnvironmentId: 'env-1'
|
||||
})
|
||||
expect(store.getState().sortEpoch).toBe(4)
|
||||
})
|
||||
|
||||
it('stamps the owning runtime host onto worktrees returned by a remote lineage update', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage({
|
||||
@@ -507,66 +230,6 @@ describe('worktree lineage state', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('assigns a parent through the active remote runtime environment and rethrows failures', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
const child = makeWorktree({
|
||||
id: lineage.worktreeId,
|
||||
repoId: 'repo1',
|
||||
path: '/remote/child',
|
||||
// Why: ingest stamps a server's rows; routing follows the stamp, not focus.
|
||||
hostId: 'runtime:env-1'
|
||||
})
|
||||
const updatedChild = { ...child, lineage }
|
||||
runtimeEnvironmentCall.mockResolvedValueOnce({
|
||||
id: 'rpc-assign-parent',
|
||||
ok: true,
|
||||
result: { worktree: updatedChild },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [child] },
|
||||
sortEpoch: 3
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().assignWorktreeParent(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.set',
|
||||
params: {
|
||||
worktree: `id:${lineage.worktreeId}`,
|
||||
parentWorktree: `id:${lineage.parentWorktreeId}`
|
||||
},
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
expect(mockApi.worktrees.updateLineage).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreeLineageById).toEqual({ [lineage.worktreeId]: lineage })
|
||||
expect(store.getState().worktreesByRepo.repo1?.[0]).toEqual({
|
||||
...updatedChild,
|
||||
hostId: 'runtime:env-1',
|
||||
runtimeOwnerEnvironmentId: 'env-1'
|
||||
})
|
||||
expect(store.getState().sortEpoch).toBe(4)
|
||||
|
||||
runtimeEnvironmentCall
|
||||
.mockRejectedValueOnce(new Error('remote lineage failed'))
|
||||
.mockResolvedValueOnce({
|
||||
id: 'rpc-lineage-refresh',
|
||||
ok: true,
|
||||
result: { lineage: {} },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
await expect(
|
||||
store.getState().assignWorktreeParent(lineage.worktreeId, {
|
||||
parentWorktreeId: lineage.parentWorktreeId
|
||||
})
|
||||
).rejects.toThrow('remote lineage failed')
|
||||
})
|
||||
|
||||
it('assigns a parent through the worktree owner runtime when host-stamped', async () => {
|
||||
const store = createTestStore()
|
||||
const lineage = makeLineage()
|
||||
@@ -722,49 +385,6 @@ describe('worktree lineage state', () => {
|
||||
})
|
||||
})
|
||||
|
||||
// Reject unresolved lineage routes so sidebar callers can toast them (WorktreeContextMenu.handleRemoveParentLink).
|
||||
it('rejects the lineage update when the owner route cannot be resolved', async () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-shared::/same/path'
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'hub-c' } as never,
|
||||
worktreesByRepo: {
|
||||
'repo-shared': [
|
||||
makeWorktree({
|
||||
id: worktreeId,
|
||||
repoId: 'repo-shared',
|
||||
hostId: 'ssh:ssh-a',
|
||||
runtimeOwnerEnvironmentId: 'hub-a'
|
||||
}),
|
||||
makeWorktree({
|
||||
id: worktreeId,
|
||||
repoId: 'repo-shared',
|
||||
hostId: 'ssh:ssh-b',
|
||||
runtimeOwnerEnvironmentId: 'hub-b'
|
||||
})
|
||||
]
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await expect(
|
||||
store.getState().updateWorktreeLineage(worktreeId, { noParent: true })
|
||||
).rejects.toThrow()
|
||||
|
||||
expect(mockApi.worktrees.updateLineage).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('rethrows the original update failure when the recovery refresh fails', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
mockApi.worktrees.updateLineage.mockRejectedValueOnce(new Error('unnest failed'))
|
||||
mockApi.worktrees.listLineage.mockRejectedValueOnce(new Error('refresh failed'))
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
|
||||
await expect(
|
||||
store.getState().updateWorktreeLineage(lineage.worktreeId, { noParent: true })
|
||||
).rejects.toThrow('unnest failed')
|
||||
})
|
||||
|
||||
it('rethrows the original assign failure when the recovery refresh fails', async () => {
|
||||
const lineage = makeLineage()
|
||||
const store = createLocalLineageTestStore(lineage)
|
||||
|
||||
@@ -71,32 +71,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(lastWrite).not.toHaveProperty('pushTarget')
|
||||
})
|
||||
|
||||
it('clears a stale push target when unlinking the GitHub PR that supplied it', async () => {
|
||||
const store = createTestStore()
|
||||
const pushTarget = { remoteName: 'fork', branchName: 'owner/old-pr' }
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1',
|
||||
linkedPR: 2548,
|
||||
pushTarget
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repo1', displayName: 'Repo 1', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().updateWorktreeMeta(wt.id, { linkedPR: null })
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: wt.id,
|
||||
executionHostId: wt.hostId ?? 'local',
|
||||
updates: expect.objectContaining({ linkedPR: null, pushTarget: undefined })
|
||||
})
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.pushTarget).toBeUndefined()
|
||||
})
|
||||
|
||||
it('switches the selected review to GitLab and clears the previous push target', async () => {
|
||||
const store = createTestStore()
|
||||
const oldPushTarget = { remoteName: 'fork', branchName: 'owner/old-pr' }
|
||||
@@ -275,66 +249,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.pushTarget).toBeUndefined()
|
||||
})
|
||||
|
||||
it('hydrates a host-stamped linked GitHub PR push target through the worktree owner runtime', async () => {
|
||||
const store = createTestStore()
|
||||
const pushTarget = { remoteName: 'fork', branchName: 'feature/owner-runtime-pr' }
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/owner-runtime-wt',
|
||||
repoId: 'repo1',
|
||||
path: '/path/owner-runtime-wt',
|
||||
hostId: 'runtime:owner-env',
|
||||
linkedPR: 5571
|
||||
})
|
||||
runtimeEnvironmentCall.mockImplementation(({ method }: RuntimeEnvironmentCallRequest) => {
|
||||
if (method === 'worktree.resolvePrBase') {
|
||||
return Promise.resolve({
|
||||
id: 'rpc-owner-resolve-pr-base',
|
||||
ok: true,
|
||||
result: { baseBranch: 'fork-head', pushTarget },
|
||||
_meta: { runtimeId: 'owner-env' }
|
||||
})
|
||||
}
|
||||
if (method === 'worktree.set') {
|
||||
return Promise.resolve({
|
||||
id: 'rpc-owner-set-worktree',
|
||||
ok: true,
|
||||
result: { worktree: { ...wt, pushTarget } },
|
||||
_meta: { runtimeId: 'owner-env' }
|
||||
})
|
||||
}
|
||||
throw new Error(`Unexpected runtime method ${method}`)
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'focused-env' } as never,
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repo1', displayName: 'Repo 1', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().ensureHostedReviewPushTarget(wt.id)
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
selector: 'owner-env',
|
||||
method: 'worktree.resolvePrBase',
|
||||
params: expect.objectContaining({ repo: 'repo1', prNumber: 5571 }),
|
||||
timeoutMs: 30_000
|
||||
})
|
||||
)
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
selector: 'owner-env',
|
||||
method: 'worktree.set',
|
||||
params: expect.objectContaining({ worktree: `id:${wt.id}`, pushTarget }),
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
)
|
||||
expect(mockApi.worktrees.resolvePrBase).not.toHaveBeenCalled()
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.pushTarget).toEqual(pushTarget)
|
||||
})
|
||||
|
||||
it('hydrates an SSH-owned linked GitHub PR push target through local IPC when a runtime is focused', async () => {
|
||||
const store = createTestStore()
|
||||
const pushTarget = { remoteName: 'fork', branchName: 'feature/ssh-pr' }
|
||||
@@ -378,37 +292,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo['repo-ssh'][0]?.pushTarget).toEqual(pushTarget)
|
||||
})
|
||||
|
||||
it('skips the push-target lookup for a genuinely ambiguous owner instead of throwing past the { ok, error } contract', async () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-shared::/same/path'
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'hub-c' } as never,
|
||||
worktreesByRepo: {
|
||||
'repo-shared': [
|
||||
makeWorktree({
|
||||
id: worktreeId,
|
||||
repoId: 'repo-shared',
|
||||
hostId: 'ssh:ssh-a',
|
||||
runtimeOwnerEnvironmentId: 'hub-a'
|
||||
}),
|
||||
makeWorktree({
|
||||
id: worktreeId,
|
||||
repoId: 'repo-shared',
|
||||
hostId: 'ssh:ssh-b',
|
||||
runtimeOwnerEnvironmentId: 'hub-b'
|
||||
})
|
||||
]
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
const result = await store.getState().updateWorktreeMeta(worktreeId, { linkedPR: 123 })
|
||||
|
||||
// The ambiguous owner must surface as a graceful { ok: false }, not an uncaught rejection.
|
||||
expect(result.ok).toBe(false)
|
||||
expect(mockApi.worktrees.resolvePrBase).not.toHaveBeenCalled()
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
})
|
||||
it('updates only the explicitly selected owner when locators collide', async () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-shared::/same/path'
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { AppState } from '../types'
|
||||
import { toast } from 'sonner'
|
||||
import 'sonner'
|
||||
import type { RuntimeEnvironmentCallRequest } from '../../runtime/runtime-compatibility-test-fixture'
|
||||
import { createCompatibleRuntimeStatusResponse } from '../../runtime/runtime-compatibility-test-fixture'
|
||||
import { WORKTREE_RENAME_ERROR_DISMISS_RUNTIME_CAPABILITY } from '../../../../shared/worktree-runtime-capabilities'
|
||||
@@ -99,37 +99,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
}
|
||||
)
|
||||
|
||||
it('persists worktree metadata through the active remote runtime environment', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1',
|
||||
hostId: 'runtime:env-1'
|
||||
})
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-set',
|
||||
ok: true,
|
||||
result: { worktree: { ...wt, comment: 'remote note' } },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().updateWorktreeMeta(wt.id, { comment: 'remote note' })
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.set',
|
||||
params: expect.objectContaining({ worktree: `id:${wt.id}`, comment: 'remote note' }),
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.comment).toBe('remote note')
|
||||
})
|
||||
|
||||
it('force-deletes a preserved HUB-owned SSH branch through its HUB', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
@@ -167,22 +136,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(mockApi.worktrees.forceDeletePreservedBranch).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('suppresses per-branch feedback for an aggregate delete', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
store.setState({ worktreesByRepo: { repo1: [wt] } } as Partial<AppState>)
|
||||
vi.mocked(toast.success).mockClear()
|
||||
vi.mocked(toast.error).mockClear()
|
||||
|
||||
const result = await store
|
||||
.getState()
|
||||
.forceDeletePreservedBranch(wt.id, 'feature/test', 'abc123', { suppressToast: true })
|
||||
|
||||
expect(result).toEqual({ ok: true, deleted: true })
|
||||
expect(toast.success).not.toHaveBeenCalled()
|
||||
expect(toast.error).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('fails preserved branch deletion closed for two HUB owners', async () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-ssh::/srv/same-wt'
|
||||
|
||||
@@ -69,30 +69,6 @@ describe('workspace attachment collections', () => {
|
||||
).toEqual([base[1]])
|
||||
})
|
||||
|
||||
it('removes a secondary review without disturbing the active review or task', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/work',
|
||||
repoId: 'repo1',
|
||||
linkedPR: 42,
|
||||
linkedIssue: 9,
|
||||
linkedItems: [
|
||||
{ provider: 'github', type: 'pr', number: 42 },
|
||||
{ provider: 'github', type: 'pr', number: 43 },
|
||||
{ provider: 'github', type: 'issue', number: 9 }
|
||||
]
|
||||
})
|
||||
store.setState({ worktreesByRepo: { repo1: [wt] } })
|
||||
await store.getState().updateWorktreeMeta(wt.id, {
|
||||
linkedItems: wt.linkedItems?.filter((item) => item.number !== 43)
|
||||
})
|
||||
expect(store.getState().worktreesByRepo.repo1[0]).toMatchObject({
|
||||
linkedPR: 42,
|
||||
linkedIssue: 9
|
||||
})
|
||||
expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('routes folder links to the owning folder update instead of dropping them', async () => {
|
||||
const store = createTestStore()
|
||||
const folder = makeFolderWorkspace()
|
||||
|
||||
@@ -59,17 +59,6 @@ describe('pending worktree creation state', () => {
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it('updatePendingWorktreeCreation skips the write when the patch changes nothing', () => {
|
||||
const store = createTestStore()
|
||||
store.getState().beginPendingWorktreeCreation(makePendingCreation('c1'))
|
||||
const before = store.getState().pendingWorktreeCreations
|
||||
|
||||
store.getState().updatePendingWorktreeCreation('c1', { phase: 'fetching' })
|
||||
|
||||
// Same map reference => no subscriber notification on a no-op progress event.
|
||||
expect(store.getState().pendingWorktreeCreations).toBe(before)
|
||||
})
|
||||
|
||||
it('removePendingWorktreeCreation clears the active surface only when it points at the removed entry', () => {
|
||||
const store = createTestStore()
|
||||
store.getState().beginPendingWorktreeCreation(makePendingCreation('c1'))
|
||||
|
||||
@@ -149,18 +149,6 @@ describe('purgeWorktreeTerminalState direct (design §4.4)', () => {
|
||||
expect(s.activeTabType).toBe('terminal')
|
||||
})
|
||||
|
||||
it('is a no-op when the id list is empty', () => {
|
||||
const store = createTestStore()
|
||||
const before = {
|
||||
'repoA::/a/wt1': [{ id: 'tab-1', worktreeId: 'repoA::/a/wt1' }]
|
||||
}
|
||||
store.setState({ tabsByWorktree: before } as unknown as Partial<AppState>)
|
||||
|
||||
store.getState().purgeWorktreeTerminalState([])
|
||||
|
||||
expect(store.getState().tabsByWorktree).toBe(before)
|
||||
})
|
||||
|
||||
it('ignores the floating workspace sentinel while purging mixed real ids', () => {
|
||||
const store = createTestStore()
|
||||
const staleId = 'repoA::/a/wt1'
|
||||
@@ -250,65 +238,4 @@ describe('purgeWorktreeTerminalState direct (design §4.4)', () => {
|
||||
groupId: 'floating-group'
|
||||
})
|
||||
})
|
||||
|
||||
it('is a no-op when only the floating workspace sentinel is passed', () => {
|
||||
const store = createTestStore()
|
||||
const tabsByWorktree = {}
|
||||
const browserTabsByWorktree = {
|
||||
[FLOATING_TERMINAL_WORKTREE_ID]: [{ id: 'floating-browser', url: 'https://orca.test' }]
|
||||
}
|
||||
const openFiles = [
|
||||
{
|
||||
id: 'floating-file',
|
||||
worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
|
||||
filePath: '/floating/note.md',
|
||||
relativePath: 'note.md',
|
||||
language: 'markdown',
|
||||
isDirty: false,
|
||||
isPreview: false,
|
||||
mode: 'edit' as const
|
||||
}
|
||||
]
|
||||
const unifiedTabsByWorktree = {
|
||||
[FLOATING_TERMINAL_WORKTREE_ID]: [
|
||||
{
|
||||
id: 'floating-unified-tab',
|
||||
type: 'editor',
|
||||
worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
|
||||
fileId: 'floating-file'
|
||||
}
|
||||
]
|
||||
}
|
||||
const groupsByWorktree = {
|
||||
[FLOATING_TERMINAL_WORKTREE_ID]: [
|
||||
{
|
||||
id: 'floating-group',
|
||||
worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
|
||||
activeTabId: 'floating-unified-tab'
|
||||
}
|
||||
]
|
||||
}
|
||||
const layoutByWorktree = {
|
||||
[FLOATING_TERMINAL_WORKTREE_ID]: { type: 'leaf', groupId: 'floating-group' }
|
||||
}
|
||||
|
||||
store.setState({
|
||||
tabsByWorktree,
|
||||
browserTabsByWorktree,
|
||||
openFiles,
|
||||
activeFileIdByWorktree: { [FLOATING_TERMINAL_WORKTREE_ID]: 'floating-file' },
|
||||
unifiedTabsByWorktree,
|
||||
groupsByWorktree,
|
||||
layoutByWorktree
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
store.getState().purgeWorktreeTerminalState([FLOATING_TERMINAL_WORKTREE_ID])
|
||||
|
||||
expect(store.getState().tabsByWorktree).toBe(tabsByWorktree)
|
||||
expect(store.getState().browserTabsByWorktree).toBe(browserTabsByWorktree)
|
||||
expect(store.getState().openFiles).toBe(openFiles)
|
||||
expect(store.getState().unifiedTabsByWorktree).toBe(unifiedTabsByWorktree)
|
||||
expect(store.getState().groupsByWorktree).toBe(groupsByWorktree)
|
||||
expect(store.getState().layoutByWorktree).toBe(layoutByWorktree)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -62,25 +62,6 @@ describe('window-side Recent stamps with the sidebar-inputs switch on', () => {
|
||||
expect(persistedStamp()).toBe(false)
|
||||
})
|
||||
|
||||
const persistedUnread = () =>
|
||||
mockApi.worktrees.updateMeta.mock.calls.some(
|
||||
([args]: [{ updates: Record<string, unknown> }]) => 'isUnread' in args.updates
|
||||
)
|
||||
|
||||
it('a bell or finish writes no stamp and leaves the unread flag to the host', () => {
|
||||
const store = storeWith()
|
||||
store.getState().markAgentAttentionUnread({
|
||||
workspaceId: wt.id,
|
||||
subjectKey: null,
|
||||
groupId: null,
|
||||
reason: 'agent-completion'
|
||||
})
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isUnread).toBe(false)
|
||||
expect(persistedUnread()).toBe(false)
|
||||
expect(lastActivityAt(store)).toBe(5)
|
||||
expect(persistedStamp()).toBe(false)
|
||||
})
|
||||
|
||||
it('a comment edit writes no stamp', async () => {
|
||||
const store = storeWith()
|
||||
await store.getState().updateWorktreeMeta(wt.id, { comment: 'note' })
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { setLocalRuntimeCapabilitiesForTests } from '../../runtime/local-runtime-capabilities'
|
||||
import { toast } from 'sonner'
|
||||
import 'sonner'
|
||||
import type { ExecutionHostId } from '../../../../shared/execution-host'
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { AppState } from '../types'
|
||||
@@ -36,25 +36,6 @@ vi.mock('@/components/worktree-base-fallback-notice', () => ({
|
||||
beforeEach(resetWorktreeSliceModuleMemory)
|
||||
|
||||
describe('worktree remote runtime mutations', () => {
|
||||
it('shows a host warning about the push destination after creating the workspace', async () => {
|
||||
const store = createRepoTestStore()
|
||||
seedRepoHost(store, 'runtime:env-1')
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'create',
|
||||
ok: true,
|
||||
result: {
|
||||
worktree: makeWorktree({
|
||||
id: 'repo1::/path/warning',
|
||||
repoId: 'repo1',
|
||||
path: '/path/warning'
|
||||
}),
|
||||
warning: 'Check the push destination.'
|
||||
}
|
||||
})
|
||||
await store.getState().createWorktree('repo1', 'warning', 'origin/main', 'skip')
|
||||
expect(toast.warning).toHaveBeenCalledWith('Check the push destination.')
|
||||
})
|
||||
|
||||
it.each([false, true])(
|
||||
'requires strict reuse support before creating on a remote host (%s)',
|
||||
async (supported) => {
|
||||
@@ -244,86 +225,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
])
|
||||
})
|
||||
|
||||
it('forwards generated-name provenance through paired-runtime create', async () => {
|
||||
const store = createRepoTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/nautilus', repoId: 'repo1' })
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-create',
|
||||
ok: true,
|
||||
result: { worktree: wt },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [] }
|
||||
} as Partial<AppState>)
|
||||
seedRepoHost(store, 'runtime:env-1')
|
||||
const createWorktree = store.getState().createWorktree
|
||||
const args: Parameters<typeof createWorktree> = ['repo1', 'nautilus']
|
||||
args[25] = { nameWasGenerated: true }
|
||||
|
||||
await createWorktree(...args)
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
method: 'worktree.create',
|
||||
params: expect.objectContaining({ nameWasGenerated: true })
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it('persists Jira item and source context through paired-runtime create', async () => {
|
||||
const store = createRepoTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/jira-link',
|
||||
repoId: 'repo1',
|
||||
path: '/path/jira-link'
|
||||
})
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-create',
|
||||
ok: true,
|
||||
result: { worktree: wt },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [] }
|
||||
} as Partial<AppState>)
|
||||
seedRepoHost(store, 'runtime:env-1')
|
||||
const linkedWorkItem = {
|
||||
provider: 'jira' as const,
|
||||
type: 'issue' as const,
|
||||
number: 0,
|
||||
title: 'ORCA-123 Link Jira',
|
||||
url: 'https://company.atlassian.net/browse/ORCA-123',
|
||||
jiraIdentifier: 'ORCA-123'
|
||||
}
|
||||
const linkedTaskSourceContext = {
|
||||
kind: 'task-source' as const,
|
||||
provider: 'jira' as const,
|
||||
projectId: 'project-1',
|
||||
hostId: 'runtime:env-1' as const,
|
||||
providerIdentity: {
|
||||
provider: 'jira' as const,
|
||||
siteId: 'site-1',
|
||||
siteUrl: 'https://company.atlassian.net',
|
||||
projectKey: 'ORCA'
|
||||
}
|
||||
}
|
||||
const createWorktree = store.getState().createWorktree
|
||||
const args: Parameters<typeof createWorktree> = ['repo1', 'jira-link']
|
||||
args[25] = { linkedWorkItem, linkedTaskSourceContext }
|
||||
|
||||
await createWorktree(...args)
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
method: 'worktree.create',
|
||||
params: expect.objectContaining({ linkedWorkItem, linkedTaskSourceContext })
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it('blocks Jira linking when the paired runtime lacks durable metadata capability', async () => {
|
||||
const oldRuntimeStatus = createCompatibleRuntimeStatusResponse('runtime-old')
|
||||
if (oldRuntimeStatus.ok) {
|
||||
@@ -429,110 +330,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
)
|
||||
})
|
||||
|
||||
it('passes task startup drafts only to the owning remote runtime', async () => {
|
||||
const store = createRepoTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/task-draft',
|
||||
repoId: 'repo1',
|
||||
path: '/path/task-draft'
|
||||
})
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-create',
|
||||
ok: true,
|
||||
result: { worktree: wt },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [] }
|
||||
} as Partial<AppState>)
|
||||
seedRepoHost(store, 'runtime:env-1')
|
||||
const createWorktree = store.getState().createWorktree
|
||||
const args: Parameters<typeof createWorktree> = ['repo1', 'task-draft', undefined, 'inherit']
|
||||
args[10] = 'codex'
|
||||
args[25] = { startupDraft: 'https://github.com/stablyai/orca/issues/12' }
|
||||
|
||||
await createWorktree(...args)
|
||||
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
method: 'worktree.create',
|
||||
params: expect.objectContaining({
|
||||
createdWithAgent: 'codex',
|
||||
startupDraft: 'https://github.com/stablyai/orca/issues/12'
|
||||
})
|
||||
})
|
||||
)
|
||||
expect(mockApi.worktrees.create).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('passes startup commands through local worktree creation IPC', async () => {
|
||||
const store = createRepoTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/local-agent-startup',
|
||||
repoId: 'repo1',
|
||||
path: '/path/local-agent-startup'
|
||||
})
|
||||
mockApi.worktrees.create.mockResolvedValue({
|
||||
worktree: wt,
|
||||
startupTerminal: { spawned: true, surface: 'visible' }
|
||||
})
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store
|
||||
.getState()
|
||||
.createWorktree(
|
||||
'repo1',
|
||||
'local-agent-startup',
|
||||
undefined,
|
||||
'skip',
|
||||
undefined,
|
||||
'sidebar',
|
||||
'Launch local agent',
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
'claude',
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
{
|
||||
command: "claude --prefill 'summarize repo'",
|
||||
env: { ORCA_AGENT_MODE: 'direct' },
|
||||
telemetry: {
|
||||
agent_kind: 'claude-code',
|
||||
launch_source: 'new_workspace_composer',
|
||||
request_kind: 'new'
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
expect(mockApi.worktrees.create).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
repoId: 'repo1',
|
||||
name: 'local-agent-startup',
|
||||
setupDecision: 'skip',
|
||||
telemetrySource: 'sidebar',
|
||||
displayName: 'Launch local agent',
|
||||
createdWithAgent: 'claude',
|
||||
startup: {
|
||||
command: "claude --prefill 'summarize repo'",
|
||||
env: { ORCA_AGENT_MODE: 'direct' },
|
||||
telemetry: {
|
||||
agent_kind: 'claude-code',
|
||||
launch_source: 'new_workspace_composer',
|
||||
request_kind: 'new'
|
||||
}
|
||||
}
|
||||
})
|
||||
)
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('retries a suffixed branchNameOverride when runtime create reports a branch conflict', async () => {
|
||||
const store = createRepoTestStore()
|
||||
const wt = makeWorktree({
|
||||
|
||||
@@ -3,7 +3,7 @@ import { worktreeRemovalReplyTimeoutMs } from '../../../../shared/worktree/archi
|
||||
import type { AppState } from '../types'
|
||||
import type { RuntimeEnvironmentCallRequest } from '../../runtime/runtime-compatibility-test-fixture'
|
||||
import { makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import { getDefaultSettings } from '../../../../shared/constants'
|
||||
import '../../../../shared/constants'
|
||||
import {
|
||||
createTestStore,
|
||||
mockApi,
|
||||
@@ -36,140 +36,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it("removes worktrees through their owning server, the row's stamp", async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1',
|
||||
hostId: 'runtime:env-1',
|
||||
runtimeOwnerEnvironmentId: 'env-1'
|
||||
})
|
||||
runtimeEnvironmentCall.mockResolvedValue({
|
||||
id: 'rpc-rm',
|
||||
ok: true,
|
||||
result: { removed: true },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
const result = await store
|
||||
.getState()
|
||||
.removeWorktree({ id: wt.id, executionHostId: null }, false, {
|
||||
snapshotPruneBatchId: 'batch-1'
|
||||
})
|
||||
|
||||
expect(result).toEqual({ ok: true })
|
||||
expect(runtimeEnvironmentCall).toHaveBeenCalledWith({
|
||||
selector: 'env-1',
|
||||
method: 'worktree.rm',
|
||||
params: {
|
||||
worktree: `id:${wt.id}`,
|
||||
force: false,
|
||||
allowUnverifiedPtyStop: false,
|
||||
runHooks: true
|
||||
},
|
||||
// Hooks run here, so the client must outlast the host's archive-hook budget (#19334).
|
||||
timeoutMs: worktreeRemovalReplyTimeoutMs(true),
|
||||
expectedEnvironmentPairingRevision: undefined,
|
||||
expectedRuntimeId: undefined
|
||||
})
|
||||
expect(mockApi.worktrees.remove).not.toHaveBeenCalled()
|
||||
expect(mockApi.workspaceCleanup.recordRemovalSnapshotPrune).toHaveBeenCalledExactlyOnceWith({
|
||||
batchId: 'batch-1',
|
||||
worktreeId: wt.id,
|
||||
executionHostId: 'runtime:env-1'
|
||||
})
|
||||
expect(store.getState().shutdownWorktreeTerminals).toHaveBeenCalledWith(wt.id, {
|
||||
shutdownReason: 'remove-worktree',
|
||||
backendOwnsPtyTeardown: true
|
||||
})
|
||||
expect(store.getState().worktreesByRepo.repo1).toEqual([])
|
||||
})
|
||||
|
||||
it('never removes an unstamped worktree through the focused server', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
store.setState({
|
||||
settings: { ...getDefaultSettings('/home'), activeRuntimeEnvironmentId: 'env-1' },
|
||||
repos: [{ id: 'repo1', path: '/path', displayName: 'r', badgeColor: '#000', addedAt: 0 }],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
})
|
||||
|
||||
await store.getState().removeWorktree({ id: wt.id, executionHostId: null }, false)
|
||||
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalledWith(
|
||||
expect.objectContaining({ method: 'worktree.rm' })
|
||||
)
|
||||
expect(mockApi.worktrees.remove).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('cleans up a preserved branch through the same host qualifier the removal used', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1',
|
||||
hostId: 'runtime:env-1'
|
||||
})
|
||||
runtimeEnvironmentCall
|
||||
.mockResolvedValueOnce({
|
||||
id: 'rpc-rm',
|
||||
ok: true,
|
||||
result: { preservedBranch: { branchName: 'feature/x', head: 'saved-head' } },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
.mockResolvedValueOnce({
|
||||
id: 'rpc-force-delete-branch',
|
||||
ok: true,
|
||||
result: { deleted: true },
|
||||
_meta: { runtimeId: 'runtime-remote' }
|
||||
})
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'env-1' } as never,
|
||||
trustedOrcaHooks: { repo1: { all: { approvedAt: 1 } } },
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: wt.id, executionHostId: 'runtime:env-1' })
|
||||
|
||||
const forceResult = await store
|
||||
.getState()
|
||||
.forceDeletePreservedBranch(wt.id, 'feature/x', 'saved-head', {
|
||||
hostId: 'runtime:env-1',
|
||||
runtimeEnvironmentId: 'env-1'
|
||||
})
|
||||
|
||||
expect(forceResult).toEqual({ ok: true, deleted: true })
|
||||
expect(runtimeEnvironmentCall).toHaveBeenNthCalledWith(1, {
|
||||
selector: 'env-1',
|
||||
method: 'worktree.rm',
|
||||
params: {
|
||||
worktree: `id:${wt.id}`,
|
||||
force: undefined,
|
||||
allowUnverifiedPtyStop: false,
|
||||
runHooks: true
|
||||
},
|
||||
// Hooks run here, so the client must outlast the host's archive-hook budget (#19334).
|
||||
timeoutMs: worktreeRemovalReplyTimeoutMs(true),
|
||||
expectedEnvironmentPairingRevision: undefined,
|
||||
expectedRuntimeId: undefined
|
||||
})
|
||||
expect(runtimeEnvironmentCall).toHaveBeenNthCalledWith(2, {
|
||||
selector: 'env-1',
|
||||
method: 'worktree.forceDeleteBranch',
|
||||
params: {
|
||||
worktree: `id:${wt.id}`,
|
||||
branchName: 'feature/x',
|
||||
expectedHead: 'saved-head'
|
||||
},
|
||||
timeoutMs: 15_000
|
||||
})
|
||||
})
|
||||
|
||||
it('does not clean up a hidden same-id VM owned by another host', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
@@ -647,37 +513,4 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo['repo-ssh']).toEqual([])
|
||||
})
|
||||
|
||||
it('fails closed before deleting an exact worktree id owned by multiple hosts', async () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-shared::/same/path'
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo-shared', path: '/local', displayName: 'Local', badgeColor: '#000', addedAt: 0 },
|
||||
{
|
||||
id: 'repo-shared',
|
||||
path: '/remote',
|
||||
displayName: 'SSH',
|
||||
badgeColor: '#111',
|
||||
addedAt: 1,
|
||||
connectionId: 'ssh-1'
|
||||
}
|
||||
],
|
||||
worktreesByRepo: {
|
||||
'repo-shared': [
|
||||
makeWorktree({ id: worktreeId, repoId: 'repo-shared', hostId: 'local' }),
|
||||
makeWorktree({ id: worktreeId, repoId: 'repo-shared', hostId: 'ssh:ssh-1' })
|
||||
]
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
const result = await store.getState().removeWorktree({ id: worktreeId, executionHostId: null })
|
||||
|
||||
expect(result).toEqual({
|
||||
ok: false,
|
||||
error: 'Workspace identity is ambiguous across hosts. Refresh projects and try again.'
|
||||
})
|
||||
expect(mockApi.worktrees.remove).not.toHaveBeenCalled()
|
||||
expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -6,8 +6,8 @@ import {
|
||||
hasDismissedHugeRepoWarning,
|
||||
markHugeRepoWarningDismissed
|
||||
} from '@/lib/source-control-huge-repo-warning-dismissals'
|
||||
import { getHostedReviewLinkMutationGenerationForTests } from './worktrees'
|
||||
import { makeLineage, makeTerminalTab, makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import './worktrees'
|
||||
import { makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import {
|
||||
createTestStore,
|
||||
mockApi,
|
||||
@@ -61,116 +61,6 @@ describe('removeWorktree state cleanup', () => {
|
||||
expect(hasDismissedHugeRepoWarning(replacementProbe)).toBe(false)
|
||||
})
|
||||
|
||||
it('retains huge-repo warning state when explicit removal fails', async () => {
|
||||
const store = createTestStore()
|
||||
const retained = makeWorktree({
|
||||
id: 'repo1::/path/retained',
|
||||
instanceId: 'retained-instance',
|
||||
repoId: 'repo1',
|
||||
path: '/path/retained'
|
||||
})
|
||||
store.setState({ worktreesByRepo: { repo1: [retained] } } as Partial<AppState>)
|
||||
const retainedProbe = beginHugeRepoWarningProbe(retained)
|
||||
expect(markHugeRepoWarningDismissed(retainedProbe)).toBe(true)
|
||||
mockApi.worktrees.remove.mockRejectedValueOnce(new Error('delete failed'))
|
||||
|
||||
const result = await store.getState().removeWorktree({ id: retained.id, executionHostId: null })
|
||||
|
||||
expect(result).toEqual({ ok: false, error: 'delete failed' })
|
||||
expect(hasDismissedHugeRepoWarning(retainedProbe)).toBe(true)
|
||||
})
|
||||
|
||||
it('cleans up hosted review link mutation bookkeeping for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const removed = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1'
|
||||
})
|
||||
const surviving = makeWorktree({
|
||||
id: 'repo1::/path/wt2',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt2'
|
||||
})
|
||||
store.setState({ worktreesByRepo: { repo1: [removed, surviving] } } as Partial<AppState>)
|
||||
await store.getState().updateWorktreeMeta(removed.id, { linkedBitbucketPR: 101 })
|
||||
await store.getState().updateWorktreeMeta(surviving.id, { linkedAzureDevOpsPR: 202 })
|
||||
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(removed.id)).toBeGreaterThan(0)
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(surviving.id)).toBeGreaterThan(0)
|
||||
|
||||
await store.getState().removeWorktree({ id: removed.id, executionHostId: null })
|
||||
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(removed.id)).toBe(0)
|
||||
expect(getHostedReviewLinkMutationGenerationForTests(surviving.id)).toBeGreaterThan(0)
|
||||
})
|
||||
|
||||
it('cleans up expandedPaneByTabId/canExpandPaneByTabId for removed worktree tabs', async () => {
|
||||
const store = createTestStore()
|
||||
const removed = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
const surviving = makeWorktree({ id: 'repo1::/path/wt2', repoId: 'repo1', path: '/path/wt2' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [removed, surviving] },
|
||||
tabsByWorktree: {
|
||||
[removed.id]: [makeTerminalTab({ id: 'removed-tab', worktreeId: removed.id })],
|
||||
[surviving.id]: [makeTerminalTab({ id: 'surviving-tab', worktreeId: surviving.id })]
|
||||
},
|
||||
// Split panes write these even when false; removeWorktree used to strand them (only closeTab deleted them).
|
||||
expandedPaneByTabId: { 'removed-tab': true, 'surviving-tab': false },
|
||||
canExpandPaneByTabId: { 'removed-tab': false, 'surviving-tab': true }
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: removed.id, executionHostId: null })
|
||||
|
||||
expect(store.getState().expandedPaneByTabId).toEqual({ 'surviving-tab': false })
|
||||
expect(store.getState().canExpandPaneByTabId).toEqual({ 'surviving-tab': true })
|
||||
})
|
||||
|
||||
it('cleans up automatic agent resume claims for removed worktree tabs', async () => {
|
||||
const store = createTestStore()
|
||||
const removed = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1'
|
||||
})
|
||||
const surviving = makeWorktree({
|
||||
id: 'repo1::/path/wt2',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt2'
|
||||
})
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [removed, surviving] },
|
||||
tabsByWorktree: {
|
||||
[removed.id]: [makeTerminalTab({ id: 'removed-tab', worktreeId: removed.id })],
|
||||
[surviving.id]: [makeTerminalTab({ id: 'surviving-tab', worktreeId: surviving.id })]
|
||||
},
|
||||
automaticAgentResumeClaimsByTabId: {
|
||||
'removed-tab': {
|
||||
worktreeId: removed.id,
|
||||
launchAgent: 'codex',
|
||||
providerSession: { key: 'session_id', id: 'removed-session' }
|
||||
},
|
||||
'surviving-tab': {
|
||||
worktreeId: surviving.id,
|
||||
launchAgent: 'codex',
|
||||
providerSession: { key: 'session_id', id: 'surviving-session' }
|
||||
}
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: removed.id, executionHostId: null })
|
||||
|
||||
expect(store.getState().automaticAgentResumeClaimsByTabId).toEqual({
|
||||
'surviving-tab': {
|
||||
worktreeId: surviving.id,
|
||||
launchAgent: 'codex',
|
||||
providerSession: { key: 'session_id', id: 'surviving-session' }
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
it('purges the orphaned project that pointed at a destroyed runtime-owned SSH target', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
@@ -223,151 +113,6 @@ describe('removeWorktree state cleanup', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up editorDrafts for files in the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
openFiles: [
|
||||
{
|
||||
id: 'file-1',
|
||||
worktreeId: 'repo1::/path/wt1',
|
||||
filePath: '/path/wt1/file.ts',
|
||||
relativePath: 'file.ts',
|
||||
language: 'typescript',
|
||||
isDirty: true,
|
||||
isPreview: false,
|
||||
mode: 'edit' as const
|
||||
}
|
||||
],
|
||||
editorDrafts: {
|
||||
'file-1': 'draft content for wt1',
|
||||
'file-2': 'draft content for another worktree'
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
const result = await store
|
||||
.getState()
|
||||
.removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(result).toEqual({ ok: true })
|
||||
expect(store.getState().editorDrafts).toEqual({
|
||||
'file-2': 'draft content for another worktree'
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up the removed worktree lineage entry', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
const childLineage = makeLineage({ worktreeId: wt.id })
|
||||
const siblingLineage = makeLineage({
|
||||
worktreeId: 'repo1::/path/wt2',
|
||||
worktreeInstanceId: 'sibling-instance'
|
||||
})
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
worktreeLineageById: {
|
||||
[wt.id]: childLineage,
|
||||
'repo1::/path/wt2': siblingLineage
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: wt.id, executionHostId: null })
|
||||
|
||||
expect(store.getState().worktreeLineageById).toEqual({
|
||||
'repo1::/path/wt2': siblingLineage
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up markdownViewMode for files in the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
openFiles: [
|
||||
{
|
||||
id: 'file-1',
|
||||
worktreeId: 'repo1::/path/wt1',
|
||||
filePath: '/path/wt1/readme.md',
|
||||
relativePath: 'readme.md',
|
||||
language: 'markdown',
|
||||
isDirty: false,
|
||||
isPreview: false,
|
||||
mode: 'edit' as const
|
||||
}
|
||||
],
|
||||
markdownViewMode: {
|
||||
'file-1': 'rich' as const,
|
||||
'file-2': 'source' as const
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().markdownViewMode).toEqual({ 'file-2': 'source' })
|
||||
})
|
||||
|
||||
it('cleans up editorViewMode for files in the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
openFiles: [
|
||||
{
|
||||
id: 'file-1',
|
||||
worktreeId: 'repo1::/path/wt1',
|
||||
filePath: '/path/wt1/app.ts',
|
||||
relativePath: 'app.ts',
|
||||
language: 'typescript',
|
||||
isDirty: false,
|
||||
isPreview: false,
|
||||
mode: 'edit' as const
|
||||
}
|
||||
],
|
||||
editorViewMode: {
|
||||
'file-1': 'changes' as const,
|
||||
'file-2': 'changes' as const
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().editorViewMode).toEqual({ 'file-2': 'changes' })
|
||||
})
|
||||
|
||||
it('cleans up markdownFrontmatterVisible for files in the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
openFiles: [
|
||||
{
|
||||
id: 'file-1',
|
||||
worktreeId: 'repo1::/path/wt1',
|
||||
filePath: '/path/wt1/readme.md',
|
||||
relativePath: 'readme.md',
|
||||
language: 'markdown',
|
||||
isDirty: false,
|
||||
isPreview: false,
|
||||
mode: 'edit' as const
|
||||
}
|
||||
],
|
||||
markdownFrontmatterVisible: {
|
||||
'file-1': true,
|
||||
'file-2': true
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().markdownFrontmatterVisible).toEqual({ 'file-2': true })
|
||||
})
|
||||
|
||||
it('cleans up markdownFrontmatterVisible for preview-only source files in the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
@@ -424,249 +169,4 @@ describe('removeWorktree state cleanup', () => {
|
||||
expect(worktreePresentWhenRecorded).toBe(true)
|
||||
expect(store.getState().worktreesByRepo.repo1).toEqual([])
|
||||
})
|
||||
|
||||
it('cleans up expandedDirs for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
expandedDirs: {
|
||||
'repo1::/path/wt1': new Set(['src', 'src/lib']),
|
||||
'repo1::/path/wt2': new Set(['test'])
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().expandedDirs).toEqual({
|
||||
'repo1::/path/wt2': new Set(['test'])
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up dotfile visibility for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
showDotfilesByWorktree: {
|
||||
'repo1::/path/wt1': false,
|
||||
'repo1::/path/wt2': false
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().showDotfilesByWorktree).toEqual({
|
||||
'repo1::/path/wt2': false
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up activeTabIdByWorktree for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeTabIdByWorktree: {
|
||||
'repo1::/path/wt1': 'tab-1',
|
||||
'repo1::/path/wt2': 'tab-2'
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().activeTabIdByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'tab-2'
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up tabBarOrderByWorktree for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
tabBarOrderByWorktree: {
|
||||
'repo1::/path/wt1': ['tab-1', 'file-1', 'browser-1'],
|
||||
'repo1::/path/wt2': ['tab-2']
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().tabBarOrderByWorktree).toEqual({
|
||||
'repo1::/path/wt2': ['tab-2']
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up split-tab model state for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
pendingReconnectTabByWorktree: {
|
||||
'repo1::/path/wt1': ['tab-1'],
|
||||
'repo1::/path/wt2': ['tab-2']
|
||||
},
|
||||
unifiedTabsByWorktree: {
|
||||
'repo1::/path/wt1': [{ id: 'tab-1', worktreeId: 'repo1::/path/wt1' }],
|
||||
'repo1::/path/wt2': [{ id: 'tab-2', worktreeId: 'repo1::/path/wt2' }]
|
||||
},
|
||||
groupsByWorktree: {
|
||||
'repo1::/path/wt1': [
|
||||
{ id: 'group-1', worktreeId: 'repo1::/path/wt1', activeTabId: 'tab-1' }
|
||||
],
|
||||
'repo1::/path/wt2': [
|
||||
{ id: 'group-2', worktreeId: 'repo1::/path/wt2', activeTabId: 'tab-2' }
|
||||
]
|
||||
},
|
||||
activeGroupIdByWorktree: {
|
||||
'repo1::/path/wt1': 'group-1',
|
||||
'repo1::/path/wt2': 'group-2'
|
||||
},
|
||||
layoutByWorktree: {
|
||||
'repo1::/path/wt1': { type: 'leaf', groupId: 'group-1' },
|
||||
'repo1::/path/wt2': { type: 'leaf', groupId: 'group-2' }
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().pendingReconnectTabByWorktree).toEqual({
|
||||
'repo1::/path/wt2': ['tab-2']
|
||||
})
|
||||
expect(store.getState().unifiedTabsByWorktree).toEqual({
|
||||
'repo1::/path/wt2': [{ id: 'tab-2', worktreeId: 'repo1::/path/wt2' }]
|
||||
})
|
||||
expect(store.getState().groupsByWorktree).toEqual({
|
||||
'repo1::/path/wt2': [{ id: 'group-2', worktreeId: 'repo1::/path/wt2', activeTabId: 'tab-2' }]
|
||||
})
|
||||
expect(store.getState().activeGroupIdByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'group-2'
|
||||
})
|
||||
expect(store.getState().layoutByWorktree).toEqual({
|
||||
'repo1::/path/wt2': { type: 'leaf', groupId: 'group-2' }
|
||||
})
|
||||
})
|
||||
|
||||
it('cleans up git caches for the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
gitStatusByWorktree: {
|
||||
'repo1::/path/wt1': [{ path: 'a.ts' }],
|
||||
'repo1::/path/wt2': [{ path: 'b.ts' }]
|
||||
},
|
||||
gitStatusHeadByWorktree: {
|
||||
'repo1::/path/wt1': 'head-1',
|
||||
'repo1::/path/wt2': 'head-2'
|
||||
},
|
||||
gitBranchLineTotalByWorktree: {
|
||||
'repo1::/path/wt1': { added: 24, removed: 3, mergeBase: 'base-1' },
|
||||
'repo1::/path/wt2': { added: 1, removed: 0, mergeBase: 'base-2' }
|
||||
},
|
||||
gitIgnoredPathsByWorktree: {
|
||||
'repo1::/path/wt1': ['dist/'],
|
||||
'repo1::/path/wt2': ['coverage/']
|
||||
},
|
||||
gitConflictOperationByWorktree: {
|
||||
'repo1::/path/wt1': 'merge',
|
||||
'repo1::/path/wt2': 'unknown'
|
||||
},
|
||||
trackedConflictPathsByWorktree: {
|
||||
'repo1::/path/wt1': { 'a.ts': 'both_modified' },
|
||||
'repo1::/path/wt2': { 'b.ts': 'both_modified' }
|
||||
},
|
||||
gitBranchChangesByWorktree: {
|
||||
'repo1::/path/wt1': [{ path: 'a.ts' }],
|
||||
'repo1::/path/wt2': [{ path: 'b.ts' }]
|
||||
},
|
||||
gitBranchCompareSummaryByWorktree: {
|
||||
'repo1::/path/wt1': { status: 'ready' },
|
||||
'repo1::/path/wt2': { status: 'loading' }
|
||||
},
|
||||
gitBranchCompareRequestKeyByWorktree: {
|
||||
'repo1::/path/wt1': 'req-1',
|
||||
'repo1::/path/wt2': 'req-2'
|
||||
},
|
||||
gitBranchCompareRequestStatusHeadByWorktree: {
|
||||
'repo1::/path/wt1': 'head-1',
|
||||
'repo1::/path/wt2': 'head-2'
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().gitStatusByWorktree).toEqual({
|
||||
'repo1::/path/wt2': [{ path: 'b.ts' }]
|
||||
})
|
||||
expect(store.getState().gitStatusHeadByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'head-2'
|
||||
})
|
||||
expect(store.getState().gitBranchLineTotalByWorktree).toEqual({
|
||||
'repo1::/path/wt2': { added: 1, removed: 0, mergeBase: 'base-2' }
|
||||
})
|
||||
expect(store.getState().gitIgnoredPathsByWorktree).toEqual({
|
||||
'repo1::/path/wt2': ['coverage/']
|
||||
})
|
||||
expect(store.getState().gitConflictOperationByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'unknown'
|
||||
})
|
||||
expect(store.getState().trackedConflictPathsByWorktree).toEqual({
|
||||
'repo1::/path/wt2': { 'b.ts': 'both_modified' }
|
||||
})
|
||||
expect(store.getState().gitBranchChangesByWorktree).toEqual({
|
||||
'repo1::/path/wt2': [{ path: 'b.ts' }]
|
||||
})
|
||||
expect(store.getState().gitBranchCompareSummaryByWorktree).toEqual({
|
||||
'repo1::/path/wt2': { status: 'loading' }
|
||||
})
|
||||
expect(store.getState().gitBranchCompareRequestKeyByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'req-2'
|
||||
})
|
||||
expect(store.getState().gitBranchCompareRequestStatusHeadByWorktree).toEqual({
|
||||
'repo1::/path/wt2': 'head-2'
|
||||
})
|
||||
})
|
||||
|
||||
it('clears recentlyClosedBrowserTabsByWorktree for the removed worktree', async () => {
|
||||
// Why: undo snapshots for a deleted worktree can never be restored, so removeWorktree clears the key (design §1.1).
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
recentlyClosedBrowserTabsByWorktree: {
|
||||
'repo1::/path/wt1': [{ workspace: { id: 'workspace-1' }, pages: [] }],
|
||||
'repo1::/path/wt2': [{ workspace: { id: 'workspace-2' }, pages: [] }]
|
||||
}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().recentlyClosedBrowserTabsByWorktree).toEqual({
|
||||
'repo1::/path/wt2': [{ workspace: { id: 'workspace-2' }, pages: [] }]
|
||||
})
|
||||
})
|
||||
|
||||
it('skips editorDrafts shallow copy when no files belong to the removed worktree', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
|
||||
const drafts = { 'file-2': 'some content' }
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
openFiles: [],
|
||||
editorDrafts: drafts
|
||||
} as Partial<AppState>)
|
||||
|
||||
await store.getState().removeWorktree({ id: 'repo1::/path/wt1', executionHostId: null })
|
||||
|
||||
expect(store.getState().editorDrafts).toBe(drafts)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -104,15 +104,6 @@ it.each([
|
||||
}
|
||||
)
|
||||
|
||||
it('does not attach a source rejected by the configured-remote exact lookup', async () => {
|
||||
const { store, workspace, branchLookup } = setup()
|
||||
exactLookup.mockResolvedValue(null)
|
||||
store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
|
||||
await flush()
|
||||
expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toEqual([])
|
||||
expect(branchLookup).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it.each([false, true])(
|
||||
'checks a saved push branch and its late replacement=%s',
|
||||
async (replace) => {
|
||||
|
||||
@@ -53,136 +53,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it('waits for branch confirmation before linking a terminal PR URL for a known push target', async () => {
|
||||
const store = createTestStore()
|
||||
const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/worktrees/orca',
|
||||
branch: 'refs/heads/feature/pr-link',
|
||||
pushTarget: {
|
||||
remoteName: 'origin',
|
||||
branchName: 'feature/pr-link',
|
||||
remoteUrl: 'https://github.com/acme/orca.git'
|
||||
}
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
})
|
||||
|
||||
store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
|
||||
url: 'https://github.com/acme/orca/pull/42',
|
||||
slug: { owner: 'acme', repo: 'orca' },
|
||||
number: 42
|
||||
})
|
||||
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBeNull()
|
||||
expect(mockApi.worktrees.resolvePrBase).not.toHaveBeenCalled()
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
await vi.waitFor(() => expect(readHostedReview).toHaveBeenCalled())
|
||||
expect(readHostedReview).toHaveBeenCalledWith({
|
||||
repoPath: '/repos/orca',
|
||||
branch: 'feature/pr-link',
|
||||
force: true,
|
||||
repoId: 'repo1',
|
||||
active: true,
|
||||
repoOwnerExecutionHostId: 'local',
|
||||
currentHeadOid: wt.head,
|
||||
linkedGitHubPR: null,
|
||||
linkedGitLabMR: null,
|
||||
linkedBitbucketPR: null,
|
||||
linkedAzureDevOpsPR: null,
|
||||
linkedGiteaPR: null
|
||||
})
|
||||
for (let i = 0; i < 20; i++) {
|
||||
await Promise.resolve()
|
||||
}
|
||||
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: wt.id,
|
||||
executionHostId: 'local',
|
||||
updates: expect.objectContaining({
|
||||
linkedItems: [{ provider: 'github', type: 'pr', number: 42 }],
|
||||
linkedPR: 42,
|
||||
suppressedGitHubPR: null
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('ignores a terminal URL matching current GitHub PR suppression', () => {
|
||||
const store = createTestStore()
|
||||
const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/worktrees/orca',
|
||||
branch: 'refs/heads/feature/pr-link',
|
||||
linkedPR: null,
|
||||
suppressedGitHubPR: 42
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
})
|
||||
|
||||
store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
|
||||
url: 'https://github.com/acme/orca/pull/42',
|
||||
slug: { owner: 'acme', repo: 'orca' },
|
||||
number: 42
|
||||
})
|
||||
|
||||
expect(readHostedReview).not.toHaveBeenCalled()
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('allows terminal observation of a different PR than the suppressed one', async () => {
|
||||
const store = createTestStore()
|
||||
installReviewRead().mockResolvedValue(confirmedReview(43))
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/worktrees/orca',
|
||||
branch: 'refs/heads/feature/pr-link',
|
||||
linkedPR: null,
|
||||
suppressedGitHubPR: 42,
|
||||
pushTarget: {
|
||||
remoteName: 'origin',
|
||||
branchName: 'feature/pr-link'
|
||||
}
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
})
|
||||
|
||||
store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
|
||||
url: 'https://github.com/acme/orca/pull/43',
|
||||
slug: { owner: 'acme', repo: 'orca' },
|
||||
number: 43
|
||||
})
|
||||
for (let i = 0; i < 20; i++) {
|
||||
await Promise.resolve()
|
||||
}
|
||||
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: wt.id,
|
||||
executionHostId: 'local',
|
||||
updates: expect.objectContaining({
|
||||
linkedItems: [{ provider: 'github', type: 'pr', number: 43 }],
|
||||
linkedPR: 43,
|
||||
suppressedGitHubPR: null
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('rechecks GitHub PR suppression after branch confirmation resolves', async () => {
|
||||
const store = createTestStore()
|
||||
let resolveLookup: (value: HostedReviewInfo | null) => void = () => {}
|
||||
@@ -232,63 +102,6 @@ describe('worktree remote runtime mutations', () => {
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('waits for branch confirmation before linking a same-repo terminal PR URL', async () => {
|
||||
const store = createTestStore()
|
||||
const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/worktrees/orca',
|
||||
branch: 'refs/heads/feature/pr-link',
|
||||
pushTarget: {
|
||||
remoteName: 'origin',
|
||||
branchName: 'feature/pr-link'
|
||||
}
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
|
||||
],
|
||||
worktreesByRepo: { repo1: [wt] }
|
||||
})
|
||||
|
||||
store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
|
||||
url: 'https://github.com/acme/orca/pull/42',
|
||||
slug: { owner: 'acme', repo: 'orca' },
|
||||
number: 42
|
||||
})
|
||||
|
||||
expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBeNull()
|
||||
await vi.waitFor(() => expect(readHostedReview).toHaveBeenCalled())
|
||||
expect(readHostedReview).toHaveBeenCalledWith({
|
||||
repoPath: '/repos/orca',
|
||||
branch: 'feature/pr-link',
|
||||
force: true,
|
||||
repoId: 'repo1',
|
||||
active: true,
|
||||
repoOwnerExecutionHostId: 'local',
|
||||
currentHeadOid: wt.head,
|
||||
linkedGitHubPR: null,
|
||||
linkedGitLabMR: null,
|
||||
linkedBitbucketPR: null,
|
||||
linkedAzureDevOpsPR: null,
|
||||
linkedGiteaPR: null
|
||||
})
|
||||
for (let i = 0; i < 20; i++) {
|
||||
await Promise.resolve()
|
||||
}
|
||||
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: wt.id,
|
||||
executionHostId: 'local',
|
||||
updates: expect.objectContaining({
|
||||
linkedItems: [{ provider: 'github', type: 'pr', number: 42 }],
|
||||
linkedPR: 42,
|
||||
suppressedGitHubPR: null
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('preserves a manual primary while appending a PR confirmed after the selection changes', async () => {
|
||||
const store = createTestStore()
|
||||
let resolveLookup: (value: HostedReviewInfo | null) => void = () => {}
|
||||
|
||||
@@ -203,43 +203,6 @@ describe('terminal reference evidence', () => {
|
||||
expect.objectContaining({ hostId: 'local', tabId: 'tab-1' })
|
||||
])
|
||||
})
|
||||
it('confirms a number-only secondary attachment without requiring it to be the primary review', async () => {
|
||||
const { store } = setup()
|
||||
const workspace = store.getState().worktreesByRepo.repo1[0]
|
||||
const readHostedReview = installReviewRead().mockResolvedValue({
|
||||
provider: 'github',
|
||||
number: 42,
|
||||
title: 'Secondary',
|
||||
state: 'open',
|
||||
url,
|
||||
status: 'success',
|
||||
mergeable: 'MERGEABLE',
|
||||
updatedAt: '2026-01-01'
|
||||
})
|
||||
store.setState({
|
||||
worktreesByRepo: {
|
||||
repo1: [
|
||||
{
|
||||
...workspace,
|
||||
linkedItems: [
|
||||
...getWorkspaceAttachments(workspace),
|
||||
{
|
||||
provider: 'github',
|
||||
type: 'pr',
|
||||
number: 42
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
})
|
||||
store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
|
||||
await flush()
|
||||
expect(readHostedReview).toHaveBeenCalledWith(expect.objectContaining({ linkedGitHubPR: 42 }))
|
||||
const current = store.getState().worktreesByRepo.repo1[0]
|
||||
expect(current.linkedPR).toBe(7)
|
||||
expect(getWorkspaceAttachments(current)[1].origins?.[0].tabId).toBe('tab-1')
|
||||
})
|
||||
it('rejects a different provider returned by owner-scoped branch confirmation', async () => {
|
||||
const { store } = setup()
|
||||
installReviewRead().mockResolvedValue({
|
||||
@@ -256,17 +219,6 @@ describe('terminal reference evidence', () => {
|
||||
await flush()
|
||||
expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
|
||||
})
|
||||
it('adds a second confirmed PR without changing which review is used for checks', async () => {
|
||||
const { store } = setup()
|
||||
store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
|
||||
await flush()
|
||||
const workspace = store.getState().worktreesByRepo.repo1[0]
|
||||
expect(workspace.linkedPR).toBe(7)
|
||||
expect(getWorkspaceAttachments(workspace).map((item) => item.number)).toEqual([7, 42])
|
||||
expect(getWorkspaceAttachments(workspace)[1].origins).toEqual([
|
||||
expect.objectContaining({ kind: 'observed', tabId: 'tab-1', hostId: 'local' })
|
||||
])
|
||||
})
|
||||
it('records two terminals for one PR and keeps repeated evidence deduplicated', async () => {
|
||||
const { store, readHostedReview } = setup()
|
||||
for (const tabId of ['tab-1', 'tab-2', 'tab-2']) {
|
||||
@@ -280,28 +232,6 @@ describe('terminal reference evidence', () => {
|
||||
).toEqual(['tab-1', 'tab-2'])
|
||||
expect(readHostedReview.mock.calls.filter(([args]) => args.active === true)).toHaveLength(1)
|
||||
})
|
||||
it('does not associate a same-number PR from a different repository', async () => {
|
||||
const { store } = setup()
|
||||
store
|
||||
.getState()
|
||||
.observeTerminalGitHubPullRequestLink(
|
||||
worktreeId,
|
||||
{ ...link, url: 'https://github.com/other/repo/pull/42' },
|
||||
context('tab-1')
|
||||
)
|
||||
await flush()
|
||||
expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
|
||||
})
|
||||
it('does not write after a failed confirmation', async () => {
|
||||
const { store, readHostedReview } = setup()
|
||||
readHostedReview.mockRejectedValue(new Error('Offline'))
|
||||
const warning = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
|
||||
await flush()
|
||||
expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
|
||||
expect(warning).toHaveBeenCalled()
|
||||
warning.mockRestore()
|
||||
})
|
||||
it('ignores a stale PTY even when its caller supplies an execution host', async () => {
|
||||
const { store, readHostedReview } = setup()
|
||||
store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, {
|
||||
|
||||
@@ -36,72 +36,6 @@ describe('worktree unread (show-until-interact)', () => {
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it('marking sets isUnread even when the worktree is active', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: wt.id
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().markAgentAttentionUnread({
|
||||
workspaceId: wt.id,
|
||||
subjectKey: null,
|
||||
groupId: null,
|
||||
reason: 'agent-completion'
|
||||
})
|
||||
|
||||
const after = store.getState().worktreesByRepo.repo1[0]
|
||||
expect(after.isUnread).toBe(true)
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
worktreeId: wt.id,
|
||||
updates: expect.objectContaining({ isUnread: true })
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it('routes multi-host project unread persistence by the worktree host (#10634)', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo-shared::/home/user/wt',
|
||||
repoId: 'repo-shared',
|
||||
path: '/home/user/wt',
|
||||
hostId: 'ssh:ssh-1'
|
||||
})
|
||||
store.setState({
|
||||
repos: [
|
||||
{ id: 'repo-shared', path: '/local', displayName: 'Local', badgeColor: '#000', addedAt: 0 },
|
||||
{
|
||||
id: 'repo-shared',
|
||||
path: '/home/user/repo',
|
||||
displayName: 'SSH',
|
||||
badgeColor: '#111',
|
||||
addedAt: 1,
|
||||
connectionId: 'ssh-1'
|
||||
}
|
||||
],
|
||||
worktreesByRepo: { 'repo-shared': [wt] }
|
||||
} as Partial<AppState>)
|
||||
|
||||
expect(() =>
|
||||
store.getState().markAgentAttentionUnread({
|
||||
workspaceId: wt.id,
|
||||
subjectKey: null,
|
||||
groupId: null,
|
||||
reason: 'agent-completion'
|
||||
})
|
||||
).not.toThrow()
|
||||
|
||||
expect(store.getState().worktreesByRepo['repo-shared'][0].isUnread).toBe(true)
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
worktreeId: wt.id,
|
||||
updates: expect.objectContaining({ isUnread: true })
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps unread state local instead of throwing for genuinely ambiguous owners (#10634)', () => {
|
||||
const store = createTestStore()
|
||||
const worktreeId = 'repo-shared::/same/path'
|
||||
@@ -188,74 +122,6 @@ describe('worktree unread (show-until-interact)', () => {
|
||||
}
|
||||
})
|
||||
|
||||
it('warns once per workspace rather than on every activity event (#10634)', () => {
|
||||
// Why: activity bumps fire on every PTY event; an unbounded warn would flood the console.
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
try {
|
||||
const worktreeId = 'repo-spam::/same/path'
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
settings: { activeRuntimeEnvironmentId: 'hub-c' } as never,
|
||||
worktreesByRepo: {
|
||||
'repo-spam': [
|
||||
makeWorktree({ id: worktreeId, repoId: 'repo-spam', hostId: 'ssh:ssh-a' }),
|
||||
makeWorktree({ id: worktreeId, repoId: 'repo-spam', hostId: 'ssh:ssh-b' })
|
||||
]
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
const before = warn.mock.calls.length
|
||||
for (let i = 0; i < 5; i++) {
|
||||
store.getState().bumpWorktreeActivity(worktreeId)
|
||||
}
|
||||
|
||||
expect(warn.mock.calls.length - before).toBe(1)
|
||||
} finally {
|
||||
warn.mockRestore()
|
||||
}
|
||||
})
|
||||
|
||||
it('reading clears isUnread and persists the change', async () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({
|
||||
id: 'repo1::/path/wt1',
|
||||
repoId: 'repo1',
|
||||
path: '/path/wt1',
|
||||
isUnread: true
|
||||
})
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: wt.id
|
||||
} as Partial<AppState>)
|
||||
|
||||
store
|
||||
.getState()
|
||||
.readOnScreenAttention({ workspaceIds: [wt.id], targets: [] }, { screenArrived: true })
|
||||
|
||||
const after = store.getState().worktreesByRepo.repo1[0]
|
||||
expect(after.isUnread).toBe(false)
|
||||
expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
worktreeId: wt.id,
|
||||
updates: { isUnread: false }
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it('reading is a no-op when already cleared', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', path: '/path/wt1' })
|
||||
const initial = { repo1: [wt] }
|
||||
store.setState({ worktreesByRepo: initial } as Partial<AppState>)
|
||||
|
||||
store
|
||||
.getState()
|
||||
.readOnScreenAttention({ workspaceIds: [wt.id], targets: [] }, { screenArrived: true })
|
||||
|
||||
expect(store.getState().worktreesByRepo).toBe(initial)
|
||||
expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('updates unread state for hidden detected worktrees', () => {
|
||||
const store = createTestStore()
|
||||
const hidden = makeWorktree({
|
||||
|
||||
@@ -4,14 +4,9 @@ import {
|
||||
registerPersistentWebview,
|
||||
unregisterPersistentWebview
|
||||
} from '../../components/browser-pane/host-guest/webview-registry'
|
||||
import { folderWorkspaceKey, worktreeWorkspaceKey } from '../../../../shared/workspace-scope'
|
||||
import { makeDetectedResult } from './worktrees-detected-listing-fixtures'
|
||||
import {
|
||||
createWebview,
|
||||
makeFolderWorkspace,
|
||||
makeLineage,
|
||||
makeWorktree
|
||||
} from './worktrees-slice-test-fixtures'
|
||||
import '../../../../shared/workspace-scope'
|
||||
import './worktrees-detected-listing-fixtures'
|
||||
import { createWebview, makeWorktree } from './worktrees-slice-test-fixtures'
|
||||
import {
|
||||
createTestStore,
|
||||
mockApi,
|
||||
@@ -37,24 +32,6 @@ vi.mock('@/components/worktree-base-fallback-notice', () => ({
|
||||
|
||||
beforeEach(resetWorktreeSliceModuleMemory)
|
||||
|
||||
describe('folder workspace lookups', () => {
|
||||
it('returns a stable synthetic worktree for repeated folder workspace lookups', () => {
|
||||
const store = createTestStore()
|
||||
const folderWorkspace = makeFolderWorkspace()
|
||||
store.setState({ folderWorkspaces: [folderWorkspace] } as Partial<AppState>)
|
||||
|
||||
const first = store.getState().getKnownWorktreeById(folderWorkspaceKey(folderWorkspace.id))
|
||||
const second = store.getState().getKnownWorktreeById(folderWorkspaceKey(folderWorkspace.id))
|
||||
|
||||
expect(second).toBe(first)
|
||||
expect(first).toMatchObject({
|
||||
id: folderWorkspaceKey(folderWorkspace.id),
|
||||
displayName: folderWorkspace.name,
|
||||
path: folderWorkspace.folderPath
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('setActiveWorktree focus handling', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
@@ -112,661 +89,4 @@ describe('setActiveWorktree focus handling', () => {
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
it('repairs a stale workspace key when reactivating the current worktree', () => {
|
||||
const store = createTestStore()
|
||||
const worktree = makeWorktree({ id: 'repo1::/path/current', repoId: 'repo1' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [worktree] },
|
||||
activeWorktreeId: worktree.id,
|
||||
activeWorkspaceKey: worktreeWorkspaceKey('repo1::/path/stale'),
|
||||
activeWorkspaceExecutionHostId: null,
|
||||
activeTabTypeByWorktree: { [worktree.id]: 'terminal' },
|
||||
rightSidebarExplorerView: 'files',
|
||||
everActivatedWorktreeIds: new Set([worktree.id])
|
||||
})
|
||||
|
||||
store.getState().setActiveWorktree(worktree.id)
|
||||
|
||||
expect(store.getState().activeWorkspaceKey).toBe(worktreeWorkspaceKey(worktree.id))
|
||||
})
|
||||
})
|
||||
|
||||
describe('markWorktreeVisited', () => {
|
||||
it('stamps a host-qualified key when the worktree owner is known', () => {
|
||||
const store = createTestStore()
|
||||
const worktree = makeWorktree({ id: 'repo1::/hosted', repoId: 'repo1', hostId: 'ssh:builder' })
|
||||
store.setState({ worktreesByRepo: { repo1: [worktree] } } as Partial<AppState>)
|
||||
|
||||
store.getState().markWorktreeVisited(worktree.id, 1000)
|
||||
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({
|
||||
[`ssh:builder|${worktree.id}`]: 1000
|
||||
})
|
||||
})
|
||||
|
||||
it('is monotonic: an older timestamp does not regress the stored value', () => {
|
||||
const store = createTestStore()
|
||||
store.getState().markWorktreeVisited('wt-1', 1000)
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBe(1000)
|
||||
|
||||
store.getState().markWorktreeVisited('wt-1', 500)
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBe(1000)
|
||||
|
||||
store.getState().markWorktreeVisited('wt-1', 1000)
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBe(1000)
|
||||
|
||||
store.getState().markWorktreeVisited('wt-1', 2000)
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBe(2000)
|
||||
})
|
||||
|
||||
it('seedActiveWorktreeLastVisitedIfMissing seeds only when missing', () => {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
activeWorktreeId: 'wt-1',
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as Partial<AppState>)
|
||||
store.getState().seedActiveWorktreeLastVisitedIfMissing()
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBeTypeOf('number')
|
||||
|
||||
const existing = store.getState().lastVisitedAtByWorktreeId['wt-1']
|
||||
store.getState().seedActiveWorktreeLastVisitedIfMissing()
|
||||
expect(store.getState().lastVisitedAtByWorktreeId['wt-1']).toBe(existing)
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps drops entries for unknown worktree IDs within hydrated repos', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
lastVisitedAtByWorktreeId: { 'repo1::/a': 100, 'repo1::/gone': 200 }
|
||||
} as Partial<AppState>)
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({ 'repo1::/a': 100 })
|
||||
})
|
||||
|
||||
it('prunes host-qualified recency by host while retaining a same-id twin', () => {
|
||||
const store = createTestStore()
|
||||
const id = 'repo1::/shared'
|
||||
const local = makeWorktree({ id, repoId: 'repo1', path: '/shared', hostId: 'local' })
|
||||
const ssh = makeWorktree({ id, repoId: 'repo1', path: '/shared', hostId: 'ssh:builder' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [local, ssh] },
|
||||
lastVisitedAtByWorktreeId: {
|
||||
[`local|${id}`]: 100,
|
||||
[`ssh:builder|${id}`]: 200,
|
||||
'local|repo1::/gone': 300
|
||||
}
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({
|
||||
[`local|${id}`]: 100,
|
||||
[`ssh:builder|${id}`]: 200
|
||||
})
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps preserves entries for not-yet-hydrated repos (e.g. SSH pre-connect)', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
lastVisitedAtByWorktreeId: { 'repo1::/a': 100, 'ssh-repo::/b': 200 }
|
||||
} as Partial<AppState>)
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({
|
||||
'repo1::/a': 100,
|
||||
'ssh-repo::/b': 200
|
||||
})
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps clears a stale activeWorktreeId gone from a hydrated repo', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/gone',
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as Partial<AppState>)
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
expect(store.getState().activeWorktreeId).toBeNull()
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps keeps a live activeWorktreeId and defers unhydrated repos', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/a'
|
||||
} as Partial<AppState>)
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
expect(store.getState().activeWorktreeId).toBe('repo1::/a')
|
||||
|
||||
// A pointer into a not-yet-hydrated (e.g. SSH pre-connect) repo is deferred.
|
||||
store.setState({ activeWorktreeId: 'ssh-repo::/b' } as Partial<AppState>)
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
expect(store.getState().activeWorktreeId).toBe('ssh-repo::/b')
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps defers when the detected list is non-authoritative', () => {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [] },
|
||||
detectedWorktreesByRepo: {
|
||||
repo1: makeDetectedResult('repo1', [], {
|
||||
authoritative: false,
|
||||
source: 'metadata-fallback'
|
||||
})
|
||||
},
|
||||
lastVisitedAtByWorktreeId: { 'repo1::/hidden': 100 }
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({ 'repo1::/hidden': 100 })
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps defers an empty list with no detected record (unhydrated shape)', () => {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [] },
|
||||
lastVisitedAtByWorktreeId: { 'repo1::/hidden': 100 }
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
// An empty list is the not-yet-hydrated shape, not an authoritative "no worktrees",
|
||||
// so focus-recency is kept until an authoritative scan lands.
|
||||
expect(store.getState().lastVisitedAtByWorktreeId).toEqual({ 'repo1::/hidden': 100 })
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps clears the derived worktree-scoped active workspace key with a stale active worktree', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/gone',
|
||||
activeWorkspaceKey: worktreeWorkspaceKey('repo1::/gone'),
|
||||
activeWorkspaceExecutionHostId: 'local',
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().activeWorktreeId).toBeNull()
|
||||
// The derived workspace key would keep the phantom workspace selected, so it goes too.
|
||||
expect(store.getState().activeWorkspaceKey).toBeNull()
|
||||
expect(store.getState().activeWorkspaceExecutionHostId).toBeNull()
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps preserves a folder-scoped active workspace key when the active worktree is stale', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/gone',
|
||||
activeWorkspaceKey: folderWorkspaceKey('folder-1'),
|
||||
activeWorkspaceExecutionHostId: 'local',
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().activeWorktreeId).toBeNull()
|
||||
// Folder-scoped keys are never dropped here (matches the removal paths).
|
||||
expect(store.getState().activeWorkspaceKey).toBe(folderWorkspaceKey('folder-1'))
|
||||
expect(store.getState().activeWorkspaceExecutionHostId).toBeNull()
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps preserves an active workspace key pointing at a different live worktree', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/gone',
|
||||
activeWorkspaceKey: worktreeWorkspaceKey('repo1::/a'),
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().activeWorktreeId).toBeNull()
|
||||
// Only the stale worktree's own derived key is dropped.
|
||||
expect(store.getState().activeWorkspaceKey).toBe(worktreeWorkspaceKey('repo1::/a'))
|
||||
})
|
||||
|
||||
it('pruneLastVisitedTimestamps clears a legacy unprefixed active workspace key for the stale worktree', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a' })
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: 'repo1::/gone',
|
||||
// Sessions predating the `worktree:` prefix stored the bare id (see the purge path).
|
||||
activeWorkspaceKey: 'repo1::/gone',
|
||||
lastVisitedAtByWorktreeId: {}
|
||||
} as unknown as Partial<AppState>)
|
||||
|
||||
store.getState().pruneLastVisitedTimestamps()
|
||||
|
||||
expect(store.getState().activeWorktreeId).toBeNull()
|
||||
expect(store.getState().activeWorkspaceKey).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('setRenamingWorktreeId', () => {
|
||||
it('sets and clears the workspace rename signal', () => {
|
||||
const store = createTestStore()
|
||||
|
||||
expect(store.getState().renamingWorktreeId).toBeNull()
|
||||
|
||||
store.getState().setRenamingWorktreeId('repo1::/feature')
|
||||
expect(store.getState().renamingWorktreeId).toEqual({ worktreeId: 'repo1::/feature' })
|
||||
|
||||
store.getState().setRenamingWorktreeId(null)
|
||||
expect(store.getState().renamingWorktreeId).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('setWorktreesPinnedAndReveal', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
resetRemoteRuntimeMocks()
|
||||
})
|
||||
|
||||
it('pins the focused worktree and reveals it so the viewport follows it into the Pinned section', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: false })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: wt.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([wt], true)
|
||||
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(true)
|
||||
expect(reveal).toHaveBeenCalledWith(wt.id, { behavior: 'smooth', highlight: true })
|
||||
})
|
||||
|
||||
it('reveals on unpin of the focused worktree so the viewport follows it back to its status group', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: true })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
activeWorktreeId: wt.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([wt], false)
|
||||
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(false)
|
||||
expect(reveal).toHaveBeenCalledWith(wt.id, { behavior: 'smooth', highlight: true })
|
||||
})
|
||||
|
||||
it('does not scroll when unpinning an unfocused worktree, but still unpins it', () => {
|
||||
const store = createTestStore()
|
||||
const focused = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: false })
|
||||
const pinned = makeWorktree({ id: 'repo1::/b', repoId: 'repo1', path: '/b', isPinned: true })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [focused, pinned] },
|
||||
activeWorktreeId: focused.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([pinned], false)
|
||||
|
||||
// The row unpins, but the viewport stays put because it isn't focused.
|
||||
expect(store.getState().worktreesByRepo.repo1[1].isPinned).toBe(false)
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('does not scroll when pinning an unfocused worktree, but still pins it', () => {
|
||||
const store = createTestStore()
|
||||
const focused = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: false })
|
||||
const other = makeWorktree({ id: 'repo1::/b', repoId: 'repo1', path: '/b', isPinned: false })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [focused, other] },
|
||||
activeWorktreeId: focused.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([other], true)
|
||||
|
||||
expect(store.getState().worktreesByRepo.repo1[1].isPinned).toBe(true)
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it("never scrolls to the focused card for its same-id twin's pin, and reveals the focused copy by host", () => {
|
||||
const store = createTestStore()
|
||||
const local = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', hostId: 'local' })
|
||||
const ssh = makeWorktree({ ...local, hostId: 'ssh:box' })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [local, ssh] },
|
||||
activeWorktreeId: local.id,
|
||||
activeWorkspaceExecutionHostId: 'local',
|
||||
revealWorktreeInSidebar: reveal
|
||||
})
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([ssh], true)
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([local], true)
|
||||
expect(reveal).toHaveBeenCalledWith(local.id, {
|
||||
behavior: 'smooth',
|
||||
highlight: true,
|
||||
executionHostId: 'local'
|
||||
})
|
||||
})
|
||||
|
||||
it.each([
|
||||
{ previousPinned: false, nextPinned: true },
|
||||
{ previousPinned: true, nextPinned: false }
|
||||
])(
|
||||
'reveals the focused descendant when changing its unfocused ancestor from $previousPinned to $nextPinned',
|
||||
({ previousPinned, nextPinned }) => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repo1::/parent',
|
||||
instanceId: 'parent-instance',
|
||||
repoId: 'repo1',
|
||||
isPinned: previousPinned
|
||||
})
|
||||
const child = makeWorktree({
|
||||
id: 'repo1::/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [parent, child] },
|
||||
worktreeLineageById: {
|
||||
[child.id]: makeLineage({ worktreeId: child.id, parentWorktreeId: parent.id })
|
||||
},
|
||||
activeWorktreeId: child.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([parent], nextPinned)
|
||||
|
||||
expect(reveal).toHaveBeenCalledWith(child.id, { behavior: 'smooth', highlight: true })
|
||||
}
|
||||
)
|
||||
|
||||
it("follows a server-proxied focused row selected by its server's runtime alias", () => {
|
||||
const store = createTestStore()
|
||||
const proxied = makeWorktree({
|
||||
id: 'repo1::/a',
|
||||
repoId: 'repo1',
|
||||
path: '/a',
|
||||
hostId: 'ssh:box',
|
||||
runtimeOwnerEnvironmentId: 'hub'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [proxied] },
|
||||
activeWorktreeId: proxied.id,
|
||||
activeWorkspaceExecutionHostId: 'runtime:hub',
|
||||
revealWorktreeInSidebar: reveal
|
||||
})
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([proxied], true)
|
||||
|
||||
expect(reveal).toHaveBeenCalledWith(proxied.id, {
|
||||
behavior: 'smooth',
|
||||
highlight: true,
|
||||
executionHostId: 'ssh:box'
|
||||
})
|
||||
})
|
||||
|
||||
it("does not reveal the focused descendant for its ancestor's twin on another host", () => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repo1::/parent',
|
||||
instanceId: 'parent-instance',
|
||||
repoId: 'repo1',
|
||||
hostId: 'local'
|
||||
})
|
||||
const parentTwin = makeWorktree({ ...parent, hostId: 'ssh:box' })
|
||||
const child = makeWorktree({
|
||||
id: 'repo1::/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repo1',
|
||||
hostId: 'local'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [parent, parentTwin, child] },
|
||||
worktreeLineageById: {
|
||||
[child.id]: makeLineage({ worktreeId: child.id, parentWorktreeId: parent.id })
|
||||
},
|
||||
activeWorktreeId: child.id,
|
||||
activeWorkspaceExecutionHostId: 'local',
|
||||
revealWorktreeInSidebar: reveal
|
||||
})
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([parentTwin], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('reveals the focused descendant from embedded legacy lineage', () => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repo1::/parent',
|
||||
instanceId: 'parent-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const child = {
|
||||
...makeWorktree({
|
||||
id: 'repo1::/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repo1'
|
||||
}),
|
||||
lineage: makeLineage({ worktreeId: 'repo1::/child', parentWorktreeId: parent.id })
|
||||
}
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [parent, child] },
|
||||
activeWorktreeId: child.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([parent], true)
|
||||
|
||||
expect(reveal).toHaveBeenCalledWith(child.id, { behavior: 'smooth', highlight: true })
|
||||
})
|
||||
|
||||
it('does not reveal through cyclic lineage rejected by rendering', () => {
|
||||
const store = createTestStore()
|
||||
const first = makeWorktree({
|
||||
id: 'repo1::/first',
|
||||
instanceId: 'first-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const second = makeWorktree({
|
||||
id: 'repo1::/second',
|
||||
instanceId: 'second-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [first, second] },
|
||||
worktreeLineageById: {
|
||||
[first.id]: makeLineage({
|
||||
worktreeId: first.id,
|
||||
worktreeInstanceId: first.instanceId,
|
||||
parentWorktreeId: second.id,
|
||||
parentWorktreeInstanceId: second.instanceId
|
||||
}),
|
||||
[second.id]: makeLineage({
|
||||
worktreeId: second.id,
|
||||
worktreeInstanceId: second.instanceId,
|
||||
parentWorktreeId: first.id,
|
||||
parentWorktreeInstanceId: first.instanceId
|
||||
})
|
||||
},
|
||||
activeWorktreeId: second.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([first], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('does not reveal a focused descendant for duplicate pinned rows', () => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repo1::/parent',
|
||||
instanceId: 'parent-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const child = makeWorktree({
|
||||
id: 'repo1::/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [parent, child] },
|
||||
worktreeLineageById: {
|
||||
[child.id]: makeLineage({ worktreeId: child.id, parentWorktreeId: parent.id })
|
||||
},
|
||||
activeWorktreeId: child.id,
|
||||
settings: { ...store.getState().settings, showPinnedWorktreesInGroups: true },
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([parent], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('does not reveal through stale lineage', () => {
|
||||
const store = createTestStore()
|
||||
const parent = makeWorktree({
|
||||
id: 'repo1::/parent',
|
||||
instanceId: 'replacement-parent-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const child = makeWorktree({
|
||||
id: 'repo1::/child',
|
||||
instanceId: 'child-instance',
|
||||
repoId: 'repo1'
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [parent, child] },
|
||||
worktreeLineageById: {
|
||||
[child.id]: makeLineage({ worktreeId: child.id, parentWorktreeId: parent.id })
|
||||
},
|
||||
activeWorktreeId: child.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([parent], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('skips a no-op toggle without requesting a reveal', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: true })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([wt], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(true)
|
||||
})
|
||||
|
||||
it('does nothing for an unknown worktree id', () => {
|
||||
const store = createTestStore()
|
||||
const wt = makeWorktree({ id: 'repo1::/a', repoId: 'repo1', path: '/a', isPinned: false })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [wt] },
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([{ id: 'repo1::/missing' }], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(false)
|
||||
})
|
||||
|
||||
it('does nothing for an empty id list', () => {
|
||||
const store = createTestStore()
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [] },
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('pins several at once and reveals the focused row even when it is not first', () => {
|
||||
const store = createTestStore()
|
||||
const alreadyPinned = makeWorktree({
|
||||
id: 'repo1::/a',
|
||||
repoId: 'repo1',
|
||||
path: '/a',
|
||||
isPinned: true
|
||||
})
|
||||
const first = makeWorktree({ id: 'repo1::/b', repoId: 'repo1', path: '/b', isPinned: false })
|
||||
const focused = makeWorktree({ id: 'repo1::/c', repoId: 'repo1', path: '/c', isPinned: false })
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [alreadyPinned, first, focused] },
|
||||
activeWorktreeId: focused.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([alreadyPinned, first, focused], true)
|
||||
|
||||
// Only the focused row is revealed, not the first-changed one.
|
||||
expect(reveal).toHaveBeenCalledTimes(1)
|
||||
expect(reveal).toHaveBeenCalledWith(focused.id, { behavior: 'smooth', highlight: true })
|
||||
// Every targeted row is pinned, not just the revealed one; the already-pinned row is untouched.
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(true)
|
||||
expect(store.getState().worktreesByRepo.repo1[1].isPinned).toBe(true)
|
||||
expect(store.getState().worktreesByRepo.repo1[2].isPinned).toBe(true)
|
||||
})
|
||||
|
||||
it('pins several at once without scrolling when none of them are focused', () => {
|
||||
const store = createTestStore()
|
||||
const first = makeWorktree({ id: 'repo1::/b', repoId: 'repo1', path: '/b', isPinned: false })
|
||||
const second = makeWorktree({ id: 'repo1::/c', repoId: 'repo1', path: '/c', isPinned: false })
|
||||
const elsewhere = makeWorktree({
|
||||
id: 'repo1::/z',
|
||||
repoId: 'repo1',
|
||||
path: '/z',
|
||||
isPinned: false
|
||||
})
|
||||
const reveal = vi.fn()
|
||||
store.setState({
|
||||
worktreesByRepo: { repo1: [first, second, elsewhere] },
|
||||
activeWorktreeId: elsewhere.id,
|
||||
revealWorktreeInSidebar: reveal
|
||||
} as Partial<AppState>)
|
||||
|
||||
store.getState().setWorktreesPinnedAndReveal([first, second], true)
|
||||
|
||||
expect(reveal).not.toHaveBeenCalled()
|
||||
expect(store.getState().worktreesByRepo.repo1[0].isPinned).toBe(true)
|
||||
expect(store.getState().worktreesByRepo.repo1[1].isPinned).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -104,21 +104,4 @@ describe('row writers touch only the copy on their own host', () => {
|
||||
expect(onLocal(WORKTREE_ID)).toMatchObject({ parentWorktreeId: null })
|
||||
expect(onLocal(PARENT_ID)).toMatchObject({ childWorktreeIds: [] })
|
||||
})
|
||||
|
||||
it("never appends a server's copy when only the local twin is listed", () => {
|
||||
const store = createTestStore()
|
||||
const { local } = seedTwins(store)
|
||||
store.setState({ worktreesByRepo: { [REPO_ID]: [local] } })
|
||||
applyWorktreeLineageUpdate(store.setState, WORKTREE_ID, {
|
||||
target: { kind: 'environment', environmentId: 'hub' },
|
||||
hostId: 'runtime:hub',
|
||||
lineage: null,
|
||||
updatedRemoteWorktree: makeWorktree({
|
||||
id: WORKTREE_ID,
|
||||
repoId: REPO_ID,
|
||||
displayName: 'server after lineage'
|
||||
})
|
||||
})
|
||||
expect(store.getState().worktreesByRepo[REPO_ID]).toEqual([local])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,12 +1,7 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { hostWorktreeTarget } from '../../../../../../shared/worktree/host-qualified-identity'
|
||||
import type { FolderWorkspace } from '../../../../../../shared/folder-workspace-types'
|
||||
import type { DetectedWorktreeListResult } from '../../../../../../shared/worktree/types'
|
||||
import {
|
||||
applyDetectedWorktreeUpdates,
|
||||
folderWorkspaceMatchesHost,
|
||||
findKnownWorktreeById
|
||||
} from './detected-worktree-meta'
|
||||
|
||||
import { findKnownWorktreeById } from './detected-worktree-meta'
|
||||
import {
|
||||
makeFolderWorkspace,
|
||||
makeProjectGroup
|
||||
@@ -115,85 +110,3 @@ describe('inherited folder consumer identity', () => {
|
||||
}
|
||||
)
|
||||
})
|
||||
|
||||
describe('folderWorkspaceMatchesHost', () => {
|
||||
it('prefers the host stamp, then the connection id, then local', () => {
|
||||
type Row = Pick<FolderWorkspace, 'connectionId' | 'executionHostId'>
|
||||
const ssh: Row = { executionHostId: 'ssh:target-1', connectionId: null }
|
||||
expect(folderWorkspaceMatchesHost(ssh, 'ssh:target-1')).toBe(true)
|
||||
expect(folderWorkspaceMatchesHost(ssh, 'local')).toBe(false)
|
||||
const stamped: Row = { executionHostId: 'runtime:env-1', connectionId: 'target-1' }
|
||||
expect(folderWorkspaceMatchesHost(stamped, 'runtime:env-1')).toBe(true)
|
||||
expect(folderWorkspaceMatchesHost(stamped, 'ssh:target-1')).toBe(false)
|
||||
const legacy: Row = { executionHostId: undefined, connectionId: 'target-1' }
|
||||
expect(folderWorkspaceMatchesHost(legacy, 'ssh:target-1')).toBe(true)
|
||||
expect(folderWorkspaceMatchesHost({ connectionId: ' ' }, 'local')).toBe(true)
|
||||
expect(folderWorkspaceMatchesHost({ connectionId: null }, 'local')).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('applyDetectedWorktreeUpdates display-name provenance', () => {
|
||||
it('projects pinning changes into detected rows', () => {
|
||||
const detected = {
|
||||
id: 'repo-1::/workspace/feature',
|
||||
displayName: 'feature',
|
||||
displayNameMode: 'automatic',
|
||||
repoId: 'repo-1',
|
||||
branch: 'refs/heads/feature'
|
||||
}
|
||||
const state = {
|
||||
'repo-1': {
|
||||
repoId: 'repo-1',
|
||||
authoritative: true,
|
||||
source: 'git',
|
||||
worktrees: [detected]
|
||||
}
|
||||
} as unknown as Record<string, DetectedWorktreeListResult>
|
||||
|
||||
const fixed = applyDetectedWorktreeUpdates(state, detected.id, {
|
||||
displayName: 'Agent workspace',
|
||||
displayNameIsPinned: true
|
||||
})
|
||||
expect(fixed['repo-1']?.worktrees[0]).toMatchObject({
|
||||
displayName: 'Agent workspace',
|
||||
displayNameMode: 'fixed'
|
||||
})
|
||||
|
||||
const automatic = applyDetectedWorktreeUpdates(state, detected.id, {
|
||||
displayName: '',
|
||||
displayNameIsPinned: false
|
||||
})
|
||||
expect(automatic['repo-1']?.worktrees[0]).toMatchObject({
|
||||
displayName: 'feature',
|
||||
displayNameMode: 'automatic'
|
||||
})
|
||||
})
|
||||
|
||||
it('keeps text until the host resolves a detached fallback', () => {
|
||||
const detached = {
|
||||
id: 'repo-1::/workspace/feature',
|
||||
displayName: 'Agent workspace',
|
||||
displayNameMode: 'fixed' as const,
|
||||
repoId: 'repo-1',
|
||||
branch: ''
|
||||
}
|
||||
const detachedState = {
|
||||
'repo-1': {
|
||||
repoId: 'repo-1',
|
||||
authoritative: true,
|
||||
source: 'git',
|
||||
worktrees: [detached]
|
||||
}
|
||||
} as unknown as Record<string, DetectedWorktreeListResult>
|
||||
|
||||
const automatic = applyDetectedWorktreeUpdates(detachedState, detached.id, {
|
||||
displayName: '',
|
||||
displayNameIsPinned: false
|
||||
})
|
||||
|
||||
expect(automatic['repo-1']?.worktrees[0]).toMatchObject({
|
||||
displayName: 'Agent workspace',
|
||||
displayNameMode: 'automatic'
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
-26
@@ -196,7 +196,6 @@ describe('a listing versioned before an applied create', () => {
|
||||
const HOST = 'host-epoch-1'
|
||||
const before = { epoch: HOST, sequence: 6 }
|
||||
const createReply = { epoch: HOST, sequence: 7 }
|
||||
const after = { epoch: HOST, sequence: 8 }
|
||||
|
||||
beforeEach(() => {
|
||||
resetStructuredAgentLaunchPersistenceForTests()
|
||||
@@ -231,31 +230,6 @@ describe('a listing versioned before an applied create', () => {
|
||||
expect(state.detectedWorktreesByRepo[REPO_ID]!.worktrees.map((w) => w.id)).toContain(CREATED_ID)
|
||||
})
|
||||
|
||||
it('reports a listing whose repo owner went away as not-current, even when also older', () => {
|
||||
const store = createTestStore()
|
||||
seedWithAppliedCreate(store)
|
||||
store.setState({ repos: [] })
|
||||
const existingRow = store.getState().worktreesByRepo[REPO_ID]![0]!
|
||||
|
||||
expect(applyListing(store, [existingRow], before)).toBe('not-current')
|
||||
|
||||
expect(store.getState().unifiedTabsByWorktree[CREATED_ID]).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('a later listing that includes the worktree applies and advances the version', () => {
|
||||
const store = createTestStore()
|
||||
seedWithAppliedCreate(store)
|
||||
const rows = store.getState().worktreesByRepo[REPO_ID]!
|
||||
|
||||
expect(applyListing(store, [...rows], after)).toBe('applied')
|
||||
|
||||
const state = store.getState()
|
||||
expect(state.activeWorktreeId).toBe(CREATED_ID)
|
||||
expect(
|
||||
state.worktreeCatalogVersionByRepoHost[worktreeCatalogVersionKey(REPO_ID, 'local')]
|
||||
).toEqual(after)
|
||||
})
|
||||
|
||||
it('a listing from a restarted host is a new catalog, not an older one', () => {
|
||||
const store = createTestStore()
|
||||
seedWithAppliedCreate(store)
|
||||
|
||||
-19
@@ -1,19 +0,0 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { getDefaultSettings } from '../../../../../../shared/constants'
|
||||
import { repoHostId } from './worktree-host-ownership'
|
||||
|
||||
const focused = { ...getDefaultSettings('/home/me'), activeRuntimeEnvironmentId: 'env-1' }
|
||||
|
||||
describe('repoHostId', () => {
|
||||
it('stamps a listing for a repo with no row as this app, never the focused server', () => {
|
||||
expect(repoHostId({ repos: [], settings: focused, runtimeEnvironments: [] }, 'repo-1')).toBe(
|
||||
'local'
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps the host the caller names for a repo with no row', () => {
|
||||
expect(
|
||||
repoHostId({ repos: [], settings: focused, runtimeEnvironments: [] }, 'repo-1', 'ssh:box')
|
||||
).toBe('ssh:box')
|
||||
})
|
||||
})
|
||||
-17
@@ -1,17 +0,0 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { worktreeMatchesHost } from './worktree-host-ownership'
|
||||
|
||||
describe('worktreeMatchesHost unstamped non-local rows', () => {
|
||||
it.each([
|
||||
['stamped SSH row', { hostId: 'ssh:t' as const }, 'ssh:t' as const, true, true],
|
||||
['stamped server row', { runtimeOwnerEnvironmentId: 'e' }, 'runtime:e' as const, true, true],
|
||||
['unstamped row claimed by local', {}, 'local' as const, true, true],
|
||||
['unstamped row claimed by SSH', {}, 'ssh:t' as const, true, true],
|
||||
['unstamped row claimed by a server', {}, 'runtime:e' as const, true, true],
|
||||
['unstamped row refused by SSH', {}, 'ssh:t' as const, false, false],
|
||||
['unstamped row, no hint, SSH', {}, 'ssh:t' as const, undefined, false],
|
||||
['unstamped row, no hint, local', {}, 'local' as const, undefined, true]
|
||||
])('%s', (_name, row, hostId, unhostedWorktreesMatchHost, matches) => {
|
||||
expect(worktreeMatchesHost(row, hostId, { unhostedWorktreesMatchHost })).toBe(matches)
|
||||
})
|
||||
})
|
||||
@@ -1,21 +0,0 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { readPublishedSortOrders } from './worktree-sort-order-patch'
|
||||
|
||||
describe('readPublishedSortOrders', () => {
|
||||
it('reads valid entries and treats an absent field as an older host', () => {
|
||||
expect(readPublishedSortOrders([{ worktreeId: 'repo::/a', sortOrder: 5 }])).toEqual([
|
||||
{ worktreeId: 'repo::/a', sortOrder: 5 }
|
||||
])
|
||||
expect(readPublishedSortOrders(undefined)).toBeNull()
|
||||
})
|
||||
|
||||
it('falls back to a refetch when any entry is malformed', () => {
|
||||
expect(
|
||||
readPublishedSortOrders([
|
||||
{ worktreeId: 'repo::/a', sortOrder: 5 },
|
||||
{ worktreeId: 'repo::/b', sortOrder: Number.NaN }
|
||||
])
|
||||
).toBeNull()
|
||||
expect(readPublishedSortOrders([{ worktreeId: 7, sortOrder: 5 }])).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -37,25 +37,6 @@ describe('persistWorktreeMeta GitHub PR suppression compatibility', () => {
|
||||
vi.unstubAllGlobals()
|
||||
})
|
||||
|
||||
it.each([
|
||||
{ linkedPR: 42 },
|
||||
{ linkedPR: null },
|
||||
{ linkedGitLabMR: 7 },
|
||||
{ linkedGitLabMR: null },
|
||||
{ linkedIssue: 9 },
|
||||
{ linkedIssue: null }
|
||||
])('does not require a collection capability for scalar writes: %j', async (updates) => {
|
||||
mocks.assertCapability.mockRejectedValue(new Error('collection unsupported'))
|
||||
await persistWorktreeMeta(mocks.target, 'repo::/feature', updates)
|
||||
expect(mocks.assertCapability).not.toHaveBeenCalled()
|
||||
expect(mocks.callRuntimeRpc).toHaveBeenCalledWith(
|
||||
mocks.target,
|
||||
'worktree.set',
|
||||
{ worktree: 'id:repo::/feature', ...updates },
|
||||
{ timeoutMs: 15_000 }
|
||||
)
|
||||
})
|
||||
|
||||
it.each([true, false])(
|
||||
'keeps review selection exclusive when collection support is %s',
|
||||
async (supportsCollections) => {
|
||||
@@ -109,33 +90,6 @@ describe('persistWorktreeMeta GitHub PR suppression compatibility', () => {
|
||||
expect(mocks.callRuntimeRpc).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('sends the complete collection to a capable host', async () => {
|
||||
const linkedItems = [
|
||||
{ provider: 'github', type: 'pr', number: 42 },
|
||||
{ provider: 'gitlab', type: 'mr', number: 7 }
|
||||
] as const
|
||||
await persistWorktreeMeta(mocks.target, 'repo::/feature', {
|
||||
linkedItems: [...linkedItems]
|
||||
})
|
||||
expect(mocks.callRuntimeRpc).toHaveBeenCalledWith(
|
||||
mocks.target,
|
||||
'worktree.set',
|
||||
{ worktree: 'id:repo::/feature', linkedItems },
|
||||
{ timeoutMs: 15_000 }
|
||||
)
|
||||
})
|
||||
|
||||
it('sends positive suppression writes to capable hosts', async () => {
|
||||
await persistWorktreeMeta(mocks.target, 'repo::/feature', { suppressedGitHubPR: 42 })
|
||||
|
||||
expect(mocks.callRuntimeRpc).toHaveBeenCalledWith(
|
||||
mocks.target,
|
||||
'worktree.set',
|
||||
{ worktree: 'id:repo::/feature', suppressedGitHubPR: 42 },
|
||||
{ timeoutMs: 15_000 }
|
||||
)
|
||||
})
|
||||
|
||||
it('strips null clears for older hosts while preserving compatible updates', async () => {
|
||||
mocks.supportsCapability.mockResolvedValue(false)
|
||||
|
||||
@@ -158,40 +112,6 @@ describe('persistWorktreeMeta GitHub PR suppression compatibility', () => {
|
||||
{ timeoutMs: 15_000 }
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps null clears for capable hosts', async () => {
|
||||
await persistWorktreeMeta(mocks.target, 'repo::/feature', {
|
||||
linkedPR: 42,
|
||||
suppressedGitHubPR: null
|
||||
})
|
||||
|
||||
expect(mocks.callRuntimeRpc).toHaveBeenCalledWith(
|
||||
mocks.target,
|
||||
'worktree.set',
|
||||
{ worktree: 'id:repo::/feature', linkedPR: 42, suppressedGitHubPR: null },
|
||||
{ timeoutMs: 15_000 }
|
||||
)
|
||||
})
|
||||
|
||||
it('preserves host-owned suppression writes without a paired-runtime capability check', async () => {
|
||||
const updateMeta = vi.fn().mockResolvedValue(undefined)
|
||||
mocks.target = { kind: 'local' }
|
||||
vi.stubGlobal('window', { api: { worktrees: { updateMeta } } })
|
||||
|
||||
await persistWorktreeMeta(
|
||||
mocks.target,
|
||||
'repo::/feature',
|
||||
{ suppressedGitHubPR: 42 },
|
||||
'ssh:build-box'
|
||||
)
|
||||
|
||||
expect(updateMeta).toHaveBeenCalledWith({
|
||||
worktreeId: 'repo::/feature',
|
||||
executionHostId: 'ssh:build-box',
|
||||
updates: { suppressedGitHubPR: 42 }
|
||||
})
|
||||
expect(mocks.assertCapability).not.toHaveBeenCalled()
|
||||
})
|
||||
it('gates and forwards the atomic collection snapshot', async () => {
|
||||
await persistWorktreeMeta(mocks.target, 'repo::/feature', {
|
||||
linkedItems: [],
|
||||
|
||||
-160
@@ -1,160 +0,0 @@
|
||||
// Main migrates sessions before window handles rename; its next save must agree with identityRenamed, never carry the rekey alone. Only compiled-off local first-work-folder-rename emits this event; paired events omit rename.
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type * as AgentStatusModule from '@/lib/agent-status'
|
||||
import { getDefaultPersistedState } from '../../../../../../shared/constants'
|
||||
import type { WorkspaceSessionState } from '../../../../../../shared/workspace-session-state-types'
|
||||
import {
|
||||
addWorkspace,
|
||||
emptySession,
|
||||
leaf
|
||||
} from '../../../../../../shared/workspace-layout/workspace-layout-session.test-fixture'
|
||||
import { applyLayoutTransition } from '../../../../../../shared/workspace-layout/workspace-layout-transitions'
|
||||
import { migrateWorktreeIdentity } from '../../../../../../main/persistence/tracking-repos/worktree-identity-migration'
|
||||
import { loadWorkspaceLayoutWithoutReport } from '../../../../../../shared/workspace-layout/workspace-layout-load'
|
||||
import { nameBasedLoadContext } from '../../../../../../shared/workspace-layout/workspace-layout-minted-ids'
|
||||
|
||||
vi.mock('sonner', () => ({ toast: { info: vi.fn(), success: vi.fn(), error: vi.fn() } }))
|
||||
vi.mock('@/lib/agent-status', async (importOriginal) => {
|
||||
const actual = await importOriginal<typeof AgentStatusModule>()
|
||||
return { ...actual, detectAgentStatusFromTitle: vi.fn().mockReturnValue(null) }
|
||||
})
|
||||
|
||||
// @ts-expect-error -- mocked browser preload API
|
||||
globalThis.window = { api: {} }
|
||||
|
||||
import { buildWorkspaceSessionPayload } from '@/lib/workspace-session'
|
||||
import { createTestStore, makeWorktree } from '../../store-test-helpers'
|
||||
|
||||
const REPO = 'repo1'
|
||||
const OLD = `${REPO}::/path/cunner`
|
||||
const NEW = `${REPO}::/path/spinner`
|
||||
const OTHER = `${REPO}::/path/other`
|
||||
const EDITOR_FILE = '/path/cunner/src/App.tsx'
|
||||
|
||||
function sessionBeforeRename(): WorkspaceSessionState {
|
||||
const session = addWorkspace(emptySession(), OLD, [
|
||||
{
|
||||
id: 'group-left',
|
||||
tabs: [
|
||||
{ id: 'tab-split', leaves: [[leaf(1), 'pty-1'], [leaf(2)]] },
|
||||
{ id: 'tab-two', leaves: [[leaf(3), 'pty-3']] },
|
||||
{ id: EDITOR_FILE, kind: 'editor' }
|
||||
]
|
||||
},
|
||||
{
|
||||
id: 'group-right',
|
||||
tabs: [
|
||||
{ id: 'tab-right', leaves: [[leaf(4)]] },
|
||||
{ id: 'browser-1', kind: 'browser' }
|
||||
]
|
||||
}
|
||||
])
|
||||
session.openFilesByWorktree = {
|
||||
[OLD]: [
|
||||
{
|
||||
filePath: EDITOR_FILE,
|
||||
relativePath: 'src/App.tsx',
|
||||
worktreeId: OLD,
|
||||
language: 'typescript'
|
||||
}
|
||||
]
|
||||
}
|
||||
session.activeFileIdByWorktree = { [OLD]: EDITOR_FILE }
|
||||
session.browserTabsByWorktree = {
|
||||
[OLD]: [
|
||||
{
|
||||
id: 'browser-1',
|
||||
worktreeId: OLD,
|
||||
url: 'https://example.com',
|
||||
title: 'Example',
|
||||
loading: false,
|
||||
faviconUrl: null,
|
||||
canGoBack: false,
|
||||
canGoForward: false,
|
||||
loadError: null,
|
||||
createdAt: 3
|
||||
}
|
||||
]
|
||||
}
|
||||
addWorkspace(session, OTHER, [
|
||||
{ id: 'group-other', tabs: [{ id: 'tab-other', leaves: [[leaf(5)]] }] }
|
||||
])
|
||||
session.activeRepoId = REPO
|
||||
session.activeWorktreeId = OLD
|
||||
return session
|
||||
}
|
||||
|
||||
/** Main's layout model of a stored partition, loaded as main loads it. */
|
||||
function layoutModelOf(session: WorkspaceSessionState) {
|
||||
return loadWorkspaceLayoutWithoutReport('local', session, nameBasedLoadContext()).layout
|
||||
}
|
||||
|
||||
function hydratedWindow(session: WorkspaceSessionState) {
|
||||
const store = createTestStore()
|
||||
store.setState({
|
||||
repos: [{ id: REPO, path: '/path', displayName: 'Repo 1', badgeColor: '#000', addedAt: 0 }],
|
||||
worktreesByRepo: {
|
||||
[REPO]: [OLD, OTHER].map((id) =>
|
||||
makeWorktree({ id, repoId: REPO, path: id.slice(`${REPO}::`.length) })
|
||||
)
|
||||
}
|
||||
})
|
||||
store.getState().hydrateWorkspaceSession(session)
|
||||
store.getState().hydrateTabsSession(session)
|
||||
store.getState().hydrateEditorSession(session)
|
||||
store.getState().hydrateBrowserSession(session)
|
||||
store.setState({ workspaceSessionReady: true })
|
||||
store.getState().setHydrationSucceeded(true)
|
||||
return store
|
||||
}
|
||||
|
||||
describe('worktree identity rename: window and main agree on the layout', () => {
|
||||
it("leaves main's migrated layout model as it is when the window saves its rekey", () => {
|
||||
const store = hydratedWindow(sessionBeforeRename())
|
||||
// What main holds: the window's last save before the rename.
|
||||
const held = buildWorkspaceSessionPayload(store.getState())
|
||||
const before = layoutModelOf(held)
|
||||
expect(Object.keys(before.workspaces).sort()).toEqual([OLD, OTHER].sort())
|
||||
|
||||
// Main: Store.migrateWorktreeIdentity, before it sends the rename event.
|
||||
const persisted = {
|
||||
...getDefaultPersistedState('/home'),
|
||||
workspaceSession: structuredClone(held)
|
||||
}
|
||||
expect(migrateWorktreeIdentity(persisted, OLD, NEW)).toBe(true)
|
||||
const mainModel = layoutModelOf(persisted.workspaceSession)
|
||||
|
||||
// Window: the rename event re-keys its slices; the worktree list then catches up.
|
||||
store.getState().migrateWorktreeIdentity(OLD, NEW)
|
||||
store.setState({
|
||||
worktreesByRepo: {
|
||||
[REPO]: [NEW, OTHER].map((id) =>
|
||||
makeWorktree({ id, repoId: REPO, path: id.slice(`${REPO}::`.length) })
|
||||
)
|
||||
}
|
||||
})
|
||||
const windowModel = layoutModelOf(buildWorkspaceSessionPayload(store.getState()))
|
||||
|
||||
expect(Object.keys(mainModel.workspaces).sort()).toEqual([NEW, OTHER].sort())
|
||||
const renamed = windowModel.workspaces[NEW]!
|
||||
expect(renamed.tabs.length).toBe(5)
|
||||
expect(renamed.groups?.length).toBe(2)
|
||||
expect(renamed.editorFiles?.length).toBe(1)
|
||||
expect(renamed.browserTabs?.length).toBe(1)
|
||||
expect({ workspaces: windowModel.workspaces, records: windowModel.records }).toEqual({
|
||||
workspaces: mainModel.workspaces,
|
||||
records: mainModel.records
|
||||
})
|
||||
|
||||
const transitioned = applyLayoutTransition(before, {
|
||||
type: 'identityRenamed',
|
||||
from: OLD,
|
||||
to: NEW
|
||||
})
|
||||
expect(transitioned.ok).toBe(true)
|
||||
if (transitioned.ok) {
|
||||
expect(transitioned.model.workspaces).toEqual(mainModel.workspaces)
|
||||
expect(transitioned.model.records).toEqual(mainModel.records)
|
||||
}
|
||||
})
|
||||
})
|
||||
+1
-49
@@ -1,41 +1,12 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { beginHostQualifiedRemoval } from './host-qualified-worktree-removal'
|
||||
import { folderWorkspaceKey } from '../../../../../../shared/workspace-scope'
|
||||
import '../../../../../../shared/workspace-scope'
|
||||
|
||||
const WORKTREE_ID = 'repo1::/shared/workspace/path'
|
||||
|
||||
/** Early refusal bypasses removal’s clearing catch; clear optimistic deleting state here or its spinner outlives the 10-second toast. */
|
||||
// Confirmed hosts resolve directly; unresolved-owner refusal is reached only by hostless callers.
|
||||
describe('beginHostQualifiedRemoval refusals clear the delete state', () => {
|
||||
function makeGet(clearWorktreeDeleteState: ReturnType<typeof vi.fn>) {
|
||||
// Minimal store surface: no worktrees, so no route can resolve for MISSING_HOST.
|
||||
return () =>
|
||||
({
|
||||
clearWorktreeDeleteState,
|
||||
allWorktrees: () => [],
|
||||
worktreesByRepo: {},
|
||||
repos: [],
|
||||
detectedWorktreesByRepo: {},
|
||||
settings: {},
|
||||
sshConnectionStates: new Map(),
|
||||
sshTargetLabels: new Map(),
|
||||
workspaceCleanupScan: null
|
||||
}) as never
|
||||
}
|
||||
|
||||
it('clears when no route resolves and no host was confirmed', () => {
|
||||
const clearWorktreeDeleteState = vi.fn()
|
||||
const start = beginHostQualifiedRemoval(
|
||||
makeGet(clearWorktreeDeleteState),
|
||||
WORKTREE_ID,
|
||||
null,
|
||||
false
|
||||
)
|
||||
|
||||
expect(start.ok).toBe(false)
|
||||
expect(clearWorktreeDeleteState).toHaveBeenCalledWith(WORKTREE_ID)
|
||||
})
|
||||
|
||||
// Use populated unresolved-owner states too; an empty fixture proves clear but not real-user reachability.
|
||||
function makeRoutedGet(
|
||||
clearWorktreeDeleteState: ReturnType<typeof vi.fn>,
|
||||
@@ -80,23 +51,4 @@ describe('beginHostQualifiedRemoval refusals clear the delete state', () => {
|
||||
})
|
||||
expect(clearWorktreeDeleteState).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
// Folder workspaces fail closed on a stale id by design, so a row whose folder record is gone
|
||||
// refuses instead of routing.
|
||||
it('clears when a folder workspace id no longer has an owner', () => {
|
||||
const clearWorktreeDeleteState = vi.fn()
|
||||
const folderId = folderWorkspaceKey('fw-removed')
|
||||
const start = beginHostQualifiedRemoval(
|
||||
makeRoutedGet(clearWorktreeDeleteState, {
|
||||
repos: [{ id: 'repo1', connectionId: null, executionHostId: 'local' }],
|
||||
folderWorkspaces: []
|
||||
}),
|
||||
folderId,
|
||||
null,
|
||||
false
|
||||
)
|
||||
|
||||
expect(start.ok).toBe(false)
|
||||
expect(clearWorktreeDeleteState).toHaveBeenCalledWith(folderId)
|
||||
})
|
||||
})
|
||||
|
||||
Reference in New Issue
Block a user