Files
orca/tests/e2e/worktree-scroll-to-current.spec.ts
Brennan Benson 03c828eece Run setup scripts for project group folder workspaces (#41744)
* 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
2026-11-13 15:37:54 -08:00

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)
})
})