Files
orca/tests/e2e/project-group-creation-visibility.spec.ts
Brennan Benson 8d908764dc Revert "Keep same-machine folders with matching Git remotes in separate projects (#32272)" (#34662)
* Revert "Keep same-machine folders with matching Git remotes in separate projects (#32272)"

This reverts commit 29a5f89b8a.

On a machine with several clones of one repo, #32272 moved the oldest clone
into the shared cross-host project. Shared Windows QA machines have several
orca clones, so everyone's sidebar "orca" project suddenly gained that
machine's main checkout and its worktrees. Revert until the intended
grouping is decided.

Conflicts resolved against later main: Settings files moved into
settings/repository (imports adjusted), and two test files later deleted on
main stay deleted.

* Use checked types in restored test fixtures

* Combine restored fixture type imports
2026-10-27 20:38:35 -07:00

194 lines
6.9 KiB
TypeScript

import { cpSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { test, expect } from './helpers/orca-app'
import { waitForSessionReady } from './helpers/store'
import { runProcess } from '@orca/process-host'
test.use({ seedTestRepo: false })
declare global {
// Resolved by the main-process gate this spec installs around the group-create response.
var __releaseGroupCreateResponse: (() => void) | undefined
}
for (const delayCreateResponse of [false, true]) {
test(`created groups survive sidebar expansion (${delayCreateResponse ? 'refresh first' : 'ordinary timing'})`, async ({
orcaPage,
electronApp,
registerPostElectronShutdownCleanup
}, testInfo) => {
await waitForSessionReady(orcaPage)
const root = realpathSync(mkdtempSync(path.join(os.tmpdir(), 'orca-group-visibility-')))
registerPostElectronShutdownCleanup(async () => {
rmSync(root, { recursive: true, force: true })
})
const paths = Array.from({ length: 30 }, (_, index) =>
path.join(root, `repo-${String(index).padStart(2, '0')}`)
)
const templatePath = paths[0]
if (!templatePath) {
throw new Error('Repository fixture requires a first path')
}
for (const repoPath of [templatePath]) {
mkdirSync(repoPath)
writeFileSync(path.join(repoPath, 'seed.txt'), 'seed\n')
for (const args of [
['init'],
['add', '.'],
[
'-c',
'user.name=Test',
'-c',
'user.email=test@example.com',
'-c',
'commit.gpgsign=false',
'commit',
'-m',
'seed'
]
]) {
const result = await runProcess({ program: 'git', args, cwd: repoPath, timeoutMs: 10_000 })
expect(result.code, result.stderr).toBe(0)
}
}
for (const repoPath of paths.slice(1)) {
cpSync(templatePath, repoPath, { recursive: true, force: false, errorOnExist: true })
}
const repoIds = await orcaPage.evaluate(async (paths) => {
const store = window.__store!
for (const repoPath of paths) {
await window.api.repos.add({ path: repoPath })
}
await store.getState().awaitLocalRepoCatalogSettlement()
const repos = store.getState().repos.filter((repo) => paths.includes(repo.path))
for (const repo of repos) {
await store.getState().fetchWorktrees(repo.id)
}
store.getState().setGroupBy('repo')
store.getState().setProjectOrderBy('manual')
return repos.map((repo) => repo.id)
}, paths)
expect(repoIds).toHaveLength(paths.length)
// Force the adverse ordering separately from the ordinary IPC path.
if (delayCreateResponse) {
await electronApp.evaluate(({ ipcMain }) => {
if (!('_invokeHandlers' in ipcMain) || !(ipcMain._invokeHandlers instanceof Map)) {
throw new Error('Electron invoke handlers unavailable')
}
const create = ipcMain._invokeHandlers.get('projectGroups:create')
if (typeof create !== 'function') {
throw new Error('Group create handler unavailable')
}
const gate = Promise.withResolvers<void>()
Reflect.set(globalThis, '__releaseGroupCreateResponse', gate.resolve)
ipcMain.removeHandler('projectGroups:create')
ipcMain.handle('projectGroups:create', async (...args) => {
ipcMain.removeHandler('projectGroups:create')
ipcMain.handle('projectGroups:create', create)
const group = await create(...args)
await gate.promise
return group
})
})
}
const creation = orcaPage.evaluate(() =>
window.__store!.getState().createProjectGroup('Crowded group', 'local')
)
if (delayCreateResponse) {
try {
await expect
.poll(() =>
orcaPage.evaluate(() =>
window
.__store!.getState()
.projectGroups.some((group) => group.name === 'Crowded group')
)
)
.toBe(true)
} finally {
await electronApp.evaluate(() => {
const release = globalThis.__releaseGroupCreateResponse
if (typeof release !== 'function') {
throw new Error('Group create response gate unavailable')
}
release()
Reflect.deleteProperty(globalThis, '__releaseGroupCreateResponse')
})
}
}
const createdGroup = await creation
if (!createdGroup) {
throw new Error('Group creation failed')
}
await orcaPage.evaluate(
async ({ repoIds, groupId }) => {
const store = window.__store!
for (const repoId of repoIds.slice(0, 2)) {
const repo = store.getState().repos.find((candidate) => candidate.id === repoId)
if (!repo) {
throw new Error(`Missing repo ${repoId}`)
}
await store.getState().moveProjectToGroup(repo, groupId)
}
const collapsedGroups = store
.getState()
.projectHostSetups.map((setup) => `project:${setup.projectId}`)
await window.api.ui.set({ groupBy: 'repo', collapsedGroups })
store.setState({ collapsedGroups: new Set(collapsedGroups) })
},
{ repoIds, groupId: createdGroup.id }
)
const scroller = orcaPage.locator('[data-worktree-sidebar]')
const group = scroller.locator(`[data-project-group-header-id="${createdGroup.id}"]`)
const groupedRepos = repoIds
.slice(0, 2)
.map((id) => scroller.locator(`[data-repo-header-id="${id}"]`))
for (const repo of groupedRepos) {
await expect(repo).toBeVisible()
}
await orcaPage.screenshot({ path: testInfo.outputPath('before-expansion.png') })
for (const repoId of repoIds.slice(2, 12)) {
const repo = scroller.locator(`[data-repo-header-id="${repoId}"]`)
await expect
.poll(async () => {
if (await repo.count()) {
return true
}
await scroller.evaluate((element) => {
element.scrollTop += element.clientHeight / 2
})
return false
})
.toBe(true)
await repo.scrollIntoViewIfNeeded()
await expect(repo).toHaveAttribute('aria-expanded', 'false')
await repo.click()
await scroller.evaluate((element) => {
element.scrollTop = 0
})
for (const groupedRepo of groupedRepos) {
await expect(groupedRepo).toBeVisible()
}
}
await expect(group).toHaveCount(1)
await orcaPage.evaluate(() =>
window
.__store!.getState()
.fetchProjectGroups({ runtimeEnvironmentId: null, throwOnError: true })
)
await expect(group).toHaveCount(1)
await group.click()
for (const repo of groupedRepos) {
await expect(repo).toHaveCount(0)
}
await group.click()
for (const repo of groupedRepos) {
await expect(repo).toBeVisible()
}
await orcaPage.screenshot({ path: testInfo.outputPath('after-expansion.png') })
})
}