mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
* refactor(e2e): group journeys and fixtures by feature ownership * refactor(e2e): consolidate remaining Playwright owner imports * test(ci): stop copying retired route modules into fixtures * fix(browser): preserve one-shot follow intent across equal snapshots * refactor(settings): colocate commit message defaults with source control * test(browser): await page registration and focus the concrete page * fix(browser): keep viewport recovery progressing during incompatible frames * fix(browser): wait for stale helper exit before replacement commands
239 lines
7.5 KiB
TypeScript
239 lines
7.5 KiB
TypeScript
import type { Page } from '@stablyai/playwright-test'
|
|
import { expect } from '@stablyai/playwright-test'
|
|
|
|
export const shortcutModifier = process.platform === 'darwin' ? 'Meta' : 'Control'
|
|
export const guestModifier: 'meta' | 'control' = process.platform === 'darwin' ? 'meta' : 'control'
|
|
|
|
export type GuestModifier = 'meta' | 'control' | 'alt' | 'shift'
|
|
|
|
export type TerminalBrowserSplitFixture = {
|
|
browserGroupId: string
|
|
browserPageId: string
|
|
browserTabId: string
|
|
terminalGroupId: string
|
|
}
|
|
|
|
export type BrowserSplitFixture = {
|
|
firstBrowserGroupId: string
|
|
firstBrowserPageId: string
|
|
firstBrowserTabId: string
|
|
secondBrowserGroupId: string
|
|
secondBrowserPageId: string
|
|
secondBrowserTabId: string
|
|
}
|
|
|
|
export async function createTerminalBrowserSplit(
|
|
page: Page,
|
|
url = 'about:blank'
|
|
): Promise<TerminalBrowserSplitFixture> {
|
|
return page.evaluate((initialUrl) => {
|
|
const store = window.__store
|
|
if (!store) {
|
|
throw new Error('Store unavailable')
|
|
}
|
|
const state = store.getState()
|
|
const worktreeId = state.activeWorktreeId
|
|
if (!worktreeId) {
|
|
throw new Error('Active worktree unavailable')
|
|
}
|
|
const terminalTabId = state.activeTabIdByWorktree[worktreeId] ?? state.activeTabId ?? undefined
|
|
if (
|
|
!terminalTabId ||
|
|
!(state.tabsByWorktree[worktreeId] ?? []).some((tab) => tab.id === terminalTabId)
|
|
) {
|
|
throw new Error('Active terminal tab unavailable')
|
|
}
|
|
const terminalGroupId = state.ensureWorktreeRootGroup(worktreeId)
|
|
const browserGroupId = state.createEmptySplitGroup(worktreeId, terminalGroupId, 'right')
|
|
if (!browserGroupId) {
|
|
throw new Error('Browser split unavailable')
|
|
}
|
|
const browserTab = state.createBrowserTab(worktreeId, initialUrl, {
|
|
activate: true,
|
|
focusAddressBar: false,
|
|
targetGroupId: browserGroupId
|
|
})
|
|
const browserPageId = browserTab.activePageId
|
|
if (!browserPageId) {
|
|
throw new Error('Active browser page unavailable')
|
|
}
|
|
return {
|
|
browserGroupId,
|
|
browserPageId,
|
|
browserTabId: browserTab.id,
|
|
terminalGroupId
|
|
}
|
|
}, url)
|
|
}
|
|
|
|
export async function createBrowserSplit(
|
|
page: Page,
|
|
urls: { first: string; second: string } = { first: 'about:blank', second: 'about:blank' }
|
|
): Promise<BrowserSplitFixture> {
|
|
return page.evaluate((initialUrls) => {
|
|
const store = window.__store
|
|
if (!store) {
|
|
throw new Error('Store unavailable')
|
|
}
|
|
const state = store.getState()
|
|
const worktreeId = state.activeWorktreeId
|
|
if (!worktreeId) {
|
|
throw new Error('Active worktree unavailable')
|
|
}
|
|
const terminalGroupId = state.ensureWorktreeRootGroup(worktreeId)
|
|
const firstBrowserGroupId = state.createEmptySplitGroup(worktreeId, terminalGroupId, 'right')
|
|
if (!firstBrowserGroupId) {
|
|
throw new Error('First browser split unavailable')
|
|
}
|
|
const firstBrowserTab = state.createBrowserTab(worktreeId, initialUrls.first, {
|
|
activate: true,
|
|
focusAddressBar: false,
|
|
targetGroupId: firstBrowserGroupId
|
|
})
|
|
const secondBrowserGroupId = state.createEmptySplitGroup(
|
|
worktreeId,
|
|
firstBrowserGroupId,
|
|
'right'
|
|
)
|
|
if (!secondBrowserGroupId) {
|
|
throw new Error('Second browser split unavailable')
|
|
}
|
|
const secondBrowserTab = state.createBrowserTab(worktreeId, initialUrls.second, {
|
|
activate: true,
|
|
focusAddressBar: false,
|
|
targetGroupId: secondBrowserGroupId
|
|
})
|
|
const firstBrowserPageId = firstBrowserTab.activePageId
|
|
const secondBrowserPageId = secondBrowserTab.activePageId
|
|
if (!firstBrowserPageId || !secondBrowserPageId) {
|
|
throw new Error('Active browser page unavailable')
|
|
}
|
|
return {
|
|
firstBrowserGroupId,
|
|
firstBrowserPageId,
|
|
firstBrowserTabId: firstBrowserTab.id,
|
|
secondBrowserGroupId,
|
|
secondBrowserPageId,
|
|
secondBrowserTabId: secondBrowserTab.id
|
|
}
|
|
}, urls)
|
|
}
|
|
|
|
export function browserOverlay(page: Page, browserTabId: string) {
|
|
return page.locator(`[data-browser-overlay-tab-id="${browserTabId}"]`)
|
|
}
|
|
|
|
export function browserAddressBar(page: Page, browserTabId: string) {
|
|
return browserOverlay(page, browserTabId).locator('[data-orca-browser-address-bar="true"]')
|
|
}
|
|
|
|
export async function focusBrowserAddressBar(page: Page, browserTabId: string): Promise<void> {
|
|
const addressBar = browserAddressBar(page, browserTabId)
|
|
const addressBarForm = browserOverlay(page, browserTabId).locator(
|
|
'form:has(> [data-orca-browser-address-bar="true"])'
|
|
)
|
|
await expect(addressBarForm).toBeVisible()
|
|
await addressBar.focus()
|
|
await expect(addressBar).toBeFocused()
|
|
}
|
|
|
|
export async function waitForBrowserGuestRegistration(
|
|
page: Page,
|
|
browserTabId: string,
|
|
browserPageId: string
|
|
): Promise<void> {
|
|
await expect
|
|
.poll(() =>
|
|
page.evaluate(
|
|
async ({ targetBrowserPageId, targetBrowserTabId }) => {
|
|
const webview = document.querySelector<Electron.WebviewTag>(
|
|
`[data-browser-overlay-tab-id="${targetBrowserTabId}"] webview`
|
|
)
|
|
try {
|
|
if (!webview) {
|
|
return false
|
|
}
|
|
const webContentsId = webview.getWebContentsId()
|
|
const registered = await window.api.browser.isGuestRegistered({
|
|
browserPageId: targetBrowserPageId,
|
|
webContentsId
|
|
})
|
|
if (!registered) {
|
|
return false
|
|
}
|
|
return true
|
|
} catch {
|
|
return false
|
|
}
|
|
},
|
|
{
|
|
targetBrowserPageId: browserPageId,
|
|
targetBrowserTabId: browserTabId
|
|
}
|
|
)
|
|
)
|
|
.toBe(true)
|
|
}
|
|
|
|
/** Types a chord into the guest's own WebContents, the path main forwards back to the renderer. */
|
|
export async function pressKeyInBrowserGuest(
|
|
page: Page,
|
|
browserTabId: string,
|
|
browserPageId: string,
|
|
keyCode: string,
|
|
modifiers: GuestModifier[]
|
|
): Promise<void> {
|
|
await waitForBrowserGuestRegistration(page, browserTabId, browserPageId)
|
|
await page.evaluate(
|
|
async ({ targetBrowserTabId, inputKeyCode, inputModifiers }) => {
|
|
const webview = document.querySelector<Electron.WebviewTag>(
|
|
`[data-browser-overlay-tab-id="${targetBrowserTabId}"] webview`
|
|
)
|
|
if (!webview) {
|
|
throw new Error('Registered browser guest unavailable')
|
|
}
|
|
webview.focus()
|
|
await webview.sendInputEvent({
|
|
type: 'keyDown',
|
|
keyCode: inputKeyCode,
|
|
modifiers: inputModifiers
|
|
})
|
|
await webview.sendInputEvent({
|
|
type: 'keyUp',
|
|
keyCode: inputKeyCode,
|
|
modifiers: inputModifiers
|
|
})
|
|
},
|
|
{ targetBrowserTabId: browserTabId, inputKeyCode: keyCode, inputModifiers: modifiers }
|
|
)
|
|
}
|
|
|
|
export async function waitForFocusedGroup(page: Page, groupId: string): Promise<void> {
|
|
await expect
|
|
.poll(() =>
|
|
page.evaluate(() => {
|
|
const state = window.__store?.getState()
|
|
const worktreeId = state?.activeWorktreeId
|
|
return worktreeId ? state.activeGroupIdByWorktree[worktreeId] : null
|
|
})
|
|
)
|
|
.toBe(groupId)
|
|
await page.evaluate(
|
|
() =>
|
|
new Promise<void>((resolve) => {
|
|
requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
|
|
})
|
|
)
|
|
}
|
|
|
|
export async function focusBrowserGroup(page: Page, groupId: string): Promise<void> {
|
|
await page.evaluate((targetGroupId) => {
|
|
const state = window.__store?.getState()
|
|
const worktreeId = state?.activeWorktreeId
|
|
if (state && worktreeId) {
|
|
state.focusGroup(worktreeId, targetGroupId)
|
|
}
|
|
}, groupId)
|
|
await waitForFocusedGroup(page, groupId)
|
|
}
|