mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
102 lines
4.6 KiB
TypeScript
102 lines
4.6 KiB
TypeScript
import '../../src/renderer/src/store/terminals/terminal-hydration-store.test-bootstrap'
|
|
import { describe, expect, it, vi } from 'vitest'
|
|
import { applyPtyBinding } from '../../src/main/persistence/loading-store/pty-binding-session-update'
|
|
import { getDefaultWorkspaceSession } from '../../src/shared/constants'
|
|
import { folderWorkspaceKey } from '../../src/shared/workspace-scope'
|
|
import type { WorkspaceSessionState } from '../../src/shared/workspace-session/workspace-session-state-types'
|
|
import { reconcileHydratedWorkspaceTabModels } from '../../src/renderer/src/app-shell/reconcile-hydrated-workspace-tab-models'
|
|
import { createTestStore } from '../../src/renderer/src/store/testing/app-store-test-fixture'
|
|
import { makeTab } from '../../src/renderer/src/store/terminals/terminal-tab.test-fixture'
|
|
import { makeWorktree } from '../../src/renderer/src/store/slices/worktrees/worktree.test-fixture'
|
|
import { TEST_REPO } from '../../src/renderer/src/store/repos/repo.test-fixture'
|
|
|
|
vi.mock('sonner', () => ({ toast: { info: vi.fn(), success: vi.fn(), error: vi.fn() } }))
|
|
vi.mock('@/runtime/sync-runtime-graph/graph-sync-scheduler', () => ({
|
|
scheduleRuntimeGraphSync: vi.fn()
|
|
}))
|
|
vi.mock('@/components/terminal-pane/pty-transport/delivery/pty-dispatcher', () => ({
|
|
registerEagerPtyBuffer: vi.fn(),
|
|
ensurePtyDispatcher: vi.fn()
|
|
}))
|
|
|
|
const TAB_ID = 'crash-survivor'
|
|
const LEAF_ID = '11111111-1111-4111-8111-111111111111'
|
|
const INCARNATION_ID = '22222222-2222-4222-8222-222222222222'
|
|
const FOLDER_KEY = folderWorkspaceKey('crash-folder')
|
|
|
|
describe.each(['repo1::/repo1', FOLDER_KEY])('binding crash hydration for %s', (worktreeId) => {
|
|
it.each([false, true])(
|
|
'restores the acknowledged terminal before a renderer snapshot (existing row: %s)',
|
|
async (existingRow) => {
|
|
const ptyId = `${worktreeId}@@surviving-pty`
|
|
const persisted: WorkspaceSessionState = {
|
|
...getDefaultWorkspaceSession(),
|
|
activeWorktreeId: worktreeId,
|
|
activeTabId: TAB_ID,
|
|
activeTabIdByWorktree: { [worktreeId]: TAB_ID },
|
|
activeWorktreeIdsOnShutdown: [],
|
|
unifiedTabs: {},
|
|
tabGroups: {},
|
|
tabGroupLayouts: {},
|
|
...(existingRow
|
|
? { tabsByWorktree: { [worktreeId]: [makeTab({ id: TAB_ID, worktreeId, ptyId: null })] } }
|
|
: {})
|
|
}
|
|
applyPtyBinding(
|
|
{ worktreeId, tabId: TAB_ID, leafId: LEAF_ID, ptyId, incarnationId: INCARNATION_ID },
|
|
persisted,
|
|
worktreeId,
|
|
`${TAB_ID}:${LEAF_ID}`
|
|
)
|
|
|
|
// A crash leaves only the binding transaction; no renderer snapshot can fill its gaps.
|
|
const restoredSession = structuredClone(persisted)
|
|
const store = createTestStore()
|
|
store.setState({
|
|
repos: [TEST_REPO],
|
|
worktreesByRepo: {
|
|
repo1: [makeWorktree({ id: 'repo1::/repo1', repoId: 'repo1', path: '/repo1' })]
|
|
}
|
|
})
|
|
const options = { additionalValidWorkspaceKeys: [FOLDER_KEY] }
|
|
store.getState().hydrateWorkspaceSession(restoredSession, options)
|
|
store.getState().hydrateTabsSession(restoredSession, options)
|
|
reconcileHydratedWorkspaceTabModels(
|
|
restoredSession,
|
|
store.getState().reconcileWorktreeTabModels
|
|
)
|
|
|
|
const beforeReconnect = store.getState()
|
|
expect(beforeReconnect.tabsByWorktree[worktreeId]?.map((tab) => tab.id)).toEqual([TAB_ID])
|
|
expect(beforeReconnect.pendingReconnectPtyIdByTabId[TAB_ID]).toBe(ptyId)
|
|
expect(beforeReconnect.unifiedTabsByWorktree[worktreeId]).toEqual([
|
|
expect.objectContaining({ id: TAB_ID, entityId: TAB_ID, contentType: 'terminal' })
|
|
])
|
|
expect(beforeReconnect.groupsByWorktree[worktreeId]).toEqual([
|
|
expect.objectContaining({ activeTabId: TAB_ID, tabOrder: [TAB_ID] })
|
|
])
|
|
expect(beforeReconnect.layoutByWorktree[worktreeId]).toEqual({
|
|
type: 'leaf',
|
|
groupId: beforeReconnect.groupsByWorktree[worktreeId][0].id
|
|
})
|
|
expect(beforeReconnect.terminalLayoutsByTabId[TAB_ID]).toMatchObject({
|
|
root: { type: 'leaf', leafId: LEAF_ID },
|
|
activeLeafId: LEAF_ID,
|
|
ptyIdsByLeafId: { [LEAF_ID]: ptyId }
|
|
})
|
|
expect(restoredSession.terminalPtyIncarnationsByPaneKey?.[`${TAB_ID}:${LEAF_ID}`]).toBe(
|
|
INCARNATION_ID
|
|
)
|
|
|
|
await store.getState().reconnectPersistedTerminals()
|
|
|
|
expect(store.getState().workspaceSessionReady).toBe(true)
|
|
expect(store.getState().activeTabId).toBe(TAB_ID)
|
|
expect(store.getState().tabsByWorktree[worktreeId]).toEqual([
|
|
expect.objectContaining({ id: TAB_ID, ptyId })
|
|
])
|
|
expect(store.getState().ptyIdsByTabId[TAB_ID]).toEqual([ptyId])
|
|
}
|
|
)
|
|
})
|