mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 19:34:29 +00:00
* Add setup scripts for project group folder workspaces * Align setup regression fixtures and catalog read validation * Target the Advanced disclosure in group setup regression * test: initialize project groups in worktree slice fixture * Preserve group setup startup input across paired hosts * Check paired group startup regression in cross-layer project * Restore group setup settings when saving fails * Wait for group agents to accept startup input * Type the group startup readiness fixture foreground state * Give group startup fixture mocks portable public types * Reuse worktree startup for group folder setup * Keep example shell regression while removing obsolete observer tests * Complete launch runtime fixture PTY options * Exercise terminal startup failure and worktree draft paste in parity tests * Preserve repository type defaults for setup commands
359 lines
13 KiB
TypeScript
359 lines
13 KiB
TypeScript
import { mkdirSync, realpathSync } from 'node:fs'
|
|
import path from 'node:path'
|
|
import { runProcess } from '@orca/process-host'
|
|
import type { Page } from '@stablyai/playwright-test'
|
|
import { test, expect } from './helpers/orca-app'
|
|
import { evaluatePolled } from './helpers/page-evaluate-polled'
|
|
import {
|
|
addRepoWithWorkspaces,
|
|
bulkWriteTimeout,
|
|
writeWorkspaceMeta
|
|
} from './helpers/repo-with-workspaces'
|
|
import { waitForActiveWorktree, waitForSessionReady } from './helpers/store'
|
|
|
|
async function prepareSidebarForScrollTest(page: Page): Promise<void> {
|
|
await page.evaluate(() => {
|
|
const store = window.__store
|
|
if (!store) {
|
|
throw new Error('window.__store is not available')
|
|
}
|
|
|
|
const state = store.getState()
|
|
state.setActiveView('terminal')
|
|
state.setSidebarOpen(true)
|
|
state.setGroupBy('none')
|
|
state.setSortBy('recent')
|
|
state.setShowActiveOnly(false)
|
|
state.setShowSleepingWorkspaces(true)
|
|
state.setHideDefaultBranchWorkspace(false)
|
|
state.setFilterRepoIds([])
|
|
})
|
|
}
|
|
|
|
test.describe('Reveal active workspace button', () => {
|
|
test.beforeEach(async ({ orcaPage }) => {
|
|
// Reduced motion jumps reveal deterministically because hidden xvfb Electron never advances smooth-scroll animations.
|
|
await orcaPage.emulateMedia({ reducedMotion: 'reduce' })
|
|
await waitForSessionReady(orcaPage)
|
|
await waitForActiveWorktree(orcaPage)
|
|
})
|
|
|
|
// Use outside-virtual-window reveal coverage; a removed ~44px synthetic viewport/±1px containment test was unstable under saturated CI.
|
|
|
|
test('adjusts sidebar filters before revealing a hidden current workspace', async ({
|
|
orcaPage,
|
|
testRepoPath
|
|
}, testInfo) => {
|
|
const filterRepoPath = testInfo.outputPath('filter-repo')
|
|
mkdirSync(filterRepoPath, { recursive: true })
|
|
for (const args of [
|
|
['init', filterRepoPath],
|
|
[
|
|
'-C',
|
|
filterRepoPath,
|
|
'-c',
|
|
'user.name=E2E',
|
|
'-c',
|
|
'user.email=e2e@test.local',
|
|
'commit',
|
|
'--allow-empty',
|
|
'-m',
|
|
'Filter fixture'
|
|
]
|
|
]) {
|
|
const result = await runProcess({ program: 'git', args })
|
|
expect(result.code, result.stderr).toBe(0)
|
|
}
|
|
const filterRepoId = await orcaPage.evaluate(async (repoPath) => {
|
|
const result = await window.api.repos.add({ path: repoPath })
|
|
if ('error' in result) {
|
|
throw new Error(result.error)
|
|
}
|
|
return result.repo.id
|
|
}, filterRepoPath)
|
|
await expect
|
|
.poll(() =>
|
|
orcaPage.evaluate(async (id) => {
|
|
await window
|
|
.__store!.getState()
|
|
.fetchRepos({ runtimeEnvironmentId: null, throwOnError: true })
|
|
return window.__store!.getState().repos.some((repo) => repo.id === id)
|
|
}, filterRepoId)
|
|
)
|
|
.toBe(true)
|
|
await prepareSidebarForScrollTest(orcaPage)
|
|
|
|
// Other specs can add worktrees to the shared repository before this test runs.
|
|
const targetId = await orcaPage.evaluate((repoPath) => {
|
|
const state = window.__store!.getState()
|
|
const repo = state.repos.find((candidate) => candidate.path === repoPath)
|
|
return repo
|
|
? state.worktreesByRepo[repo.id]?.find(
|
|
(worktree) => worktree.branch === 'refs/heads/e2e-secondary'
|
|
)?.id
|
|
: undefined
|
|
}, testRepoPath)
|
|
if (!targetId) {
|
|
throw new Error('Seeded secondary worktree is missing')
|
|
}
|
|
const targetRepoId = await orcaPage.evaluate(
|
|
(repoPath) => window.__store!.getState().repos.find((repo) => repo.path === repoPath)?.id,
|
|
testRepoPath
|
|
)
|
|
if (!targetRepoId) {
|
|
throw new Error('Seeded repository is missing')
|
|
}
|
|
|
|
const targetRows = orcaPage.locator(
|
|
`[data-worktree-sidebar] [data-worktree-id=${JSON.stringify(targetId)}]`
|
|
)
|
|
const targetRow = targetRows.first()
|
|
await expect(targetRows.and(orcaPage.getByRole('option'))).toHaveCount(1)
|
|
const revealButton = orcaPage.getByRole('button', { name: 'Reveal active workspace' })
|
|
|
|
await orcaPage.evaluate((targetId) => {
|
|
const store = window.__store
|
|
if (!store) {
|
|
throw new Error('window.__store is not available')
|
|
}
|
|
const state = store.getState()
|
|
const target = Object.values(state.worktreesByRepo)
|
|
.flat()
|
|
.find((worktree) => worktree.id === targetId)
|
|
if (!target) {
|
|
throw new Error(`Target workspace ${targetId} not found`)
|
|
}
|
|
store.setState({
|
|
activeRepoId: target.repoId,
|
|
activeWorktreeId: target.id,
|
|
activeWorkspaceKey: `worktree:${target.id}`,
|
|
pendingRevealWorktree: null
|
|
})
|
|
}, targetId)
|
|
await expect(targetRow).toHaveAttribute('aria-current', 'page')
|
|
|
|
// Catalog refreshes prune nonexistent IDs, so use a real repo to keep the filter applied.
|
|
await orcaPage.evaluate((repoId) => {
|
|
window.__store!.getState().setFilterRepoIds([repoId])
|
|
}, filterRepoId)
|
|
await expect(targetRows).toHaveCount(0)
|
|
|
|
await revealButton.click()
|
|
await orcaPage
|
|
.getByRole('dialog', { name: 'Reveal hidden workspace?' })
|
|
.getByRole('button', { name: 'Adjust filters and reveal' })
|
|
.click()
|
|
|
|
await expect(targetRow).toBeVisible()
|
|
await expect(targetRow).toHaveAttribute('data-scroll-reveal-highlight', 'true')
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
orcaPage.evaluate(() => {
|
|
const store = window.__store
|
|
if (!store) {
|
|
throw new Error('window.__store is not available')
|
|
}
|
|
return store.getState().filterRepoIds
|
|
}),
|
|
{
|
|
timeout: 10_000,
|
|
message:
|
|
'Reveal button should preserve selected repos while revealing the current workspace'
|
|
}
|
|
)
|
|
.toEqual([filterRepoId, targetRepoId])
|
|
})
|
|
|
|
test('reveals the current workspace when it starts outside the virtualized window', async ({
|
|
orcaPage
|
|
}, testInfo) => {
|
|
await prepareSidebarForScrollTest(orcaPage)
|
|
|
|
const repo = await addRepoWithWorkspaces(orcaPage, testInfo, 60)
|
|
await writeWorkspaceMeta(
|
|
orcaPage,
|
|
repo.ids.map((worktreeId, index) => ({
|
|
worktreeId,
|
|
updates: {
|
|
displayName: `Virtual reveal ${String(index).padStart(2, '0')}`,
|
|
sortOrder: 10_000 - index,
|
|
manualOrder: 10_000 - index
|
|
}
|
|
}))
|
|
)
|
|
const targetId = repo.ids.at(-1)!
|
|
await orcaPage.evaluate(
|
|
({ repoId, targetId }) => {
|
|
window.__store!.setState({
|
|
activeRepoId: repoId,
|
|
activeWorktreeId: targetId,
|
|
activeWorkspaceKey: `worktree:${targetId}`,
|
|
pendingRevealWorktree: null,
|
|
sortBy: 'manual'
|
|
})
|
|
},
|
|
{ repoId: repo.repoId, targetId }
|
|
)
|
|
|
|
const scroller = orcaPage.locator('[data-worktree-sidebar]')
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
orcaPage.evaluate(() => {
|
|
const scroller = document.querySelector<HTMLElement>('[data-worktree-sidebar]')
|
|
return scroller?.scrollTop ?? null
|
|
}),
|
|
{ timeout: 10_000, message: 'sidebar scroller did not mount' }
|
|
)
|
|
.not.toBeNull()
|
|
|
|
await scroller.evaluate((element) => {
|
|
element.scrollTop = 0
|
|
element.dispatchEvent(new Event('scroll', { bubbles: true }))
|
|
})
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
orcaPage.evaluate((targetId) => {
|
|
const scroller = document.querySelector<HTMLElement>('[data-worktree-sidebar]')
|
|
const target = [...document.querySelectorAll<HTMLElement>('[data-worktree-id]')].find(
|
|
(candidate) => candidate.dataset.worktreeId === targetId
|
|
)
|
|
if (!scroller || !target) {
|
|
return false
|
|
}
|
|
const scrollerBounds = scroller.getBoundingClientRect()
|
|
const targetBounds = target.getBoundingClientRect()
|
|
return (
|
|
targetBounds.top >= scrollerBounds.top - 1 &&
|
|
targetBounds.bottom <= scrollerBounds.bottom + 1
|
|
)
|
|
}, targetId),
|
|
{ timeout: 10_000, message: 'target workspace should start outside the sidebar viewport' }
|
|
)
|
|
.toBe(false)
|
|
|
|
const revealButton = orcaPage.getByRole('button', { name: 'Reveal active workspace' })
|
|
await expect(revealButton).toBeVisible()
|
|
await expect(revealButton).toBeEnabled()
|
|
|
|
await revealButton.click()
|
|
const targetRow = orcaPage
|
|
.locator(`[data-worktree-sidebar] [data-worktree-id=${JSON.stringify(targetId)}]`)
|
|
.first()
|
|
await expect(targetRow).toBeVisible()
|
|
await expect(targetRow).toHaveAttribute('data-scroll-reveal-highlight', 'true')
|
|
})
|
|
|
|
test('uses the active workspace key when the legacy active worktree id is not set', async ({
|
|
orcaPage
|
|
}, testInfo) => {
|
|
await prepareSidebarForScrollTest(orcaPage)
|
|
|
|
// The oldest of 36 folder workspaces sorts last under Recent.
|
|
const groupPath = testInfo.outputPath('reveal-folder-group')
|
|
const folderPaths = Array.from({ length: 36 }, (_, index) => {
|
|
const folderPath = path.join(groupPath, `folder-${String(index).padStart(2, '0')}`)
|
|
mkdirSync(folderPath, { recursive: true })
|
|
return realpathSync(folderPath)
|
|
})
|
|
const folderWorktreeId = await evaluatePolled(
|
|
orcaPage,
|
|
async ({ parentPath, folderPaths }) => {
|
|
const store = window.__store!
|
|
const group = await window.api.projectGroups.create({
|
|
name: 'Reveal folder group',
|
|
parentPath,
|
|
createdFrom: 'manual'
|
|
})
|
|
await store
|
|
.getState()
|
|
.fetchProjectGroups({ runtimeEnvironmentId: null, throwOnError: true })
|
|
const ids: string[] = []
|
|
for (const [index, folderPath] of folderPaths.entries()) {
|
|
const folder = await store.getState().createFolderWorkspace(
|
|
{
|
|
projectGroupId: group.id,
|
|
name: `Reveal folder workspace ${String(index).padStart(2, '0')}`,
|
|
folderPath
|
|
},
|
|
{ runtimeEnvironmentId: null }
|
|
)
|
|
if (!folder) {
|
|
throw new Error(`Folder workspace ${index} was not created`)
|
|
}
|
|
ids.push(folder.folderWorkspace.id)
|
|
}
|
|
const targetKey = `folder:${ids[0]}` as const
|
|
store.setState({
|
|
activeRepoId: null,
|
|
activeWorktreeId: null,
|
|
activeWorkspaceKey: targetKey
|
|
})
|
|
store.getState().setGroupBy('repo')
|
|
return targetKey
|
|
},
|
|
{ parentPath: realpathSync(groupPath), folderPaths },
|
|
{ timeout: bulkWriteTimeout(folderPaths.length) }
|
|
)
|
|
|
|
const scroller = orcaPage.locator('[data-worktree-sidebar]')
|
|
await scroller.evaluate((element) => {
|
|
element.scrollTop = 0
|
|
element.dispatchEvent(new Event('scroll', { bubbles: true }))
|
|
})
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
orcaPage.evaluate((targetId) => {
|
|
const scroller = document.querySelector<HTMLElement>('[data-worktree-sidebar]')
|
|
const target = [...document.querySelectorAll<HTMLElement>('[data-worktree-id]')].find(
|
|
(candidate) => candidate.dataset.worktreeId === targetId
|
|
)
|
|
if (!scroller || !target) {
|
|
return false
|
|
}
|
|
const scrollerBounds = scroller.getBoundingClientRect()
|
|
const targetBounds = target.getBoundingClientRect()
|
|
return (
|
|
targetBounds.top >= scrollerBounds.top - 1 &&
|
|
targetBounds.bottom <= scrollerBounds.bottom + 1
|
|
)
|
|
}, folderWorktreeId),
|
|
{ timeout: 10_000, message: 'target folder workspace should start outside the viewport' }
|
|
)
|
|
.toBe(false)
|
|
|
|
const revealButton = orcaPage.getByRole('button', { name: 'Reveal active workspace' })
|
|
await expect(revealButton).toBeVisible()
|
|
await expect(revealButton).toBeEnabled()
|
|
await revealButton.click()
|
|
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
orcaPage.evaluate((targetId) => {
|
|
const scroller = document.querySelector<HTMLElement>('[data-worktree-sidebar]')
|
|
const target = [...document.querySelectorAll<HTMLElement>('[data-worktree-id]')].find(
|
|
(candidate) => candidate.dataset.worktreeId === targetId
|
|
)
|
|
if (!scroller || !target) {
|
|
return false
|
|
}
|
|
const scrollerBounds = scroller.getBoundingClientRect()
|
|
const targetBounds = target.getBoundingClientRect()
|
|
return (
|
|
targetBounds.top >= scrollerBounds.top - 1 &&
|
|
targetBounds.bottom <= scrollerBounds.bottom + 1
|
|
)
|
|
}, folderWorktreeId),
|
|
{
|
|
timeout: 10_000,
|
|
message: 'Reveal button should scroll to the active folder workspace'
|
|
}
|
|
)
|
|
.toBe(true)
|
|
})
|
|
})
|