mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-17 05:26:47 +03:00
2306 lines
104 KiB
TypeScript
2306 lines
104 KiB
TypeScript
import type { OpenCodeEvent, SessionMessageInfo } from "@opencode/client/promise"
|
||
import { expect, test, type Locator, type Page } from "@playwright/test"
|
||
import { base64Encode } from "@opencode/util/encode"
|
||
import { SERVER, holdRoute, project, provider, session } from "../utils/app"
|
||
import { browseFiles, openFileLauncher, openReviewLauncher, reviewTabs } from "../utils/side-panel"
|
||
import { mockOpenCodeServer } from "../utils/mock-server"
|
||
import { fileDiff, fileNode, openSession } from "../utils/workspace"
|
||
import { expectSessionTitle } from "../utils/waits"
|
||
import { readFile } from "node:fs/promises"
|
||
|
||
test.use({ viewport: { width: 1440, height: 900 } })
|
||
|
||
test("review toggle shows its tooltip with the side panel open or closed", async ({ page }) => {
|
||
await openSession(page, {
|
||
name: "ReviewTooltip",
|
||
seed: { panes: { ses_reviewtooltip: { review: true } } },
|
||
})
|
||
const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
|
||
const tooltip = page.getByRole("tooltip", { name: /Toggle review/ })
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(page.locator("#review-panel")).toHaveAttribute("aria-hidden", "false")
|
||
await toggle.hover()
|
||
await expect(tooltip).toBeVisible()
|
||
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
await page.locator("[data-session-title]").hover()
|
||
await expect(tooltip).toBeHidden()
|
||
await toggle.hover()
|
||
await expect(tooltip).toBeVisible()
|
||
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await page.locator("[data-session-title]").hover()
|
||
await expect(tooltip).toBeHidden()
|
||
await toggle.hover()
|
||
await expect(tooltip).toBeVisible()
|
||
})
|
||
|
||
for (const view of ["desktop", "mobile"] as const) {
|
||
test(`offers Git initialization for a project without VCS (${view})`, async ({ page }) => {
|
||
if (view === "mobile") await page.setViewportSize({ width: 390, height: 844 })
|
||
const requests: { directory: string; provider?: string }[] = []
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "ReviewWithoutGit",
|
||
project: { vcs: undefined },
|
||
onVcsInit: (input) => requests.push(input),
|
||
})
|
||
|
||
if (view === "desktop") await page.getByRole("button", { name: "Toggle review" }).click()
|
||
else await page.getByRole("tablist", { name: "Session view" }).getByRole("tab", { name: "Changes" }).click()
|
||
|
||
const panel = view === "desktop" ? page.locator("#review-panel") : page.locator('[data-component="session-review"]')
|
||
|
||
if (view === "desktop") await openReviewLauncher(panel)
|
||
await expect(panel.getByText("Track, review, and undo changes in this project")).toBeVisible()
|
||
await expect(panel.getByRole("button", { name: "Git changes" })).toHaveCount(0)
|
||
const init = panel.getByRole("button", { name: "Create Git repository" })
|
||
await init.click()
|
||
await expect.poll(() => requests).toEqual([{ directory: workspace.directory, provider: "git" }])
|
||
await expect(panel.getByRole("button", { name: "Git changes" })).toBeVisible()
|
||
await expect(init).toHaveCount(0)
|
||
})
|
||
}
|
||
|
||
test("Git initialization belongs to its session and refreshes after a session switch", async ({ page }) => {
|
||
const requests: { directory: string; provider?: string }[] = []
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "ReviewInitSwitch",
|
||
project: { vcs: undefined },
|
||
onVcsInit: (input) => requests.push(input),
|
||
sessions: [
|
||
{ id: "ses_init_a", title: "Initialize Alpha" },
|
||
{ id: "ses_init_b", title: "Initialize Beta" },
|
||
],
|
||
seed: {
|
||
panes: { ses_init_a: { review: true }, ses_init_b: { review: true } },
|
||
storage: reviewTabs("C:/OpenCode/ReviewInitSwitch", "ses_init_a", "ses_init_b"),
|
||
},
|
||
})
|
||
|
||
// The successful init finishes while another session is routed.
|
||
const request = await holdRoute(page, (url) => url.pathname === "/api/vcs/init", { method: "POST" })
|
||
const panel = page.locator("#review-panel")
|
||
const init = panel.getByRole("button", { name: "Create Git repository", exact: true })
|
||
const pending = panel.getByRole("button", { name: "Creating Git repository…", exact: true })
|
||
await expect(init).toBeEnabled()
|
||
await init.click()
|
||
await request.arrived
|
||
await expect(pending).toBeDisabled()
|
||
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Beta" }).click()
|
||
await expectSessionTitle(page, "Initialize Beta")
|
||
await expect(init).toBeEnabled()
|
||
await expect(pending).toHaveCount(0)
|
||
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Alpha" }).click()
|
||
await expectSessionTitle(page, "Initialize Alpha")
|
||
await expect(pending).toBeDisabled()
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Beta" }).click()
|
||
await expectSessionTitle(page, "Initialize Beta")
|
||
await expect(init).toBeEnabled()
|
||
|
||
const response = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/vcs/init")
|
||
// The worktree event can refresh project-wide UI by itself; the completed action must also reload Alpha's cache.
|
||
const refreshed = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/session/ses_init_a")
|
||
request.release()
|
||
expect((await response).status()).toBe(204)
|
||
expect((await refreshed).status()).toBe(200)
|
||
expect(requests).toEqual([{ directory: workspace.directory, provider: "git" }])
|
||
await expect(panel.getByRole("button", { name: "Git changes", exact: true })).toBeVisible()
|
||
await expect(init).toHaveCount(0)
|
||
await expect(page.getByText("Request failed", { exact: true })).toHaveCount(0)
|
||
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Alpha" }).click()
|
||
await expectSessionTitle(page, "Initialize Alpha")
|
||
await expect(panel.getByRole("button", { name: "Git changes", exact: true })).toBeVisible()
|
||
await expect(pending).toHaveCount(0)
|
||
})
|
||
|
||
test("a rejected Git init releases its session's button without showing an error in another session", async ({
|
||
page,
|
||
}) => {
|
||
await openSession(page, {
|
||
name: "ReviewInitFailure",
|
||
project: { vcs: undefined },
|
||
sessions: [
|
||
{ id: "ses_init_failure_a", title: "Initialize Alpha" },
|
||
{ id: "ses_init_failure_b", title: "Initialize Beta" },
|
||
],
|
||
seed: {
|
||
panes: { ses_init_failure_a: { review: true }, ses_init_failure_b: { review: true } },
|
||
storage: reviewTabs("C:/OpenCode/ReviewInitFailure", "ses_init_failure_a", "ses_init_failure_b"),
|
||
},
|
||
})
|
||
const request = await holdRoute(page, (url) => url.pathname === "/api/vcs/init", { method: "POST" })
|
||
const init = page.locator("#review-panel").getByRole("button", { name: "Create Git repository", exact: true })
|
||
await init.click()
|
||
await request.arrived
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Beta" }).click()
|
||
await expectSessionTitle(page, "Initialize Beta")
|
||
await expect(init).toBeEnabled()
|
||
const response = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/vcs/init")
|
||
request.release()
|
||
expect((await response).status()).toBe(501)
|
||
await expect(page.getByText("Request failed", { exact: true })).toHaveCount(0)
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: "Initialize Alpha" }).click()
|
||
await expectSessionTitle(page, "Initialize Alpha")
|
||
await expect(init).toBeEnabled()
|
||
})
|
||
|
||
test("a created Git repository whose project refresh fails still refreshes the session without an error", async ({
|
||
page,
|
||
}) => {
|
||
await openSession(page, {
|
||
name: "ReviewInitRefresh",
|
||
project: { vcs: undefined },
|
||
onVcsInit: () => undefined,
|
||
sessions: [{ id: "ses_init_refresh", title: "Initialize Refresh" }],
|
||
seed: {
|
||
panes: { ses_init_refresh: { review: true } },
|
||
storage: reviewTabs("C:/OpenCode/ReviewInitRefresh", "ses_init_refresh"),
|
||
},
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const init = panel.getByRole("button", { name: "Create Git repository", exact: true })
|
||
await expect(init).toBeEnabled()
|
||
|
||
// The repository is created; the project list refresh after it fails.
|
||
await page.route(/\/api\/project(\?|$)/, (route) =>
|
||
route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} }),
|
||
)
|
||
const created = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/vcs/init")
|
||
const project = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/project")
|
||
const session = page.waitForResponse((item) => new URL(item.url()).pathname === "/api/session/ses_init_refresh")
|
||
await init.click()
|
||
expect((await created).status()).toBe(204)
|
||
expect((await project).status()).toBe(500)
|
||
expect((await session).status()).toBe(200)
|
||
await expect(panel.getByRole("button", { name: "Creating Git repository…", exact: true })).toHaveCount(0)
|
||
await expect(page.getByText("Request failed", { exact: true })).toHaveCount(0)
|
||
})
|
||
|
||
test("opens file picker launchers when randomUUID is unavailable on insecure HTTP origins", async ({ page }) => {
|
||
await page.addInitScript(() => {
|
||
Object.defineProperty(globalThis, "isSecureContext", { configurable: true, value: false })
|
||
Object.defineProperty(globalThis.crypto, "randomUUID", { configurable: true, value: undefined })
|
||
})
|
||
|
||
await openSession(page, {
|
||
name: "ReviewOpenFileInsecure",
|
||
seed: { panes: { ses_reviewopenfileinsecure: { review: true } } },
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
const tab = panel.getByRole("tab", { name: "Open file", exact: true })
|
||
await openFileLauncher(panel)
|
||
await expect(tab).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByRole("combobox", { name: "Filter files" })).toBeFocused()
|
||
|
||
await openFileLauncher(panel)
|
||
await expect(tab).toHaveCount(2)
|
||
})
|
||
|
||
test("open file tab browses, searches, and tracks missing files", async ({ page }) => {
|
||
const searches: { query: string; dirs?: string; limit?: number; directory: string }[] = []
|
||
const directory = "C:/OpenCode/ReviewOpenFile"
|
||
const files = Array.from({ length: 80 }, (_, index) => `file-${String(index).padStart(2, "0")}.ts`)
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "ReviewOpenFile",
|
||
vcsDiff: [fileDiff("src/changed.ts")],
|
||
fileList: (path) =>
|
||
path
|
||
? []
|
||
: [
|
||
fileNode(directory, "README.md"),
|
||
fileNode(directory, "src", "directory"),
|
||
...files.map((file) => fileNode(directory, file)),
|
||
],
|
||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||
findFiles: (input) => {
|
||
searches.push(input)
|
||
|
||
return input.query === "nested" ? [fileNode(directory, "src/nested.ts")] : []
|
||
},
|
||
seed: {
|
||
panes: { ses_reviewopenfile: { review: true } },
|
||
storage: {
|
||
...reviewTabs("C:/OpenCode/ReviewOpenFile", "ses_reviewopenfile"),
|
||
"opencode.global.dat:review-panel-v2": { sidebarOpened: false },
|
||
},
|
||
},
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
const sidebar = panel.locator('[data-slot="session-review-v2-sidebar"]')
|
||
const sidebarToggle = panel.getByRole("button", { name: "Toggle file tree" })
|
||
const contextButton = page.getByRole("button", { name: "Toggle session context" })
|
||
const tab = (name: string) => panel.getByRole("tab", { name, exact: true })
|
||
await contextButton.click()
|
||
await expect(tab("Context")).toHaveAttribute("aria-selected", "true")
|
||
await openFileLauncher(panel)
|
||
const filter = panel.getByRole("combobox", { name: "Filter files" })
|
||
await expect(filter).toBeFocused()
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "true")
|
||
await expect(sidebarToggle).toBeDisabled()
|
||
await expect(sidebar).toBeVisible()
|
||
await contextButton.click()
|
||
await expect(tab("Context")).toHaveAttribute("aria-selected", "true")
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "false")
|
||
await expect(sidebar).toBeHidden()
|
||
// The strip's launcher tab returns to it.
|
||
await tab("Open file").click()
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("ReviewOpenFile", { exact: true })).toBeVisible()
|
||
|
||
await panel.getByRole("treeitem", { name: "README.md" }).click()
|
||
await expect(tab("README.md")).toHaveAttribute("aria-selected", "true")
|
||
await expect(sidebarToggle).toBeEnabled()
|
||
await expect(panel.getByText("contents:README.md", { exact: true })).toBeVisible()
|
||
await expect(sidebar).toHaveCount(0)
|
||
|
||
const missingRead = "**/api/fs/read/README.md*"
|
||
await page.route(missingRead, (route) =>
|
||
route.fulfill({
|
||
status: 404,
|
||
headers: { "access-control-allow-origin": "*" },
|
||
// SAFETY: the server's wire body for a missing file, which the client decodes into its own error.
|
||
// oxlint-disable-next-line anti-slop-effect/no-manual-tagged-construction -- see SAFETY above
|
||
json: { _tag: "FileNotFoundError", path: "README.md", message: "File not found: README.md" },
|
||
}),
|
||
)
|
||
const missingResponse = page.waitForResponse((response) => response.url().includes("/api/fs/read/README.md"))
|
||
await workspace.push([filesystemEvent(directory, "README.md", "unlink")])
|
||
await missingResponse
|
||
await expect(page.getByText("Failed to load file", { exact: true })).toHaveCount(0)
|
||
await expect(tab("File not found: README.md")).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("File not found: README.md", { exact: true })).toBeVisible()
|
||
|
||
await page.unroute(missingRead)
|
||
await workspace.push([filesystemEvent(directory, "README.md", "add")])
|
||
await expect(tab("README.md")).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("contents:README.md", { exact: true })).toBeVisible()
|
||
|
||
// A new launcher opens beside the preview rather than replacing it.
|
||
await browseFiles(page)
|
||
await expect(tab("README.md")).toHaveAttribute("aria-selected", "false")
|
||
await expect(sidebar).toBeVisible()
|
||
await filter.fill("nested")
|
||
const result = panel.getByRole("option", { name: /nested\.ts/ })
|
||
await expect(result).toBeVisible()
|
||
await expect(filter).toHaveAttribute("aria-activedescendant", (await result.getAttribute("id"))!)
|
||
await filter.press("Enter")
|
||
await expect(tab("nested.ts")).toHaveAttribute("aria-selected", "true")
|
||
await expect(sidebarToggle).toBeEnabled()
|
||
await expect(panel.getByText("contents:src/nested.ts", { exact: true })).toBeVisible()
|
||
expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200, directory })
|
||
|
||
await browseFiles(page)
|
||
await expect(tab("nested.ts")).toHaveCount(1)
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "true")
|
||
await expect(sidebarToggle).toBeDisabled()
|
||
await panel.locator("#session-side-panel-review-tab").click()
|
||
await expect(sidebarToggle).toBeEnabled()
|
||
await tab("Open file").click()
|
||
await page.keyboard.press("Control+w")
|
||
await expect(tab("Open file")).toHaveCount(0)
|
||
await expect(tab("nested.ts")).toHaveAttribute("aria-selected", "true")
|
||
|
||
// The New tab view keeps offering Open file, so several launchers stay open; a pick replaces the selected one.
|
||
await openFileLauncher(panel)
|
||
await openFileLauncher(panel)
|
||
await expect(tab("Open file")).toHaveCount(2)
|
||
await panel.getByRole("treeitem", { name: "README.md" }).click()
|
||
await expect(tab("README.md")).toHaveAttribute("aria-selected", "true")
|
||
await expect(tab("Open file")).toHaveCount(1)
|
||
await tab("Open file").click()
|
||
await page.keyboard.press("Control+w")
|
||
await expect(tab("Open file")).toHaveCount(0)
|
||
await expect(tab("nested.ts")).toHaveAttribute("aria-selected", "true")
|
||
|
||
// The file browser beside file tabs keeps its DOM and scroll position across preview and pinned tab switches.
|
||
await sidebarToggle.click()
|
||
await filter.fill("")
|
||
const root = panel.locator('[data-component="session-review-v2-sidebar-root"]')
|
||
const viewport = root.locator('[data-slot="session-review-v2-sidebar-tree"] [data-file-tree-virtualized-scroll]')
|
||
await expect(root.getByRole("treeitem", { name: "file-00.ts" })).toBeVisible()
|
||
await viewport.hover()
|
||
await page.mouse.wheel(0, 100_000)
|
||
await expect
|
||
.poll(() => viewport.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
|
||
.toBeLessThanOrEqual(1)
|
||
// The tree ignores the pointer until a scroll settles. A click before then hits the scroller, and Playwright's retry
|
||
// scrolls the row into view itself, which moves the position this case guards.
|
||
await expect(viewport.locator("[data-file-tree-virtualized-list]")).not.toHaveAttribute("data-is-scrolling")
|
||
const scrolled = await viewport.evaluate((element) => element.scrollTop)
|
||
expect(scrolled).toBeGreaterThan(0)
|
||
await root.evaluate((element) => void (element.dataset.e2eProbe = "original"))
|
||
|
||
const expectSidebarKept = async () => {
|
||
expect(await root.evaluate((element) => element.dataset.e2eProbe)).toBe("original")
|
||
await expect.poll(() => viewport.evaluate((element) => element.scrollTop)).toBe(scrolled)
|
||
}
|
||
|
||
await root.getByRole("treeitem", { name: "file-79.ts" }).click()
|
||
await expect(tab("file-79.ts")).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("contents:file-79.ts", { exact: true })).toBeVisible()
|
||
await expectSidebarKept()
|
||
await root.getByRole("treeitem", { name: "file-78.ts" }).dblclick()
|
||
await expect(tab("file-78.ts")).toHaveAttribute("aria-selected", "true")
|
||
await root.getByRole("treeitem", { name: "file-79.ts" }).click()
|
||
await expect(tab("file-79.ts")).toHaveAttribute("aria-selected", "true")
|
||
await tab("file-78.ts").click()
|
||
await expect(tab("file-78.ts")).toHaveAttribute("aria-selected", "true")
|
||
await expectSidebarKept()
|
||
|
||
// Context opens in front and keeps the preview tab, so closing it selects the first remaining tab.
|
||
await tab("Context").click({ button: "middle" })
|
||
await expect(tab("Context")).toHaveCount(0)
|
||
await contextButton.click()
|
||
await expect(tab("Context")).toHaveAttribute("aria-selected", "true")
|
||
await expect(tab("file-79.ts")).toHaveCount(1)
|
||
await contextButton.click()
|
||
await expect(tab("Context")).toHaveCount(0)
|
||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||
})
|
||
|
||
for (const listed of [false, true]) {
|
||
test(`the open file heading names a subfolder session ${listed ? "after its sidebar project" : "after its folder"}`, async ({
|
||
page,
|
||
}) => {
|
||
const root = "C:/OpenCode/BrowserRepo"
|
||
const directory = `${root}/packages/app`
|
||
await openSession(page, {
|
||
name: "BrowserRepo",
|
||
sessions: [{ id: "ses_browserrepo", title: "BrowserRepo", directory }],
|
||
fileList: (path) => (path ? [] : [fileNode(directory, "README.md")]),
|
||
// The server also lists the subfolder as its own project, renamed.
|
||
...(listed && {
|
||
projects: [
|
||
project({ id: "proj_browserrepo", directory: root, name: "BrowserRepo" }),
|
||
project({ id: "proj_browserrepo_app", directory, name: "Custom app" }),
|
||
],
|
||
}),
|
||
seed: { panes: { ses_browserrepo: { review: true } } },
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
await openFileLauncher(panel)
|
||
await expect(panel.getByRole("treeitem", { name: "README.md" })).toBeVisible()
|
||
await expect(panel.locator('[data-slot="session-review-v2-sidebar-title"]')).toHaveText(
|
||
listed ? "Custom app" : "app",
|
||
)
|
||
})
|
||
}
|
||
|
||
test("context closes the side region only when its button opened it", async ({ page }) => {
|
||
// A /btw tab saved before plugins must not linger as a hidden tab that keeps the region open.
|
||
await openSession(page, {
|
||
name: "ReviewContextOpener",
|
||
seed: {
|
||
storage: {
|
||
"opencode.global.dat:layout": {
|
||
sessionTabs: {
|
||
[`local\u0000${base64Encode("C:/OpenCode/ReviewContextOpener")}/ses_reviewcontextopener`]: {
|
||
all: ["btw"],
|
||
active: "btw",
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
|
||
const contextButton = page.getByRole("button", { name: "Toggle session context" })
|
||
const context = panel.getByRole("tab", { name: "Context", exact: true })
|
||
|
||
await contextButton.click()
|
||
await expect(context).toHaveAttribute("aria-selected", "true")
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await contextButton.click()
|
||
await expect(context).toHaveCount(0)
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
|
||
// With another tab open, closing Context leaves the region open on it.
|
||
await contextButton.click()
|
||
await expect(context).toHaveAttribute("aria-selected", "true")
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(context).toHaveAttribute("aria-selected", "true")
|
||
// "+" opens the New tab view over Context; picking a launcher replaces it with the tab it opens.
|
||
const newTab = panel.getByRole("tab", { name: "New tab", exact: true })
|
||
await panel.getByRole("button", { name: "Add tab", exact: true }).click()
|
||
await expect(newTab).toHaveAttribute("aria-selected", "true")
|
||
await panel.getByRole("button", { name: /^Review/ }).click()
|
||
await expect(newTab).toHaveCount(0)
|
||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||
// Closing Review returns to Context, the tab the view opened over, without bringing the replaced view back.
|
||
await panel
|
||
.locator('div[data-value="review:changes"]')
|
||
.getByRole("button", { name: "Close tab", exact: true })
|
||
.click()
|
||
await expect(context).toHaveAttribute("aria-selected", "true")
|
||
await expect(newTab).toHaveCount(0)
|
||
// "Recently closed" lists only files, so the closed Review is offered again by its launcher alone.
|
||
await panel.getByRole("button", { name: "Add tab", exact: true }).click()
|
||
await expect(panel.getByRole("region", { name: "Recently closed", exact: true })).toHaveCount(0)
|
||
await panel.getByRole("button", { name: /^Review/ }).click()
|
||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||
await context.click()
|
||
await contextButton.click()
|
||
await expect(context).toHaveCount(0)
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||
})
|
||
|
||
test("context hides zero cost for Go and free models but keeps paid-model cost", async ({ page }) => {
|
||
const cases = [
|
||
{ id: "ses_context_free", title: "Free model", model: "free", cost: 0, usage: false, text: "0" },
|
||
{ id: "ses_context_paid", title: "Paid model", model: "paid", cost: 0, usage: false, text: "0·$0.00" },
|
||
{ id: "ses_context_used", title: "Paid usage", model: "paid", cost: 1.25, usage: true, text: "2k·$1.25" },
|
||
{ id: "ses_context_free_used", title: "Free usage", model: "free", cost: 0, usage: true, text: "2k" },
|
||
{ id: "ses_context_mixed", title: "Previously paid", model: "free", cost: 1.25, usage: true, text: "2k·$1.25" },
|
||
{ id: "ses_context_unknown", title: "Unknown pricing", model: "missing", cost: 0, usage: false, text: "0·$0.00" },
|
||
{ id: "ses_context_output", title: "Output pricing", model: "output", cost: 0, usage: false, text: "0·$0.00" },
|
||
{
|
||
id: "ses_context_go",
|
||
title: "Covered by Go",
|
||
providerID: "opencode-go",
|
||
model: "paid",
|
||
cost: 0,
|
||
usage: true,
|
||
text: "2k",
|
||
},
|
||
{
|
||
id: "ses_context_go_spend",
|
||
title: "Go with charges",
|
||
providerID: "opencode-go",
|
||
model: "paid",
|
||
cost: 0.38,
|
||
usage: true,
|
||
text: "2k·$0.38",
|
||
},
|
||
// The root's model is free, but its subagent spent on a paid model: the family total shows.
|
||
{ id: "ses_context_family", title: "Paid subagent", model: "free", cost: 0, usage: true, text: "2k·$1.25" },
|
||
// A completed compaction resets the context until the next reply reports usage, as in the TUI.
|
||
{ id: "ses_context_compacted", title: "Compacted", model: "paid", cost: 1.25, usage: true, text: "0·$1.25" },
|
||
]
|
||
|
||
const catalog = provider(
|
||
{ id: "free", name: "Free", cost: { input: 0, output: 0 } },
|
||
{ id: "paid", name: "Paid", cost: { input: 1, output: 3 } },
|
||
{ id: "output", name: "Output", cost: { input: 0, output: 1 } },
|
||
)
|
||
|
||
await openSession(page, {
|
||
name: "ContextPricing",
|
||
provider: {
|
||
...catalog,
|
||
all: [...catalog.all, { ...catalog.all[0], id: "opencode-go", name: "OpenCode Go" }],
|
||
connected: [...catalog.connected, "opencode-go"],
|
||
},
|
||
sessions: [
|
||
...cases.map((item) => ({
|
||
id: item.id,
|
||
title: item.title,
|
||
model: { id: item.model, providerID: item.providerID ?? "opencode" },
|
||
cost: item.cost,
|
||
})),
|
||
{
|
||
id: "ses_context_family_child",
|
||
parentID: "ses_context_family",
|
||
title: "Subagent run",
|
||
model: { id: "paid", providerID: "opencode" },
|
||
cost: 1.25,
|
||
},
|
||
],
|
||
pageMessages: (id) => ({
|
||
items: cases.flatMap((item): SessionMessageInfo[] =>
|
||
item.id === id && item.usage
|
||
? [
|
||
{
|
||
id: `msg_${item.id}`,
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: item.model, providerID: item.providerID ?? "opencode" },
|
||
tokens: { input: 1500, output: 500, reasoning: 0, cache: { read: 0, write: 0 } },
|
||
content: [{ type: "text", text: "Done." }],
|
||
time: { created: 1, completed: 2 },
|
||
},
|
||
...(item.id === "ses_context_compacted"
|
||
? [
|
||
{
|
||
id: `msg_${item.id}_compaction`,
|
||
type: "compaction" as const,
|
||
status: "completed" as const,
|
||
reason: "manual" as const,
|
||
summary: "Current state",
|
||
recent: "",
|
||
time: { created: 3 },
|
||
},
|
||
]
|
||
: []),
|
||
]
|
||
: [],
|
||
),
|
||
}),
|
||
})
|
||
const button = page.getByRole("button", { name: "Toggle session context", exact: true })
|
||
|
||
for (const item of cases) {
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: item.title }).click()
|
||
await expectSessionTitle(page, item.title)
|
||
await expect(button).toHaveText(item.text)
|
||
|
||
if (item.providerID === "opencode-go") {
|
||
await button.click()
|
||
const panel = page.locator('[data-slot="session-usage-content"]')
|
||
|
||
await expect(panel.getByText("OpenCode Go", { exact: true })).toBeVisible()
|
||
await expect(panel.getByText("Total Cost", { exact: true })).toBeVisible({ visible: item.cost > 0 })
|
||
await button.click()
|
||
}
|
||
}
|
||
})
|
||
|
||
test("file tree expands Windows paths and scrolls long names in both directions", async ({ page }) => {
|
||
const directory = "C:/OpenCode/OpenFileExpand"
|
||
const longFilename = "a-very-long-file-name-that-must-overflow-the-file-sidebar-instead-of-being-truncated.ts"
|
||
const longPath = `frontend/${longFilename}`
|
||
await openSession(page, {
|
||
name: "OpenFileExpand",
|
||
vcsDiff: [
|
||
{
|
||
file: longPath,
|
||
additions: 1,
|
||
deletions: 0,
|
||
status: "added",
|
||
patch: "@@ -0,0 +1 @@\n+export const added = true\n",
|
||
},
|
||
],
|
||
fileList: (path) => {
|
||
if (path === "frontend\\" || path === "frontend") {
|
||
return [
|
||
fileNode(directory, "frontend/nested", "directory"),
|
||
{ ...fileNode(directory, "frontend/app.ts"), path: "frontend\\app.ts" },
|
||
{ ...fileNode(directory, longPath), path: `frontend\\${longFilename}` },
|
||
// Short rows below the long one, so it can scroll out of view.
|
||
...Array.from({ length: 80 }, (_, index) => {
|
||
const name = `file-${String(index).padStart(2, "0")}.ts`
|
||
|
||
return { ...fileNode(directory, `frontend/${name}`), path: `frontend\\${name}` }
|
||
}),
|
||
]
|
||
}
|
||
|
||
if (path === "frontend/nested") return [fileNode(directory, "frontend/nested/child.ts")]
|
||
|
||
if (path) return []
|
||
|
||
return [
|
||
{ ...fileNode(directory, "frontend", "directory"), name: "", path: "frontend\\" },
|
||
fileNode(directory, "README.md"),
|
||
]
|
||
},
|
||
findFiles: ({ query }) => (longPath.includes(query) ? [fileNode(directory, longPath)] : []),
|
||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||
seed: {
|
||
panes: { ses_openfileexpand: { review: true } },
|
||
storage: { "opencode.global.dat:review-panel-v2": { sidebarOpened: true } },
|
||
},
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
await openFileLauncher(panel)
|
||
await expect(panel.getByRole("tab", { name: "Open file" })).toHaveAttribute("aria-selected", "true")
|
||
const sidebar = panel.locator('[data-component="session-review-v2-sidebar-root"]')
|
||
const frontend = panel.locator('[data-type="item"][data-item-path="frontend/"]')
|
||
await expect(frontend.getByText("frontend", { exact: true })).toBeVisible()
|
||
await expect(frontend).toHaveAttribute("aria-expanded", "false")
|
||
await frontend.click()
|
||
await expect(frontend).toHaveAttribute("aria-expanded", "true")
|
||
|
||
const nested = panel.locator('[data-type="item"][data-item-path="frontend/nested/"]')
|
||
await nested.click()
|
||
const child = panel.locator('[data-type="item"][data-item-path="frontend/nested/child.ts"]')
|
||
await expect(child).toBeVisible()
|
||
await expect(child.locator('[data-item-section="spacing-item"]')).toHaveCount(2)
|
||
|
||
// Every ancestor guide runs through its folder's chevron, not just the first indentation level.
|
||
const guideOffset = () =>
|
||
child.evaluate((element) => {
|
||
const root = element.getRootNode()
|
||
|
||
if (!(root instanceof ShadowRoot)) throw new Error("Expected the file tree's shadow root")
|
||
|
||
return Math.max(
|
||
...Array.from(element.querySelectorAll<HTMLElement>('[data-item-section="spacing-item"]'), (guide) => {
|
||
const folder = Array.from(root.querySelectorAll<HTMLElement>('[data-type="item"]')).find(
|
||
(row) => row.dataset.itemPath === guide.dataset.ancestorPath,
|
||
)!
|
||
|
||
const icon = folder.querySelector('[data-item-section="icon"]')!.getBoundingClientRect()
|
||
const line = guide.getBoundingClientRect()
|
||
const center = getComputedStyle(guide).direction === "rtl" ? line.right - 0.5 : line.left + 0.5
|
||
|
||
return Math.abs(center - (icon.left + icon.width / 2))
|
||
}),
|
||
)
|
||
})
|
||
|
||
await expect.poll(guideOffset).toBeLessThanOrEqual(0.5)
|
||
|
||
const viewport = sidebar.locator('[data-slot="session-review-v2-sidebar-viewport"]')
|
||
const longRow = panel.locator(`[data-type="item"][data-item-path="${longPath}"]`)
|
||
const content = longRow.locator('[data-item-section="content"]')
|
||
const status = longRow.locator('[data-item-section="git"]')
|
||
await expect(longRow).toBeVisible()
|
||
await expect(content).toHaveAttribute("title", longFilename)
|
||
// The name is never clipped: the tree scrolls sideways and the change letter sticks to the pane's edge.
|
||
await expect
|
||
.poll(() => content.evaluate((element) => element.scrollWidth - element.clientWidth))
|
||
.toBeLessThanOrEqual(0)
|
||
await expect
|
||
.poll(() =>
|
||
longRow.evaluate((element) => {
|
||
const scroll = element.closest("[data-file-tree-virtualized-scroll]")!
|
||
|
||
return scroll.scrollWidth - scroll.clientWidth
|
||
}),
|
||
)
|
||
.toBeGreaterThan(0)
|
||
await expect(status).toHaveText("A")
|
||
await expect.poll(() => statusInset(status, "right")).toBeLessThanOrEqual(24)
|
||
const treeScroll = panel.locator(".opencode-pierre-file-tree")
|
||
|
||
const scrollTree = (position: { left?: number; top?: number }) =>
|
||
treeScroll.evaluate((element, position) => {
|
||
const scroll = element.shadowRoot!.querySelector<HTMLElement>("[data-file-tree-virtualized-scroll]")!
|
||
|
||
if (position.left !== undefined) scroll.scrollLeft = position.left
|
||
|
||
if (position.top !== undefined) scroll.scrollTop = position.top
|
||
|
||
return { left: scroll.scrollLeft, overflow: scroll.scrollWidth - scroll.clientWidth }
|
||
}, position)
|
||
|
||
await scrollTree({ left: 1_000_000 })
|
||
await expect.poll(() => statusInset(status, "right")).toBeLessThanOrEqual(24)
|
||
// The tree keeps the long row's width after it scrolls out of view, so the sideways position holds.
|
||
await scrollTree({ top: 1_000_000 })
|
||
await expect(longRow).toHaveCount(0)
|
||
await expect.poll(async () => (await scrollTree({})).overflow).toBeGreaterThan(0)
|
||
await expect.poll(async () => (await scrollTree({})).left).toBeGreaterThan(0)
|
||
await scrollTree({ left: 0, top: 0 })
|
||
await viewport.evaluate((element) => element.setAttribute("dir", "rtl"))
|
||
await expect.poll(guideOffset).toBeLessThanOrEqual(0.5)
|
||
await expect.poll(() => statusInset(status, "left")).toBeLessThanOrEqual(24)
|
||
await frontend.focus()
|
||
await page.keyboard.press("ArrowRight")
|
||
await expect(frontend).toHaveAttribute("aria-expanded", "false")
|
||
await page.keyboard.press("ArrowLeft")
|
||
await expect(frontend).toHaveAttribute("aria-expanded", "true")
|
||
await viewport.evaluate((element) => element.removeAttribute("dir"))
|
||
|
||
const filter = panel.getByRole("combobox", { name: "Filter files" })
|
||
await filter.fill(longFilename)
|
||
const filteredOption = panel.getByRole("option", { name: longFilename })
|
||
await expect(filteredOption.locator('svg[data-icon-token="typescript"]')).toBeVisible()
|
||
const filteredStatus = filteredOption.locator('[data-slot="file-tree-v2-change"]')
|
||
await expect(filteredStatus).toHaveText("A")
|
||
await expect.poll(() => viewport.evaluate((element) => element.scrollWidth - element.clientWidth)).toBeGreaterThan(0)
|
||
await expect.poll(() => statusInset(filteredStatus, "right")).toBeLessThanOrEqual(24)
|
||
await viewport.hover()
|
||
await page.mouse.wheel(1_000, 0)
|
||
await expect.poll(() => viewport.evaluate((element) => element.scrollLeft)).toBeGreaterThan(0)
|
||
await expect.poll(() => statusInset(filteredStatus, "right")).toBeLessThanOrEqual(24)
|
||
await viewport.evaluate((element) => {
|
||
element.setAttribute("dir", "rtl")
|
||
element.scrollLeft = -1_000_000
|
||
})
|
||
await expect.poll(() => viewport.evaluate((element) => element.scrollLeft)).toBeLessThan(0)
|
||
await expect.poll(() => statusInset(filteredStatus, "left")).toBeLessThanOrEqual(24)
|
||
await viewport.evaluate((element) => {
|
||
element.removeAttribute("dir")
|
||
element.scrollLeft = 0
|
||
})
|
||
|
||
await filter.fill("")
|
||
await panel.locator('[data-type="item"][data-item-path="frontend/app.ts"]').click()
|
||
await expect(panel.getByRole("tab", { name: "app.ts" })).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("contents:frontend/app.ts", { exact: true })).toBeVisible()
|
||
})
|
||
|
||
test("the file tree follows a folder the review closes and lists a recreated folder's files", async ({ page }) => {
|
||
const directory = "C:/OpenCode/TreeFollow"
|
||
const disk = { src: true }
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "TreeFollow",
|
||
vcsDiff: [fileDiff("src/a.ts")],
|
||
fileList: (path) => {
|
||
if (!disk.src) return path ? [] : [fileNode(directory, "README.md")]
|
||
|
||
if (path === "src") return [fileNode(directory, "src/a.ts")]
|
||
|
||
return path ? [] : [fileNode(directory, "src", "directory"), fileNode(directory, "README.md")]
|
||
},
|
||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||
seed: {
|
||
panes: { ses_treefollow: { review: true } },
|
||
storage: { "opencode.global.dat:review-panel-v2": { sidebarOpened: true } },
|
||
},
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
const tab = (name: string) => panel.getByRole("tab", { name, exact: true })
|
||
// Only the selected tab's tree is visible; the file browser stays mounted, hidden, behind the review.
|
||
const folder = panel.getByRole("treeitem", { name: "src" })
|
||
const file = panel.getByRole("treeitem", { name: "a.ts" })
|
||
|
||
await openReviewLauncher(panel)
|
||
await expect(file).toBeVisible()
|
||
await openFileLauncher(panel)
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "true")
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "true")
|
||
await expect(file).toBeVisible()
|
||
|
||
// The review shares the workspace's folders: closing one there closes it in the file browser too.
|
||
await panel.locator("#session-side-panel-review-tab").click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "true")
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "false")
|
||
await tab("Open file").click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "false")
|
||
await expect(file).toHaveCount(0)
|
||
|
||
// A deleted folder takes its files with it, so they show again once it is recreated and opened.
|
||
await folder.click()
|
||
await expect(file).toBeVisible()
|
||
disk.src = false
|
||
await workspace.push([filesystemEvent(directory, "src", "unlink")])
|
||
await expect(folder).toHaveCount(0)
|
||
disk.src = true
|
||
await workspace.push([filesystemEvent(directory, "src", "add")])
|
||
await expect(folder).toHaveAttribute("aria-expanded", "false")
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "true")
|
||
await expect(file).toBeVisible()
|
||
})
|
||
|
||
test("rereads a file each time an artifact link opens it", async ({ page }) => {
|
||
// Enough lines to scroll the code view, ending in the draft's name.
|
||
const draft = (name: string) => [...Array.from({ length: 200 }, (_, index) => `item ${index + 1}`), name].join("\n")
|
||
const file = { content: draft("first draft") }
|
||
|
||
const messages = [
|
||
{ id: "msg_prompt", type: "user", text: "Write the shopping list", time: { created: 1 } },
|
||
{
|
||
id: "msg_reply",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [{ type: "text", text: "Updated [shopping.txt](shopping.txt)." }],
|
||
time: { created: 2, completed: 3 },
|
||
},
|
||
] satisfies SessionMessageInfo[]
|
||
|
||
await openSession(page, {
|
||
name: "ArtifactReopen",
|
||
fileList: () => [],
|
||
fileContent: (path) => (path === "shopping.txt" ? file : ""),
|
||
pageMessages: () => ({ items: messages }),
|
||
})
|
||
|
||
const link = page.getByRole("link", { name: "shopping.txt", exact: true })
|
||
const panel = page.locator("#review-panel")
|
||
const tab = panel.getByRole("tab", { name: "shopping.txt" })
|
||
const code = panel.locator("[data-scrollable]", { has: page.locator('[data-component="file"]') })
|
||
|
||
// A long file mounts only the rows near the viewport, so its last line needs a scroll. A reopened tab may restore its
|
||
// earlier scroll position, so this starts from wherever the view is once its rows overflow.
|
||
const scrollToEnd = async () => {
|
||
await expect.poll(() => code.evaluate((element) => element.scrollHeight - element.clientHeight)).toBeGreaterThan(0)
|
||
await code.hover()
|
||
await page.mouse.wheel(0, 100_000)
|
||
await expect
|
||
.poll(() => code.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
|
||
.toBeLessThanOrEqual(1)
|
||
}
|
||
|
||
await link.click()
|
||
await expect(tab).toHaveAttribute("aria-selected", "true")
|
||
// The first open starts at the top.
|
||
await expect(panel.getByText("item 1", { exact: true })).toBeVisible()
|
||
await scrollToEnd()
|
||
await expect(panel.getByText("first draft", { exact: true })).toBeVisible()
|
||
|
||
// Rereading the open file updates it in place: the code view keeps its node and never jumps back to the top.
|
||
const scrolled = await code.evaluate((element) => element.scrollTop)
|
||
expect(scrolled).toBeGreaterThan(0)
|
||
await code.evaluate((element) => void (element.dataset.e2eProbe = "original"))
|
||
file.content = draft("second draft")
|
||
await link.click()
|
||
await expect(panel.getByText("second draft", { exact: true })).toBeVisible()
|
||
expect(await code.evaluate((element) => element.dataset.e2eProbe)).toBe("original")
|
||
expect(await code.evaluate((element) => element.scrollTop)).toBe(scrolled)
|
||
|
||
file.content = draft("third draft")
|
||
await tab.locator("..").getByRole("button", { name: "Close tab" }).click()
|
||
await expect(tab).toHaveCount(0)
|
||
await link.click()
|
||
await expect(tab).toHaveAttribute("aria-selected", "true")
|
||
await scrollToEnd()
|
||
await expect(panel.getByText("third draft", { exact: true })).toBeVisible()
|
||
await expect(panel.getByText("second draft", { exact: true })).toHaveCount(0)
|
||
|
||
// A restored file tab whose file was deleted shows its inline not-found state without a toast; clicking a broken link
|
||
// when no tab is open for it shows one toast.
|
||
await page.route("**/api/fs/read/shopping.txt*", (route) =>
|
||
route.fulfill({
|
||
status: 404,
|
||
headers: { "access-control-allow-origin": "*" },
|
||
// SAFETY: the server's wire body for a missing file, which the client decodes into its own error.
|
||
// oxlint-disable-next-line anti-slop-effect/no-manual-tagged-construction -- see SAFETY above
|
||
json: { _tag: "FileNotFoundError", path: "shopping.txt", message: "File not found: shopping.txt" },
|
||
}),
|
||
)
|
||
await page.reload()
|
||
const missingTab = panel.getByRole("tab", { name: "File not found: shopping.txt", exact: true })
|
||
await expect(missingTab).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("File not found: shopping.txt", { exact: true })).toBeVisible()
|
||
await expect(page.getByText("Failed to load file", { exact: true })).toHaveCount(0)
|
||
|
||
// Behind another tab, the deleted file's tab is what its link selects: the click never does nothing.
|
||
await page.getByRole("button", { name: "Toggle session context" }).click()
|
||
await expect(missingTab).toHaveAttribute("aria-selected", "false")
|
||
await link.click()
|
||
await expect(missingTab).toHaveAttribute("aria-selected", "true")
|
||
await expect(page.getByText("Failed to load file", { exact: true })).toHaveCount(0)
|
||
|
||
await missingTab.locator("..").getByRole("button", { name: "Close tab" }).click()
|
||
await expect(missingTab).toHaveCount(0)
|
||
await link.click()
|
||
await expect(page.getByText("Failed to load file", { exact: true })).toBeVisible()
|
||
await expect(missingTab).toHaveCount(0)
|
||
})
|
||
|
||
// A change reported while a file's read is in flight used to join that read, so the tab kept the bytes from before the
|
||
// change until the next change.
|
||
test("a file changed during its read shows the change", async ({ page }) => {
|
||
const reads: string[] = []
|
||
const arrived = Promise.withResolvers<void>()
|
||
const held = Promise.withResolvers<void>()
|
||
|
||
const messages = [
|
||
{ id: "msg_prompt", type: "user", text: "Update the lists", time: { created: 1 } },
|
||
{
|
||
id: "msg_reply",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [{ type: "text", text: "Updated [notes.txt](notes.txt) and [shopping.txt](shopping.txt)." }],
|
||
time: { created: 2, completed: 3 },
|
||
},
|
||
] satisfies SessionMessageInfo[]
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "FileReadRace",
|
||
fileList: () => [],
|
||
fileContent: async (path) => {
|
||
reads.push(path)
|
||
|
||
if (path !== "shopping.txt") return `contents:${path}`
|
||
|
||
if (reads.filter((item) => item === path).length > 1) return "after change"
|
||
arrived.resolve()
|
||
await held.promise
|
||
|
||
return "before change"
|
||
},
|
||
pageMessages: () => ({ items: messages }),
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
await page.getByRole("link", { name: "notes.txt", exact: true }).click()
|
||
await expect(panel.getByText("contents:notes.txt", { exact: true })).toBeVisible()
|
||
|
||
await page.getByRole("link", { name: "shopping.txt", exact: true }).click()
|
||
await arrived.promise
|
||
// Events arrive in order, so the reread of notes.txt shows that the change to shopping.txt was handled before it.
|
||
await workspace.push([
|
||
filesystemEvent(workspace.directory, "shopping.txt", "change"),
|
||
filesystemEvent(workspace.directory, "notes.txt", "change"),
|
||
])
|
||
await expect.poll(() => reads.filter((item) => item === "notes.txt").length).toBe(2)
|
||
held.resolve()
|
||
|
||
await expect(panel.getByRole("tab", { name: "shopping.txt" })).toHaveAttribute("aria-selected", "true")
|
||
await expect(panel.getByText("after change", { exact: true })).toBeVisible()
|
||
await expect(panel.getByText("before change", { exact: true })).toHaveCount(0)
|
||
})
|
||
|
||
test("artifact actions copy and download content, switch source, and follow the selected file's capabilities", async ({
|
||
page,
|
||
context,
|
||
}) => {
|
||
await context.grantPermissions(["clipboard-read", "clipboard-write"])
|
||
const source = '<svg xmlns="http://www.w3.org/2000/svg" width="120" height="80"><rect width="120" height="80"/></svg>'
|
||
const table = 'name,role\n"Jensen, Oliver",Researcher\nIsabella,Support'
|
||
const broken = '<svg xmlns="http://www.w3.org/2000/svg"><rect'
|
||
|
||
const notes = [
|
||
"---",
|
||
"description: Release checklist",
|
||
"mode: primary",
|
||
"model: opencode/test",
|
||
"temperature: 0.2",
|
||
"steps: 12",
|
||
"color: accent",
|
||
"hidden: false",
|
||
'title: "Release"',
|
||
"tools:",
|
||
" write: false",
|
||
"---",
|
||
"",
|
||
"# Notes",
|
||
"",
|
||
"A document with a visible top edge.",
|
||
"",
|
||
"---",
|
||
"",
|
||
"Trailing section.",
|
||
].join("\n")
|
||
|
||
const workspace = await openSession(page, {
|
||
name: "ArtifactActions",
|
||
fileList: () => [],
|
||
fileContent: (path) => {
|
||
if (path === "vector.svg") return { content: source }
|
||
|
||
if (path === "data.csv") return { content: table }
|
||
|
||
if (path === "notes.md") return { content: notes }
|
||
|
||
if (path === "broken.svg") return { content: broken }
|
||
|
||
return { type: "binary", content: "AAEC", encoding: "base64" }
|
||
},
|
||
pageMessages: () => ({
|
||
items: [
|
||
{
|
||
id: "msg_artifact_actions",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [
|
||
{
|
||
type: "text",
|
||
text: "---\ndescription: Chat heading\n---\n\n[Vector](vector.svg) [Table](data.csv) [Notes](notes.md) [Binary](sample.bin) [Broken](broken.svg)",
|
||
},
|
||
],
|
||
time: { created: 1, completed: 2 },
|
||
},
|
||
],
|
||
}),
|
||
})
|
||
|
||
await page.getByRole("link", { name: "Vector", exact: true }).click()
|
||
const panel = page.locator("#review-panel")
|
||
const toolbar = panel.locator('[data-slot="artifact-toolbar"]:visible')
|
||
const actions = toolbar.getByRole("button", { name: "File actions", exact: true })
|
||
const image = panel.getByRole("img", { name: "vector.svg", exact: true })
|
||
await expect(image).toHaveJSProperty("naturalWidth", 120)
|
||
await expect(toolbar.getByText("vector.svg", { exact: true })).toBeVisible()
|
||
await panel.getByRole("button", { name: "Toggle file tree", exact: true }).click()
|
||
|
||
// The source action stays visible at rest; only metadata needs hover or keyboard focus.
|
||
await page.mouse.move(0, 0)
|
||
const sourceAction = toolbar.getByRole("button", { name: "View source", exact: true })
|
||
await expect(sourceAction).toHaveCSS("opacity", "1")
|
||
await expect(toolbar.locator('[data-slot="artifact-metadata"]')).toHaveCSS("opacity", "0")
|
||
await actions.focus()
|
||
await expect(toolbar.locator('[data-slot="artifact-metadata"]')).toHaveCSS("opacity", "1")
|
||
await expect(toolbar.getByText("120 × 80", { exact: true })).toBeVisible()
|
||
const copy = toolbar.getByRole("button", { name: "Copy content", exact: true })
|
||
await copy.click()
|
||
await expect(page.getByText("Copied", { exact: true })).toBeVisible()
|
||
await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe(source)
|
||
await page.getByRole("button", { name: "Dismiss", exact: true }).click()
|
||
|
||
await sourceAction.click()
|
||
await expect(image).toHaveCount(0)
|
||
await expect(panel.locator("diffs-container")).toContainText(source)
|
||
await actions.click()
|
||
await expect(page.getByRole("menuitem", { name: "View preview", exact: true })).toBeVisible()
|
||
await expect(page.getByRole("menuitem", { name: "Open in", exact: true })).toHaveCount(0)
|
||
await page.getByRole("menuitem", { name: "View preview", exact: true }).click()
|
||
await expect(image).toHaveJSProperty("naturalWidth", 120)
|
||
|
||
await page.getByRole("link", { name: "Table", exact: true }).click()
|
||
await expect(panel.getByRole("columnheader", { name: /^name(?:\s|$)/ })).toHaveCSS(
|
||
"background-color",
|
||
"rgb(242, 242, 242)",
|
||
)
|
||
const nameCell = panel.getByRole("cell", { name: /^Jensen, Oliver(?:\s|$)/ })
|
||
await expect(nameCell).toBeVisible()
|
||
await expect(toolbar.getByText("data.csv", { exact: true })).toBeVisible()
|
||
await nameCell.hover()
|
||
await nameCell.getByRole("button", { name: "Copy cell", exact: true }).click()
|
||
await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe("Jensen, Oliver")
|
||
await toolbar.hover()
|
||
await expect(nameCell.getByRole("button", { name: "Copy cell", exact: true })).toHaveCSS("opacity", "0")
|
||
await page.keyboard.press("Tab")
|
||
|
||
const nextCopy = panel
|
||
.getByRole("cell", { name: /^Researcher(?:\s|$)/ })
|
||
.getByRole("button", { name: "Copy cell", exact: true })
|
||
|
||
await expect(nextCopy).toBeFocused()
|
||
await expect(nextCopy).toHaveCSS("opacity", "1")
|
||
|
||
const copyHeader = panel
|
||
.getByRole("columnheader", { name: /^role(?:\s|$)/ })
|
||
.getByRole("button", { name: "Copy cell", exact: true })
|
||
|
||
await copyHeader.focus()
|
||
await copyHeader.press("Enter")
|
||
await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe("role")
|
||
await actions.click()
|
||
const downloaded = page.waitForEvent("download")
|
||
await page.getByRole("menuitem", { name: "Download", exact: true }).click()
|
||
const download = await downloaded
|
||
expect(download.suggestedFilename()).toBe("data.csv")
|
||
expect(await readFile((await download.path())!, "utf8")).toBe(table)
|
||
|
||
await expect(page.getByRole("heading", { name: "description: Chat heading", exact: true })).toBeVisible()
|
||
await page.getByRole("link", { name: "Notes", exact: true }).click()
|
||
await expect(panel.getByRole("heading", { name: "Notes", exact: true })).toBeVisible()
|
||
const paper = panel.locator('[data-slot="artifact-markdown-page"]')
|
||
await expect(paper.getByRole("heading")).toHaveText(["Notes"])
|
||
await expect(paper.locator("code.language-yaml")).toHaveCount(0)
|
||
await expect(paper.locator("hr")).toHaveCount(1)
|
||
const terms = paper.getByRole("term")
|
||
await expect(terms).toHaveText(["description", "mode", "model", "temperature", "steps", "color"])
|
||
await paper.getByRole("button", { name: "Show all 9 properties", exact: true }).click()
|
||
await expect(terms).toHaveText([
|
||
"description",
|
||
"mode",
|
||
"model",
|
||
"temperature",
|
||
"steps",
|
||
"color",
|
||
"hidden",
|
||
"title",
|
||
"tools",
|
||
])
|
||
await expect(paper.getByRole("definition")).toHaveText([
|
||
"Release checklist",
|
||
"primary",
|
||
"opencode/test",
|
||
"0.2",
|
||
"12",
|
||
"accent",
|
||
"false",
|
||
"Release",
|
||
"write: false",
|
||
])
|
||
await expect(paper).toHaveCSS("border-radius", "8px")
|
||
await expect(paper).toHaveAttribute("data-component", "document-surface")
|
||
expect(await paper.evaluate((element) => getComputedStyle(element, "::after").borderTopStyle)).toBe("solid")
|
||
const surface = (await paper.boundingBox())!
|
||
const bar = (await toolbar.boundingBox())!
|
||
expect(surface.y - bar.y - bar.height).toBe(1)
|
||
await expect(panel.getByRole("group", { name: "Preview controls", exact: true })).toHaveCount(0)
|
||
await copy.click()
|
||
// Chromium writes CRLF to the Windows clipboard.
|
||
await expect
|
||
.poll(() => page.evaluate(() => navigator.clipboard.readText()).then((text) => text.replace(/\r\n/g, "\n")))
|
||
.toBe(notes)
|
||
await page.getByRole("button", { name: "Dismiss", exact: true }).click()
|
||
await sourceAction.click()
|
||
await expect(paper).toHaveCount(0)
|
||
await expect(panel.locator('diffs-container [data-line="1"]')).toHaveText("---")
|
||
await expect(panel.locator('diffs-container [data-line="2"]')).toContainText("description: Release checklist")
|
||
|
||
await page.getByRole("link", { name: "Binary", exact: true }).click()
|
||
await expect(panel.getByText(/Binary file/)).toBeVisible()
|
||
await expect(toolbar.getByText("sample.bin", { exact: true })).toBeVisible()
|
||
await expect(copy).toHaveCount(0)
|
||
await expect(toolbar.getByRole("button", { name: "View source", exact: true })).toHaveCount(0)
|
||
await actions.click()
|
||
await expect(page.getByRole("menuitem", { name: "Download", exact: true })).toHaveCount(0)
|
||
await page.getByRole("menuitem", { name: "Copy path", exact: true }).click()
|
||
await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe(`${workspace.directory}/sample.bin`)
|
||
|
||
// A text SVG that fails to decode shows the binary placeholder but can still show its source.
|
||
await page.getByRole("link", { name: "Broken", exact: true }).click()
|
||
await expect(toolbar.getByText("broken.svg", { exact: true })).toBeVisible()
|
||
await expect(panel.getByText("Couldn't load this file.", { exact: true })).toBeVisible()
|
||
await toolbar.getByRole("button", { name: "View source", exact: true }).click()
|
||
await expect(panel.locator("diffs-container")).toContainText(broken)
|
||
})
|
||
|
||
test("Markdown and DOCX sheets stay aligned when switching at wide and narrow preview widths", async ({ page }) => {
|
||
// Minimal DOCX containing one paragraph, "Document spacing", and a letter-sized page.
|
||
const docx =
|
||
"UEsDBBQAAAAIAI51W13mdcR+0gAAAIsBAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbH2QvVLDMAzHX8XnlasVGBh6SToAKzD0BXSOkvjw11luad++Sls6cIVR+n/8ZLebQ/BqT4Vdip1+NI3e9O32mImVKJE7Pdea1wBsZwrIJmWKooypBKwylgky2i+cCJ6a5hlsipViXdWlQ/ftK42481W9HWR9oRTyrNXLxbiwOo05e2exig77OPyirK4EI8mzh2eX+UEMGu4SFuVvwDX3Ic8ubiD1iaW+YxAXfKcywJDsLkjS/F9z5840js7SLb+05ZIsMbs4BW9uSkAXf+6H83f3J1BLAwQUAAAACACOdVtdXzOVUpUAAAAHAQAACwAAAF9yZWxzLy5yZWxzjc87DsIwDAbgq0Q+QJ0yMKCmXVi6Ii4QJW5T0TzkhNftycBAEQOjf//6LHfDw6/iRpyXGBS0jYSh70606lKD7JaURW2ErMCVkg6I2TjyOjcxUaibKbLXpY48Y9LmomfCnZR75E8DtqYYrQIebQvi/Ez0jx2naTF0jObqKZQfJ74aVdY8U1Fwj2zRvuOmsoB9h5sX+xdQSwMEFAAAAAgAjnVbXUye0X++AAAAMQEAABEAAAB3b3JkL2RvY3VtZW50LnhtbEVQ0Q6CMAz8FbIPsEjUGILw4quJiV8wxwQSti5dFfXr7TCEl9v1ru01q5q3G7OXpTigP6ntJldNXU1li+bprOdMbB/L6aR65lACRNNbp+MGg/XiPZCcZimpgwmpDYTGxjj4zo1Q5PkBnB68Sivv2H7SGxJQAq7PS0wM2shQBUlNSDPOvdEavs4Dobt9syldsy2KXa6E98L3R+Hwb7hoEpUxiL77t9DQ9byWd2RGt9ajfSwuzKFLHiw3w/of9Q9QSwECFAMUAAAACACOdVtd5nXEftIAAACLAQAAEwAAAAAAAAAAAAAAgAEAAAAAW0NvbnRlbnRfVHlwZXNdLnhtbFBLAQIUAxQAAAAIAI51W11fM5VSlQAAAAcBAAALAAAAAAAAAAAAAACAAQMBAABfcmVscy8ucmVsc1BLAQIUAxQAAAAIAI51W11MntF/vgAAADEBAAARAAAAAAAAAAAAAACAAcEBAAB3b3JkL2RvY3VtZW50LnhtbFBLBQYAAAAAAwADALkAAACuAgAAAAA="
|
||
|
||
await page.setViewportSize({ width: 1728, height: 900 })
|
||
await openSession(page, {
|
||
name: "DocumentAlignment",
|
||
fileList: () => [],
|
||
fileContent: (path) =>
|
||
path === "notes.md"
|
||
? { type: "text", content: "# Document spacing\n\nA Markdown sheet beside an Office document." }
|
||
: {
|
||
type: "binary",
|
||
content: docx,
|
||
encoding: "base64",
|
||
mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
||
},
|
||
pageMessages: () => ({
|
||
items: [
|
||
{
|
||
id: "msg_document_alignment",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [{ type: "text", text: "[Markdown](notes.md) [Word](sample.docx) [Second Word](other.docx)" }],
|
||
time: { created: 1, completed: 2 },
|
||
},
|
||
],
|
||
}),
|
||
seed: { storage: { "opencode.global.dat:review-panel-v2": { sidebarOpened: false } } },
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
const toolbar = panel.locator('[data-slot="artifact-toolbar"]:visible')
|
||
const markdown = panel.locator('[data-slot="artifact-markdown-page"]')
|
||
const word = panel.getByRole("group", { name: "Page 1", exact: true })
|
||
|
||
const edges = (sheet: Locator) =>
|
||
sheet.evaluate((element) => {
|
||
const rect = element.getBoundingClientRect()
|
||
const scrollport = element.closest("[data-document-surface-scrollport]")!
|
||
|
||
return { left: rect.left, right: rect.right, inset: rect.left - scrollport.getBoundingClientRect().left }
|
||
})
|
||
|
||
await page.getByRole("link", { name: "Markdown", exact: true }).click()
|
||
await page.getByRole("link", { name: "Word", exact: true }).click()
|
||
await expect(toolbar.getByText("sample.docx", { exact: true })).toBeVisible()
|
||
// The real Office engine may need a cold WASM initialization before its text layer is ready.
|
||
await expect(word.getByText("Document spacing", { exact: true })).toBeVisible({ timeout: 30_000 })
|
||
await word.evaluate((element) => {
|
||
element.dataset.e2eProbe = "warm"
|
||
})
|
||
const canvas = await word.locator("canvas").elementHandle()
|
||
expect(canvas).not.toBeNull()
|
||
await expect.poll(() => canvas!.evaluate((element) => Number(element.getAttribute("width")))).toBeGreaterThan(0)
|
||
await page.getByRole("link", { name: "Second Word", exact: true }).click()
|
||
await expect(toolbar.getByText("other.docx", { exact: true })).toBeVisible()
|
||
await expect(word.getByText("Document spacing", { exact: true })).toBeVisible({ timeout: 30_000 })
|
||
await word.evaluate((element) => {
|
||
element.dataset.e2eProbe = "other-warm"
|
||
})
|
||
|
||
for (const size of [
|
||
{ width: 1728, gutter: 20 },
|
||
{ width: 1000, gutter: 12 },
|
||
]) {
|
||
await page.setViewportSize({ width: size.width, height: 900 })
|
||
await panel.getByRole("tab", { name: "notes.md", exact: true }).click()
|
||
await expect(markdown.getByRole("heading", { name: "Document spacing", exact: true })).toBeVisible()
|
||
await toolbar.hover()
|
||
await expect.poll(async () => (await edges(markdown)).inset).toBeCloseTo(size.gutter, 1)
|
||
const reference = await edges(markdown)
|
||
const header = await toolbar.boundingBox()
|
||
|
||
await panel.getByRole("tab", { name: "sample.docx", exact: true }).click()
|
||
await expect(word).toHaveAttribute("data-e2e-probe", "warm")
|
||
await expect(word.getByText("Document spacing", { exact: true })).toBeVisible()
|
||
await expect
|
||
.poll(() => edges(word))
|
||
.toEqual({
|
||
left: expect.closeTo(reference.left, 1),
|
||
right: expect.closeTo(reference.right, 1),
|
||
inset: expect.closeTo(size.gutter, 1),
|
||
})
|
||
await expect.poll(() => toolbar.boundingBox()).toEqual(header)
|
||
|
||
await panel.getByRole("tab", { name: "notes.md", exact: true }).click()
|
||
await expect(markdown.getByRole("heading", { name: "Document spacing", exact: true })).toBeVisible()
|
||
await expect.poll(() => edges(markdown)).toEqual(reference)
|
||
await expect.poll(() => toolbar.boundingBox()).toEqual(header)
|
||
expect(await canvas!.evaluate((element) => element.isConnected && Number(element.getAttribute("width")) > 0)).toBe(
|
||
true,
|
||
)
|
||
await panel.getByRole("tab", { name: "other.docx", exact: true }).click()
|
||
await expect(word).toHaveAttribute("data-e2e-probe", "other-warm")
|
||
await panel.getByRole("tab", { name: "notes.md", exact: true }).click()
|
||
}
|
||
|
||
await panel
|
||
.getByRole("tab", { name: "sample.docx", exact: true })
|
||
.locator("..")
|
||
.getByRole("button", { name: "Close tab", exact: true })
|
||
.click()
|
||
await expect.poll(() => canvas!.evaluate((element) => element.isConnected)).toBe(false)
|
||
})
|
||
|
||
test("diagram preview controls zoom the rendered diagram and fit it back into its pane", async ({ page }) => {
|
||
await openSession(page, {
|
||
name: "DiagramZoom",
|
||
fileList: () => [],
|
||
fileContent: () => ({ content: "flowchart LR\n Start[Start] --> Review[Review] --> Finish[Finish]" }),
|
||
pageMessages: () => ({
|
||
items: [
|
||
{
|
||
id: "msg_diagram_zoom",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [{ type: "text", text: "[Diagram](flow.mmd)" }],
|
||
time: { created: 1, completed: 2 },
|
||
},
|
||
],
|
||
}),
|
||
})
|
||
await page.getByRole("link", { name: "Diagram", exact: true }).click()
|
||
const panel = page.locator("#review-panel")
|
||
const diagram = panel.locator('[data-component="markdown-mermaid"] > svg')
|
||
const controls = panel.getByRole("group", { name: "Preview controls", exact: true })
|
||
const fit = controls.getByRole("button", { name: "Fit", exact: true })
|
||
await expect(panel.getByText("Finish", { exact: true })).toBeVisible()
|
||
await diagram.hover()
|
||
const initial = (await diagram.boundingBox())!
|
||
|
||
await expect(fit).toBeEnabled()
|
||
await controls.getByRole("button", { name: "Zoom in", exact: true }).click()
|
||
await expect.poll(async () => (await diagram.boundingBox())!.width).toBeCloseTo(initial.width * 1.25, 1)
|
||
await controls.getByRole("button", { name: "Zoom out", exact: true }).click()
|
||
await expect.poll(async () => (await diagram.boundingBox())!.width).toBeCloseTo(initial.width, 1)
|
||
await controls.getByRole("button", { name: "Zoom out", exact: true }).click()
|
||
await expect.poll(async () => (await diagram.boundingBox())!.width).toBeCloseTo(initial.width / 1.25, 1)
|
||
await fit.click()
|
||
await expect.poll(() => diagram.boundingBox()).toEqual(initial)
|
||
})
|
||
|
||
/** What the image case's frame probe records on the window. */
|
||
type ImageProbe = { problems: string[]; frames: number; running: boolean }
|
||
|
||
test("image gestures anchor zoom, pan, and reset independently of the pane", async ({ page }) => {
|
||
// Some browsers expose no natural dimensions for a viewBox-only SVG.
|
||
await page.addInitScript(() => {
|
||
for (const name of ["naturalWidth", "naturalHeight"]) {
|
||
const original = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, name)!
|
||
Object.defineProperty(HTMLImageElement.prototype, name, {
|
||
...original,
|
||
get() {
|
||
return this.alt === "second.svg" ? 0 : original.get?.call(this)
|
||
},
|
||
})
|
||
}
|
||
})
|
||
await openSession(page, {
|
||
name: "ImageGestures",
|
||
fileList: () => [],
|
||
fileContent: (path) => {
|
||
if (path === "small.svg")
|
||
return {
|
||
content:
|
||
'<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32"><rect width="32" height="32" fill="#6699aa"/></svg>',
|
||
}
|
||
|
||
return {
|
||
content:
|
||
path === "second.svg"
|
||
? '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1600 1600"><rect width="1600" height="1600" fill="#6699aa"/></svg>'
|
||
: '<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="1600"><rect width="1600" height="1600" fill="#6699aa"/></svg>',
|
||
}
|
||
},
|
||
pageMessages: () => ({
|
||
items: [
|
||
{
|
||
id: "msg_images",
|
||
type: "assistant",
|
||
agent: "build",
|
||
model: { id: "test", providerID: "opencode" },
|
||
content: [{ type: "text", text: "[First](first.svg) [Second](second.svg) [Small](small.svg)" }],
|
||
time: { created: 1, completed: 2 },
|
||
},
|
||
],
|
||
}),
|
||
})
|
||
await page.getByRole("link", { name: "First", exact: true }).click()
|
||
const panel = page.locator("#review-panel")
|
||
const image = panel.getByRole("img", { name: "first.svg", exact: true })
|
||
const stage = panel.locator('[data-slot="artifact-stage"]')
|
||
const fit = panel.getByRole("button", { name: "Fit", exact: true })
|
||
await expect(image).toBeVisible()
|
||
await expect(fit).toBeEnabled()
|
||
// Wait for the side pane's opening motion before choosing a gesture anchor.
|
||
await image.hover()
|
||
const initial = (await image.boundingBox())!
|
||
const pane = (await panel.boundingBox())!
|
||
await panel.getByRole("button", { name: "Zoom in", exact: true }).click()
|
||
await expect.poll(async () => (await image.boundingBox())!.width).toBeCloseTo(initial.width * 1.25, 1)
|
||
await panel.getByRole("button", { name: "Zoom out", exact: true }).click()
|
||
await expect.poll(() => image.boundingBox()).toEqual(initial)
|
||
const anchor = { x: Math.round(initial.x + initial.width * 0.55), y: Math.round(initial.y + initial.height * 0.55) }
|
||
await page.mouse.move(anchor.x, anchor.y)
|
||
// A continuous pinch catches anchor drift while the image still fits one axis.
|
||
const cdp = await page.context().newCDPSession(page)
|
||
await cdp.send("Input.synthesizePinchGesture", {
|
||
...anchor,
|
||
scaleFactor: 2,
|
||
relativeSpeed: 500,
|
||
gestureSourceType: "mouse",
|
||
})
|
||
await cdp.detach()
|
||
await expect(stage).toHaveAttribute("data-zoom", "actual")
|
||
const zoomed = (await image.boundingBox())!
|
||
expect(zoomed.width).toBeCloseTo(initial.width * 2, 1)
|
||
expect((anchor.x - zoomed.x) / zoomed.width).toBeCloseTo((anchor.x - initial.x) / initial.width, 4)
|
||
expect((anchor.y - zoomed.y) / zoomed.height).toBeCloseTo((anchor.y - initial.y) / initial.height, 4)
|
||
expect(await panel.boundingBox()).toEqual(pane)
|
||
expect(await page.evaluate(() => window.visualViewport?.scale)).toBe(1)
|
||
await page.mouse.wheel(40, 60)
|
||
await expect.poll(async () => (await image.boundingBox())!.x).toBeCloseTo(zoomed.x - 40, 1)
|
||
expect((await image.boundingBox())!.y).toBeCloseTo(zoomed.y - 60, 1)
|
||
const scrolled = (await image.boundingBox())!
|
||
await page.mouse.down()
|
||
await page.mouse.move(anchor.x + 60, anchor.y + 40, { steps: 5 })
|
||
await page.mouse.up()
|
||
await expect(stage).toHaveAttribute("data-zoom", "actual")
|
||
expect((await image.boundingBox())!.x).toBeCloseTo(scrolled.x + 60, 1)
|
||
expect((await image.boundingBox())!.y).toBeCloseTo(scrolled.y + 40, 1)
|
||
// Touch uses the same captured-pointer path and must not generate a click-to-fit.
|
||
const touch = await page.context().newCDPSession(page)
|
||
await touch.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x: anchor.x, y: anchor.y }] })
|
||
await touch.send("Input.dispatchTouchEvent", {
|
||
type: "touchMove",
|
||
touchPoints: [{ x: anchor.x - 30, y: anchor.y - 20 }],
|
||
})
|
||
await touch.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] })
|
||
await touch.detach()
|
||
await expect(stage).toHaveAttribute("data-zoom", "actual")
|
||
expect((await image.boundingBox())!.x).toBeCloseTo(scrolled.x + 30, 1)
|
||
expect((await image.boundingBox())!.y).toBeCloseTo(scrolled.y + 20, 1)
|
||
// A pan whose release the image never heard ends on the next move without the button, and pans nothing.
|
||
const touched = (await image.boundingBox())!
|
||
await page.mouse.down()
|
||
await expect(image).toHaveCSS("cursor", "grabbing")
|
||
await image.evaluate(
|
||
(element, point) =>
|
||
element.dispatchEvent(
|
||
new PointerEvent("pointermove", {
|
||
bubbles: true,
|
||
pointerId: 1,
|
||
pointerType: "mouse",
|
||
isPrimary: true,
|
||
buttons: 0,
|
||
clientX: point.x,
|
||
clientY: point.y,
|
||
}),
|
||
),
|
||
{ x: anchor.x - 100, y: anchor.y - 100 },
|
||
)
|
||
await expect(image).toHaveCSS("cursor", "grab")
|
||
expect(await image.boundingBox()).toEqual(touched)
|
||
await page.mouse.up()
|
||
// Keyboard-accessible fit restores the exact original geometry.
|
||
await fit.focus()
|
||
await page.keyboard.press("Enter")
|
||
await expect(stage).toHaveAttribute("data-zoom", "fit")
|
||
expect(await image.boundingBox()).toEqual(initial)
|
||
expect(
|
||
await stage.evaluate((element) =>
|
||
element.dispatchEvent(new WheelEvent("wheel", { deltaY: 40, bubbles: true, cancelable: true })),
|
||
),
|
||
).toBe(true)
|
||
await image.click()
|
||
await expect(stage).toHaveAttribute("data-zoom", "actual")
|
||
await page.getByRole("link", { name: "Second", exact: true }).click()
|
||
await expect(panel.getByRole("img", { name: "second.svg", exact: true })).toBeVisible()
|
||
await expect(stage).toHaveAttribute("data-zoom", "fit")
|
||
await panel.getByRole("img", { name: "second.svg", exact: true }).hover()
|
||
const second = (await panel.getByRole("img", { name: "second.svg", exact: true }).boundingBox())!
|
||
expect(second.width).toBeGreaterThan(0)
|
||
expect(second.height).toBeGreaterThan(0)
|
||
await page.keyboard.down("Control")
|
||
await page.mouse.wheel(0, -50)
|
||
await expect(stage).toHaveAttribute("data-zoom", "actual")
|
||
await page.keyboard.up("Control")
|
||
await fit.click()
|
||
await page.setViewportSize({ width: 1200, height: 700 })
|
||
await expect
|
||
.poll(async () => {
|
||
const frame = (await stage.boundingBox())!
|
||
const media = (await panel.getByRole("img", { name: "second.svg", exact: true }).boundingBox())!
|
||
|
||
return media.width <= frame.width - 47 && media.height <= frame.height - 47
|
||
})
|
||
.toBe(true)
|
||
await page.getByRole("link", { name: "Small", exact: true }).click()
|
||
const small = panel.getByRole("img", { name: "small.svg", exact: true })
|
||
await expect(small).toHaveJSProperty("naturalWidth", 32)
|
||
await small.click()
|
||
await expect.poll(async () => (await small.boundingBox())!.width).toBeCloseTo(32, 1)
|
||
await expect(panel.getByRole("button", { name: "Zoom out", exact: true })).toBeDisabled()
|
||
await fit.click()
|
||
await expect.poll(async () => (await small.boundingBox())!.width).toBeGreaterThan(128)
|
||
})
|
||
|
||
test("image files load into the review panel and keep it painted while loading", async ({ page }) => {
|
||
await page.setViewportSize({ width: 960, height: 900 })
|
||
const directory = "C:/OpenCode/ReviewImage"
|
||
const image = "assets/preview.png"
|
||
const read = Promise.withResolvers<void>()
|
||
const release = Promise.withResolvers<void>()
|
||
await openSession(page, {
|
||
name: "ReviewImage",
|
||
vcsDiff: [fileDiff("src/example.ts"), { file: image, patch: "", additions: 1, deletions: 0, status: "added" }],
|
||
fileContent: async (path) => {
|
||
if (path !== image) return undefined
|
||
read.resolve()
|
||
await release.promise
|
||
|
||
// A 1x1 PNG.
|
||
return {
|
||
type: "binary",
|
||
content: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=",
|
||
encoding: "base64",
|
||
mimeType: "image/png",
|
||
}
|
||
},
|
||
fileList: (path) => {
|
||
if (!path) return [fileNode(directory, "assets", "directory"), fileNode(directory, "src", "directory")]
|
||
|
||
if (path === "assets") return [fileNode(directory, image)]
|
||
|
||
if (path === "src") return [fileNode(directory, "src/example.ts")]
|
||
|
||
return []
|
||
},
|
||
})
|
||
await page.getByRole("button", { name: "Toggle review" }).click()
|
||
await openReviewLauncher(page.locator("#review-panel"))
|
||
await expect(page.locator('#review-panel [data-component="session-review-v2"]')).toBeVisible()
|
||
|
||
// Records every painted frame from before the click until after the image read completes.
|
||
await page.evaluate(() => {
|
||
const probe: ImageProbe = { problems: [], frames: 0, running: true }
|
||
|
||
const sample = () => {
|
||
const panel = document.querySelector<HTMLElement>('#review-panel [data-component="session-review-v2"]')
|
||
const rect = panel?.getBoundingClientRect()
|
||
|
||
const hit =
|
||
rect?.width && rect.height ? document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2) : null
|
||
|
||
const frame = [
|
||
!panel?.checkVisibility() && "hidden",
|
||
!panel?.textContent?.trim() && "blank",
|
||
!(hit && document.querySelector("#review-panel")?.contains(hit)) && "outside the review panel",
|
||
hit && getComputedStyle(hit).backgroundColor === "rgb(0, 0, 0)" && "black",
|
||
].filter((problem) => problem !== false && problem !== null)
|
||
|
||
probe.problems.push(...frame)
|
||
probe.frames += 1
|
||
|
||
if (probe.running) requestAnimationFrame(sample)
|
||
}
|
||
|
||
// The evaluates below read it.
|
||
Object.assign(window, { e2eImageProbe: probe })
|
||
requestAnimationFrame(sample)
|
||
})
|
||
|
||
const frames = () =>
|
||
// SAFETY: the evaluate above stored the probe on the window before any frame is counted.
|
||
page.evaluate(() => (window as Window & { e2eImageProbe?: ImageProbe }).e2eImageProbe!.frames)
|
||
|
||
const response = page.waitForResponse((item) => item.url().includes(`/api/fs/read/${image}`))
|
||
await page.getByRole("treeitem", { name: /preview\.png/ }).click()
|
||
await read.promise
|
||
const pending = await frames()
|
||
await expect.poll(frames).toBeGreaterThan(pending)
|
||
release.resolve()
|
||
await response
|
||
await expect(page.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("preview.png")
|
||
await expect(page.locator("#review-panel").getByRole("img", { name: image, exact: true })).toHaveJSProperty(
|
||
"naturalWidth",
|
||
1,
|
||
)
|
||
const loaded = await frames()
|
||
await expect.poll(frames).toBeGreaterThan(loaded)
|
||
expect(
|
||
await page.evaluate(() => {
|
||
// SAFETY: the evaluate above stored the probe on the window.
|
||
const probe = (window as Window & { e2eImageProbe?: ImageProbe }).e2eImageProbe!
|
||
probe.running = false
|
||
|
||
return probe.problems
|
||
}),
|
||
).toEqual([])
|
||
})
|
||
|
||
test("video files stream into the viewer behind a loading state, open into the preview, and come back on Escape without remounting", async ({
|
||
page,
|
||
}) => {
|
||
const directory = "C:/OpenCode/ReviewVideo"
|
||
const file = "arcade-update-draft.mp4"
|
||
|
||
const head = Buffer.from(
|
||
"AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAMm1kYXSCSYNCAAPwAjYAOCQcGEIAADBgAABYS///mpmB/////7FMC////+OkgAAAAAL+bW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAA+gAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAil0cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAA+gAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAEAAAAAkAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAAPoAAAAAAABAAAAAAGhbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAABAAAAAQABVxAAAAAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAABTG1pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAAAQxzdGJsAAAAqHN0c2QAAAAAAAAAAQAAAJh2cDA5AAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAEAAJABIAAAASAAAAAAAAAABF0xhdmM2My4xLjEwMiBsaWJ2cHgtdnA5AAAAAAAAAAAAGP//AAAAFHZwY0MBAAAAAAqCAgICAAAAAAAKZmllbAEAAAAAEHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAAJxAAAAAAAAAAGHN0dHMAAAAAAAAAAQAAAAEAAEAAAAAAHHN0c2MAAAAAAAAAAQAAAAEAAAABAAAAAQAAABRzdHN6AAAAAAAAACoAAAABAAAAFHN0Y28AAAAAAAAAAQAAACwAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYzLjEuMTAy",
|
||
"base64",
|
||
)
|
||
|
||
const mp4 = Buffer.alloc(38_400_000)
|
||
|
||
head.copy(mp4)
|
||
mp4.writeUInt32BE(mp4.length - head.length, head.length)
|
||
mp4.write("free", head.length + 4, "ascii")
|
||
|
||
await openSession(page, {
|
||
name: "ReviewVideo",
|
||
fileList: (path) => (path ? [] : [fileNode(directory, file)]),
|
||
seed: {
|
||
panes: { ses_reviewvideo: { review: true } },
|
||
},
|
||
})
|
||
// The app only checks the file with a HEAD; the video element streams it with range requests, held until released.
|
||
const ranged = Promise.withResolvers<void>()
|
||
const release = Promise.withResolvers<void>()
|
||
await page.route(`**/api/fs/read/${file}*`, async (route) => {
|
||
const headers = {
|
||
"access-control-allow-origin": "*",
|
||
"accept-ranges": "bytes",
|
||
"content-type": "video/mp4",
|
||
"content-disposition": `attachment; filename="${file}"`,
|
||
"content-security-policy": "default-src 'none'; img-src 'self'; media-src 'self'; sandbox",
|
||
"x-content-type-options": "nosniff",
|
||
}
|
||
|
||
if (route.request().method() === "HEAD")
|
||
return route.fulfill({ status: 200, headers: { ...headers, "content-length": String(mp4.length) } })
|
||
|
||
const range = /^bytes=(\d+)-(\d*)$/.exec((await route.request().headerValue("range")) ?? "")
|
||
|
||
if (!range) return route.fulfill({ status: 200, headers, body: mp4 })
|
||
ranged.resolve()
|
||
await release.promise
|
||
const start = Number(range[1])
|
||
const end = Math.min(range[2] ? Number(range[2]) : mp4.length - 1, start + 4_000_000, mp4.length - 1)
|
||
|
||
return route.fulfill({
|
||
status: 206,
|
||
headers: { ...headers, "content-range": `bytes ${start}-${end}/${mp4.length}` },
|
||
body: mp4.subarray(start, end + 1),
|
||
})
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
await openFileLauncher(panel)
|
||
await panel.getByRole("treeitem", { name: file }).click()
|
||
await expect(panel.getByRole("tab", { name: file, exact: true })).toHaveAttribute("aria-selected", "true")
|
||
|
||
const toolbar = panel.locator('[data-slot="artifact-toolbar"]')
|
||
const stage = panel.locator('[data-slot="artifact-stage"]')
|
||
const video = stage.locator('video[data-slot="artifact-media"]')
|
||
const fullscreen = stage.getByRole("button", { name: "Enter full screen", exact: true })
|
||
const preview = page.locator('[data-component="image-preview"]')
|
||
const loading = stage.getByRole("status", { name: "Loading", exact: true })
|
||
|
||
await ranged.promise
|
||
await expect(loading).toBeVisible()
|
||
expect(await video.getAttribute("src")).toMatch(new RegExp(`^${SERVER}/api/fs/read/${file}\\?`))
|
||
release.resolve()
|
||
await expect(loading).toHaveCount(0)
|
||
await expect(video).toBeVisible()
|
||
await expect(toolbar).toContainText("64 × 36")
|
||
await expect(toolbar).toContainText("0:01")
|
||
await expect(toolbar).toContainText("38.4 MB")
|
||
await expect(panel.getByText(/Binary file/)).toHaveCount(0)
|
||
const inlineBounds = (await stage.boundingBox())!
|
||
expect(inlineBounds.width).toBeLessThan(1000)
|
||
|
||
await video.evaluate((element) => {
|
||
element.dataset.e2eProbe = "retained"
|
||
})
|
||
|
||
// The preview borrows the same element, so playback never restarts.
|
||
await fullscreen.click()
|
||
await expect(preview).toHaveAttribute("data-stage", "rest")
|
||
await expect(preview.locator('video[data-e2e-probe="retained"]')).toBeVisible()
|
||
await expect(video).toHaveCount(0)
|
||
expect(await page.evaluate(() => document.fullscreenElement)).toBeNull()
|
||
|
||
await page.keyboard.press("Escape")
|
||
await expect(preview).toHaveCount(0)
|
||
await expect(video).toHaveAttribute("data-e2e-probe", "retained")
|
||
await expect.poll(() => stage.boundingBox()).toEqual(inlineBounds)
|
||
|
||
await video.dblclick()
|
||
await expect(preview).toHaveAttribute("data-stage", "rest")
|
||
await page.mouse.click(8, 8)
|
||
await expect(preview).toHaveCount(0)
|
||
await expect(video).toHaveAttribute("data-e2e-probe", "retained")
|
||
|
||
// Chromium's controls also answer a double click with native fullscreen, which covers the backdrop. Opting out with
|
||
// controlslist="nofullscreen" would end their click-to-play as well.
|
||
await video.click()
|
||
await expect.poll(() => video.evaluate((element: HTMLVideoElement) => element.currentTime)).toBeGreaterThan(0)
|
||
expect(await page.evaluate(() => document.fullscreenElement)).toBeNull()
|
||
})
|
||
|
||
test("review file navigation focuses the arrow for the keyboard direction", async ({ page }) => {
|
||
await openSession(page, {
|
||
name: "ReviewArrowFocus",
|
||
vcsDiff: [fileDiff("src/alpha.ts"), fileDiff("src/beta.ts"), fileDiff("src/gamma.ts")],
|
||
seed: {
|
||
panes: { ses_reviewarrowfocus: { review: true } },
|
||
storage: {
|
||
...reviewTabs("C:/OpenCode/ReviewArrowFocus", "ses_reviewarrowfocus"),
|
||
"opencode.global.dat:review-panel-v2": { sidebarOpened: false },
|
||
},
|
||
},
|
||
})
|
||
|
||
const panel = page.locator("#review-panel")
|
||
const file = panel.locator('[data-slot="session-review-v2-file-name"]')
|
||
const previous = panel.getByRole("button", { name: "Previous file", exact: true })
|
||
const next = panel.getByRole("button", { name: "Next file", exact: true })
|
||
|
||
await expect(file).toHaveText("alpha.ts")
|
||
await previous.click()
|
||
await expect(file).toHaveText("gamma.ts")
|
||
await page.keyboard.press("ArrowRight")
|
||
await expect(file).toHaveText("alpha.ts")
|
||
await expect(next).toBeFocused()
|
||
await page.keyboard.press("Enter")
|
||
await expect(file).toHaveText("beta.ts")
|
||
await page.keyboard.press("ArrowLeft")
|
||
await expect(file).toHaveText("alpha.ts")
|
||
await expect(previous).toBeFocused()
|
||
await next.click()
|
||
await expect(file).toHaveText("beta.ts")
|
||
await expect(next).toBeFocused()
|
||
|
||
const home = page.getByRole("button", { name: "Home", exact: true })
|
||
await home.focus()
|
||
await page.keyboard.press("ArrowRight")
|
||
await expect(file).toHaveText("gamma.ts")
|
||
await expect(home).toBeFocused()
|
||
await page.keyboard.press("ArrowLeft")
|
||
await expect(file).toHaveText("beta.ts")
|
||
await expect(home).toBeFocused()
|
||
})
|
||
|
||
test("restores review state and the side-panel tab per session", async ({ page }) => {
|
||
const sessions = [
|
||
{ id: "ses_review_state_a", title: "Alpha review state" },
|
||
{ id: "ses_review_state_b", title: "Beta review state" },
|
||
{ id: "ses_review_state_c", title: "Gamma review state" },
|
||
]
|
||
|
||
const directory = "C:/OpenCode/ReviewState"
|
||
await openSession(page, {
|
||
name: "ReviewState",
|
||
sessions,
|
||
vcs: { current: "feature", default: "dev" },
|
||
vcsDiff: ({ mode }) =>
|
||
mode === "branch"
|
||
? [fileDiff("src/alpha.ts"), fileDiff("src/beta.ts")]
|
||
: [fileDiff("src/alpha.ts"), fileDiff("src/gamma.ts")],
|
||
fileList: () => [fileNode(directory, "README.md")],
|
||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const review = panel.locator("#session-side-panel-review-tab")
|
||
const toggle = page.getByRole("button", { name: "Toggle review" })
|
||
|
||
const selectedTab = (name: string) =>
|
||
expect(panel.getByRole("tab", { name, exact: true })).toHaveAttribute("aria-selected", "true")
|
||
|
||
const selectedFile = (file: string) =>
|
||
expect(page.locator('[data-slot="session-review-v2-file-name"]')).toHaveText(file)
|
||
|
||
const switchSession = async (title: string) => {
|
||
await page.locator("[data-titlebar-tab-slot]", { hasText: title }).click()
|
||
await expectSessionTitle(page, title)
|
||
}
|
||
|
||
// Each session selects a file other than the first, which the review would show without a stored selection.
|
||
await toggle.click()
|
||
await openReviewLauncher(panel)
|
||
await page.getByRole("treeitem", { name: "gamma.ts" }).click()
|
||
await selectedFile("gamma.ts")
|
||
await openFileLauncher(panel)
|
||
await panel.getByRole("treeitem", { name: "README.md" }).click()
|
||
await selectedTab("README.md")
|
||
|
||
await switchSession("Beta review state")
|
||
await toggle.click()
|
||
await openReviewLauncher(panel)
|
||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||
await page.getByRole("button", { name: "Git changes" }).click()
|
||
await page.getByRole("option", { name: "Branch changes" }).click()
|
||
await page.getByRole("treeitem", { name: "beta.ts" }).click()
|
||
await selectedFile("beta.ts")
|
||
await page.getByRole("button", { name: "Toggle session context" }).click()
|
||
await selectedTab("Context")
|
||
|
||
await switchSession("Gamma review state")
|
||
await toggle.click()
|
||
await openFileLauncher(panel)
|
||
await selectedTab("Open file")
|
||
|
||
await switchSession("Alpha review state")
|
||
await selectedTab("README.md")
|
||
await review.click()
|
||
await selectedFile("gamma.ts")
|
||
await panel.getByRole("tab", { name: "README.md", exact: true }).click()
|
||
await switchSession("Beta review state")
|
||
await selectedTab("Context")
|
||
await switchSession("Gamma review state")
|
||
await selectedTab("Open file")
|
||
|
||
await page.reload()
|
||
await expectSessionTitle(page, "Gamma review state")
|
||
await selectedTab("Open file")
|
||
await switchSession("Beta review state")
|
||
await selectedTab("Context")
|
||
await review.click()
|
||
await expect(page.getByRole("button", { name: "Branch changes" })).toBeVisible()
|
||
await selectedFile("beta.ts")
|
||
await switchSession("Alpha review state")
|
||
await selectedTab("README.md")
|
||
await panel.getByRole("tab", { name: "README.md", exact: true }).press("Home")
|
||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||
await expect(page.getByRole("button", { name: "Git changes" })).toBeVisible()
|
||
await selectedFile("gamma.ts")
|
||
await review.press("End")
|
||
await selectedTab("README.md")
|
||
|
||
// A hidden side-panel tab does not claim Close Tab while the side region is collapsed.
|
||
await toggle.click()
|
||
await expect(panel).toBeHidden()
|
||
await page.keyboard.press("Control+w")
|
||
await expect(page.locator("[data-titlebar-tab-slot]", { hasText: "Alpha review state" })).toHaveCount(0)
|
||
await expectSessionTitle(page, "Beta review state")
|
||
await page.keyboard.press("Control+Shift+T")
|
||
await expectSessionTitle(page, "Alpha review state")
|
||
await toggle.click()
|
||
await selectedTab("README.md")
|
||
|
||
// Opening moves focus into the side panel once its motion lands; from there Close Tab closes the side tab.
|
||
await expect(panel).toBeFocused()
|
||
await page.keyboard.press("Control+w")
|
||
await expect(panel.getByRole("tab", { name: "README.md", exact: true })).toHaveCount(0)
|
||
await expect(review).toHaveAttribute("aria-selected", "true")
|
||
await expectSessionTitle(page, "Alpha review state")
|
||
})
|
||
|
||
test("shows and restores last turn changes from the session diff", async ({ page }) => {
|
||
const sessionID = "ses_reviewturn"
|
||
await openSession(page, { name: "ReviewTurn", vcsDiff: [fileDiff("src/alpha.ts")] })
|
||
await page.route(`**/api/session/${sessionID}/diff**`, (route) =>
|
||
route.fulfill({
|
||
status: 200,
|
||
contentType: "application/json",
|
||
body: JSON.stringify({ data: [fileDiff("src/delta.ts")] }),
|
||
}),
|
||
)
|
||
const panel = page.locator("#review-panel")
|
||
await page.getByRole("button", { name: "Toggle review" }).click()
|
||
await openReviewLauncher(panel)
|
||
await page.getByRole("button", { name: "Git changes" }).click()
|
||
await page.getByRole("option", { name: "Last turn changes" }).click()
|
||
await expect(page.getByRole("button", { name: "Last turn changes" })).toBeVisible()
|
||
await expect(panel.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("delta.ts")
|
||
|
||
await page.reload()
|
||
await expectSessionTitle(page, "ReviewTurn")
|
||
await expect(page.getByRole("button", { name: "Last turn changes" })).toBeVisible()
|
||
await expect(panel.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("delta.ts")
|
||
})
|
||
|
||
test("keeps the review state a session stored before plugins", async ({ page }) => {
|
||
const directory = "C:/OpenCode/ReviewLegacy"
|
||
await openSession(page, {
|
||
name: "ReviewLegacy",
|
||
vcs: { current: "feature", default: "dev" },
|
||
vcsDiff: ({ mode }) =>
|
||
mode === "branch" ? [fileDiff("alpha.ts"), fileDiff("beta.ts")] : [fileDiff("alpha.ts"), fileDiff("gamma.ts")],
|
||
seed: {
|
||
storage: {
|
||
"opencode.global.dat:layout": {
|
||
sessionView: {
|
||
[`local\u0000${base64Encode(directory)}/ses_reviewlegacy`]: {
|
||
scroll: {},
|
||
reviewMode: "branch",
|
||
reviewFile: "beta.ts",
|
||
reviewOpen: ["beta.ts"],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
})
|
||
const mode = (name: string) => page.getByRole("button", { name, exact: true })
|
||
const changes = page.getByRole("tablist", { name: "Session view", exact: true }).getByRole("tab", { name: "Changes" })
|
||
|
||
const trigger = (file: string) =>
|
||
page
|
||
.locator(`[data-component="session-review"] [data-file="${file}"]`)
|
||
.getByRole("button", { name: file, exact: true })
|
||
|
||
await page.getByRole("button", { name: "Toggle review" }).click()
|
||
await openReviewLauncher(page.locator("#review-panel"))
|
||
await expect(mode("Branch changes")).toBeVisible()
|
||
await expect(page.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("beta.ts")
|
||
// The narrow review lists every file and expands the ones left open.
|
||
await page.setViewportSize({ width: 390, height: 844 })
|
||
await changes.click()
|
||
await expect(trigger("beta.ts")).toHaveAttribute("aria-expanded", "true")
|
||
await expect(trigger("alpha.ts")).toHaveAttribute("aria-expanded", "false")
|
||
|
||
// The copy happens once: a later change survives a reload, although the old state is still stored.
|
||
await mode("Branch changes").click()
|
||
await page.getByRole("option", { name: "Git changes" }).click()
|
||
await expect(trigger("gamma.ts")).toBeVisible()
|
||
await page.reload()
|
||
await changes.click()
|
||
await expect(mode("Git changes")).toBeVisible()
|
||
await expect(trigger("gamma.ts")).toBeVisible()
|
||
})
|
||
|
||
test("desktop review waits for the session's stored mode before it loads changes", async ({ page }) => {
|
||
const directory = "C:/OpenCode/ReviewDesktop"
|
||
const id = "ses_review_desktop"
|
||
const title = "Desktop review"
|
||
await mockOpenCodeServer(page, {
|
||
directory,
|
||
project: project({ id: "proj_review_desktop", directory }),
|
||
provider: provider(),
|
||
sessions: [session({ id, directory, title })],
|
||
pageMessages: () => ({ items: [] }),
|
||
vcs: { current: "feature", default: "dev" },
|
||
vcsDiff: ({ mode }) => (mode === "branch" ? [fileDiff("beta.ts")] : [fileDiff("gamma.ts")]),
|
||
})
|
||
const working: string[] = []
|
||
page.on("request", (request) => {
|
||
const url = new URL(request.url())
|
||
|
||
if (url.pathname.endsWith("/vcs/diff") && url.searchParams.get("mode") === "working") working.push(request.url())
|
||
})
|
||
|
||
const desktop = (hold?: string) =>
|
||
`/e2e/utils/settings-wsl.html?${new URLSearchParams({
|
||
server: SERVER,
|
||
mode: "stopped",
|
||
storage: "async",
|
||
path: `/server/${base64Encode("sidecar")}/session/${id}`,
|
||
...(hold && { hold }),
|
||
})}`
|
||
|
||
const mode = (name: string) => page.getByRole("button", { name, exact: true })
|
||
const file = page.locator('[data-slot="session-review-v2-file-name"]')
|
||
const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
|
||
|
||
await page.goto(desktop())
|
||
await expectSessionTitle(page, title)
|
||
await toggle.click()
|
||
await openReviewLauncher(page.locator("#review-panel"))
|
||
await mode("Git changes").click()
|
||
await page.getByRole("option", { name: "Branch changes" }).click()
|
||
await expect(file).toHaveText("beta.ts")
|
||
await expect
|
||
.poll(() =>
|
||
page.evaluate(() =>
|
||
Object.entries(localStorage).some(
|
||
([key, value]) => key.includes("plugin.review.session") && value.includes('"branch"'),
|
||
),
|
||
),
|
||
)
|
||
.toBe(true)
|
||
|
||
// The reopened window's review mounts before its session store has loaded.
|
||
working.length = 0
|
||
await page.goto(desktop("plugin.review.session"))
|
||
await expectSessionTitle(page, title)
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(page.locator("#review-panel").getByText("Loading changes…", { exact: true })).toBeVisible()
|
||
await expect(mode("Git changes")).toHaveCount(0)
|
||
await page.getByRole("button", { name: "Load held storage" }).click()
|
||
await expect(mode("Branch changes")).toBeVisible()
|
||
await expect(file).toHaveText("beta.ts")
|
||
expect(working).toEqual([])
|
||
})
|
||
|
||
// A failed request used to settle like an empty one, so the review claimed the working tree was clean.
|
||
test("a failed diff request offers a retry instead of a clean working tree", async ({ page }) => {
|
||
await openSession(page, { name: "ReviewDiffFailure", vcsDiff: [fileDiff("src/alpha.ts")] })
|
||
const changes = { failing: true }
|
||
await page.route(/\/api\/vcs\/diff\?/, (route) => {
|
||
if (!changes.failing || new URL(route.request().url()).searchParams.get("untracked") !== "folders")
|
||
return route.fallback()
|
||
|
||
return route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} })
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const failure = panel.getByRole("alert")
|
||
|
||
await page.getByRole("button", { name: "Toggle review", exact: true }).click()
|
||
await openReviewLauncher(panel)
|
||
await expect(failure.getByText("Couldn't load changes", { exact: true })).toBeVisible()
|
||
await expect(panel.locator('[data-slot="session-review-v2-empty-changes"]')).toHaveCount(0)
|
||
changes.failing = false
|
||
await failure.getByRole("button", { name: "Try again", exact: true }).click()
|
||
await expect(panel.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("alpha.ts")
|
||
await expect(failure).toHaveCount(0)
|
||
})
|
||
|
||
// A large file's full patch that failed to load used to leave its preview blank, with no reason and no way to load it.
|
||
test("a large file whose full diff fails to load says so, and loads on Try again", async ({ page }) => {
|
||
// The listing leaves the patch out, as the server does for a large file; the bounded request carries it.
|
||
await openSession(page, {
|
||
name: "ReviewDetailFailure",
|
||
vcsDiff: (input) => [fileDiff("big.ts", { loaded: input.context === "3" })],
|
||
})
|
||
const full = { failing: true }
|
||
await page.route(/\/api\/vcs\/diff\?.*context=3/, (route) => {
|
||
if (!full.failing) return route.fallback()
|
||
|
||
return route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} })
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const preview = panel.locator('[data-slot="session-review-v2-diff-scroll"]')
|
||
const failure = preview.getByRole("alert")
|
||
|
||
await page.getByRole("button", { name: "Toggle review", exact: true }).click()
|
||
await openReviewLauncher(panel)
|
||
await expect(panel.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("big.ts")
|
||
// The request runs three times, a second and then two apart, before the preview gives up.
|
||
await expect(failure.getByText("Couldn't load changes", { exact: true })).toBeVisible()
|
||
full.failing = false
|
||
await failure.getByRole("button", { name: "Try again", exact: true }).click()
|
||
await expect(preview.locator("diffs-container")).toContainText("export const value = 'after'")
|
||
await expect(failure).toHaveCount(0)
|
||
})
|
||
|
||
// A failed search used to read "No results found", as if the workspace had no such file.
|
||
test("a failed file search offers a retry instead of no results", async ({ page }) => {
|
||
const directory = "C:/OpenCode/ReviewSearchFailure"
|
||
await openSession(page, {
|
||
name: "ReviewSearchFailure",
|
||
fileList: () => [fileNode(directory, "README.md")],
|
||
findFiles: (input) => (input.query === "nested" ? [fileNode(directory, "src/nested.ts")] : []),
|
||
seed: { panes: { ses_reviewsearchfailure: { review: true } } },
|
||
})
|
||
const search = { failing: true }
|
||
await page.route(/\/api\/fs\/find\?/, (route) => {
|
||
if (!search.failing) return route.fallback()
|
||
|
||
return route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} })
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const filter = panel.getByRole("combobox", { name: "Filter files" })
|
||
const failure = panel.getByRole("alert")
|
||
|
||
await openFileLauncher(panel)
|
||
await filter.fill("nested")
|
||
await expect(failure.getByText("Couldn't search files", { exact: true })).toBeVisible()
|
||
await expect(panel.getByText("No results found", { exact: true })).toHaveCount(0)
|
||
await page.screenshot({ path: test.info().outputPath("file-search-failed.png"), animations: "disabled" })
|
||
search.failing = false
|
||
await failure.getByRole("button", { name: "Try again", exact: true }).click()
|
||
await expect(panel.getByRole("option", { name: /nested\.ts/ })).toBeVisible()
|
||
await expect(failure).toHaveCount(0)
|
||
})
|
||
|
||
// An untracked folder whose listing failed used to look empty, and opening it again never asked the server again.
|
||
test("an untracked folder that cannot load says so, and loads once it is opened again", async ({ page }) => {
|
||
const workspace = await openSession(page, {
|
||
name: "ReviewFolderFailure",
|
||
vcsDiff: (input) =>
|
||
input.directory.endsWith("/untracked")
|
||
? [fileDiff("untracked/notes.ts", { status: "added" })]
|
||
: [fileDiff("src/alpha.ts"), fileDiff("untracked/", { status: "added" })],
|
||
})
|
||
|
||
const listing = { failing: true, failures: 0 }
|
||
|
||
await page.route(/\/api\/vcs\/diff\?/, (route) => {
|
||
const directory = new URL(route.request().url()).searchParams.get("location[directory]")
|
||
|
||
if (!listing.failing || directory !== `${workspace.directory}/untracked`) return route.fallback()
|
||
listing.failures += 1
|
||
|
||
return route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} })
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const folder = panel.getByRole("treeitem", { name: "untracked" })
|
||
const notes = panel.getByRole("treeitem", { name: "notes.ts" })
|
||
|
||
await page.getByRole("button", { name: "Toggle review", exact: true }).click()
|
||
await openReviewLauncher(panel)
|
||
await expect(panel.getByRole("treeitem", { name: "alpha.ts" })).toBeVisible()
|
||
// Retries back off over 1, 2 and 4 seconds; the installed clock follows real time until a fast-forward skips it.
|
||
await page.clock.install()
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "true")
|
||
|
||
for (const failures of [1, 2, 3]) {
|
||
await expect.poll(() => listing.failures).toBe(failures)
|
||
await page.clock.fastForward(1_000 * 2 ** (failures - 1))
|
||
}
|
||
|
||
await expect.poll(() => listing.failures).toBe(4)
|
||
await expect(folder).toContainText("Couldn't load changes")
|
||
await expect(notes).toHaveCount(0)
|
||
|
||
listing.failing = false
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "false")
|
||
await expect(folder).not.toContainText("Couldn't load changes")
|
||
await folder.click()
|
||
await expect(folder).toHaveAttribute("aria-expanded", "true")
|
||
await expect(notes).toBeVisible()
|
||
await expect(folder).toContainText("1")
|
||
expect(listing.failures).toBe(4)
|
||
})
|
||
|
||
test("a chosen mode the session stops offering shows as Git, and comes back when it is offered again", async ({
|
||
page,
|
||
}) => {
|
||
// The mock server reads the branches on each request, so a reload sees the session's branch change.
|
||
const vcs = { current: "feature", default: "dev" }
|
||
await openSession(page, {
|
||
name: "ReviewModeBack",
|
||
vcs,
|
||
vcsDiff: ({ mode }) => (mode === "branch" ? [fileDiff("beta.ts")] : [fileDiff("gamma.ts")]),
|
||
})
|
||
const mode = (name: string) => page.getByRole("button", { name, exact: true })
|
||
const file = page.locator('[data-slot="session-review-v2-file-name"]')
|
||
|
||
await page.getByRole("button", { name: "Toggle review", exact: true }).click()
|
||
await openReviewLauncher(page.locator("#review-panel"))
|
||
await mode("Git changes").click()
|
||
await page.getByRole("option", { name: "Branch changes" }).click()
|
||
await expect(file).toHaveText("beta.ts")
|
||
|
||
// Back on the default branch, Branch is not offered.
|
||
vcs.current = "dev"
|
||
await page.reload()
|
||
await expect(mode("Git changes")).toBeVisible()
|
||
await expect(file).toHaveText("gamma.ts")
|
||
|
||
vcs.current = "feature"
|
||
await page.reload()
|
||
await expect(mode("Branch changes")).toBeVisible()
|
||
await expect(file).toHaveText("beta.ts")
|
||
})
|
||
|
||
test("names a single change source and keeps the review header rows at 48px", async ({ page }) => {
|
||
// Turn changes are offered only for Git, so another VCS offers one source.
|
||
await openSession(page, { name: "ReviewHeader", project: { vcs: "hg" }, vcsDiff: [fileDiff("src/alpha.ts")] })
|
||
await page.getByRole("button", { name: "Toggle review", exact: true }).click()
|
||
const panel = page.locator("#review-panel")
|
||
await openReviewLauncher(panel)
|
||
const toggle = panel.getByRole("button", { name: "Toggle file tree" })
|
||
const header = panel.locator('[data-slot="session-review-v2-sidebar-header"]')
|
||
const toolbar = panel.locator('[data-slot="session-review-v2-toolbar"]')
|
||
|
||
await expect(header.getByText("Git changes", { exact: true })).toBeVisible()
|
||
await expect(panel.getByRole("button", { name: "Git changes" })).toHaveCount(0)
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(header).toHaveCSS("height", "48px")
|
||
await expect(toolbar).toHaveCSS("height", "48px")
|
||
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
await expect(toolbar.getByText("Git changes", { exact: true })).toBeVisible()
|
||
await expect(toolbar).toHaveCSS("height", "48px")
|
||
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(header).toHaveCSS("height", "48px")
|
||
await expect(toolbar).toHaveCSS("height", "48px")
|
||
|
||
// Closing the last tab closes the side region; it reopens on a New tab view listing its launchers.
|
||
const region = page.getByRole("button", { name: "Toggle review", exact: true })
|
||
await panel.locator("#session-side-panel-review-tab").hover()
|
||
await panel.getByRole("button", { name: "Close tab", exact: true }).click()
|
||
await expect(region).toHaveAttribute("aria-expanded", "false")
|
||
await region.click()
|
||
await expect(panel.getByRole("tab")).toHaveCount(1)
|
||
await expect(panel.getByRole("tab", { name: "New tab", exact: true })).toHaveAttribute("aria-selected", "true")
|
||
// "+" adds another New tab beside it instead of replacing it.
|
||
await panel.getByRole("button", { name: "Add tab", exact: true }).click()
|
||
await expect(panel.getByRole("tab", { name: "New tab", exact: true })).toHaveCount(2)
|
||
// Only its launchers: "Recently closed" lists files, not the closed Review.
|
||
await expect(panel.getByRole("button", { name: /^Review/ })).toBeVisible()
|
||
await expect(panel.getByRole("region", { name: "Recently closed", exact: true })).toHaveCount(0)
|
||
})
|
||
|
||
test("Review from a new tab keeps the file browser and preview open", async ({ page }) => {
|
||
const directory = "C:/OpenCode/ReviewNewTabFile"
|
||
await openSession(page, {
|
||
name: "ReviewNewTabFile",
|
||
fileList: (path) => (path ? [] : [fileNode(directory, "README.md")]),
|
||
fileContent: (path) => ({ type: "text", content: `contents:${path}` }),
|
||
seed: {
|
||
panes: { ses_reviewnewtabfile: { review: true } },
|
||
storage: { "opencode.global.dat:review-panel-v2": { sidebarOpened: false } },
|
||
},
|
||
})
|
||
const panel = page.locator("#review-panel")
|
||
const tab = (name: string) => panel.getByRole("tab", { name, exact: true })
|
||
|
||
await openFileLauncher(panel)
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "true")
|
||
// The empty panel's own New tab stays beside the one the file browser replaced, so the added one is the last.
|
||
await panel.getByRole("button", { name: "Add tab", exact: true }).click()
|
||
await expect(tab("New tab").last()).toHaveAttribute("aria-selected", "true")
|
||
await panel.getByRole("button", { name: /^Review/ }).click()
|
||
await expect(tab("Review")).toHaveAttribute("aria-selected", "true")
|
||
await expect(tab("Open file")).toHaveAttribute("aria-selected", "false")
|
||
await tab("Review").hover()
|
||
await panel
|
||
.locator('div[data-value="review:changes"]')
|
||
.getByRole("button", { name: "Close tab", exact: true })
|
||
.click()
|
||
await tab("Open file").click()
|
||
await panel.getByRole("treeitem", { name: "README.md" }).click()
|
||
await expect(tab("README.md")).toHaveAttribute("aria-selected", "true")
|
||
|
||
// Choosing Review also leaves a single-click file preview open beside it.
|
||
await panel.getByRole("button", { name: "Add tab", exact: true }).click()
|
||
await expect(tab("New tab").last()).toHaveAttribute("aria-selected", "true")
|
||
await panel.getByRole("button", { name: /^Review/ }).click()
|
||
await expect(panel.locator("#session-side-panel-review-tab")).toHaveAttribute("aria-selected", "true")
|
||
await expect(tab("README.md")).toHaveCount(1)
|
||
})
|
||
|
||
for (const direction of ["ltr", "rtl"] as const) {
|
||
test(`review toggle stays at the header edge in ${direction}`, async ({ page }) => {
|
||
await page.setViewportSize({ width: 1000, height: 900 })
|
||
await openSession(page, { name: "ReviewToggle" })
|
||
await page.locator("html").evaluate((element, dir) => element.setAttribute("dir", dir), direction)
|
||
|
||
const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
|
||
const panel = page.locator("#review-panel")
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
const closed = (await toggle.boundingBox())!
|
||
const header = (await page.locator("[data-session-title]").boundingBox())!
|
||
expect(closed.y).toBeGreaterThanOrEqual(header.y)
|
||
expect(closed.y + closed.height).toBeLessThanOrEqual(header.y + header.height)
|
||
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "true")
|
||
await expect(panel).toHaveAttribute("aria-hidden", "false")
|
||
await expect(toggle).toHaveCount(1)
|
||
await expect.poll(() => toggle.boundingBox()).toEqual(closed)
|
||
await expect
|
||
.poll(async () => {
|
||
const box = (await panel.boundingBox())!
|
||
|
||
return (
|
||
closed.x >= box.x &&
|
||
closed.x + closed.width <= box.x + box.width &&
|
||
closed.y >= box.y &&
|
||
closed.y + closed.height <= box.y + 52
|
||
)
|
||
})
|
||
.toBe(true)
|
||
|
||
for (const control of [
|
||
panel.locator('[data-slot="session-side-panel-actions"]'),
|
||
panel.getByRole("button", { name: "Add tab", exact: true }),
|
||
]) {
|
||
await expect
|
||
.poll(async () => {
|
||
const box = await control.boundingBox()
|
||
|
||
return box ? box.y + box.height / 2 : undefined
|
||
})
|
||
.toBe(closed.y + closed.height / 2)
|
||
}
|
||
|
||
await toggle.press("Enter")
|
||
await expect(toggle).toHaveAttribute("aria-expanded", "false")
|
||
await expect(toggle).toBeFocused()
|
||
await expect.poll(() => toggle.boundingBox()).toEqual(closed)
|
||
await expect(panel).toBeHidden()
|
||
|
||
// The chat's width springs; once the panel settles open, it fills the rest of the row beside the chat.
|
||
for (const opened of [true, false]) {
|
||
await toggle.click()
|
||
await expect(toggle).toHaveAttribute("aria-expanded", String(opened))
|
||
await expect(panel).toHaveAttribute("aria-hidden", String(!opened))
|
||
|
||
if (opened) await expect(() => expectHeaderClearOfToggle(page, toggle)).toPass()
|
||
}
|
||
|
||
await expect(panel).toBeHidden()
|
||
})
|
||
}
|
||
|
||
async function statusInset(status: Locator, side: "left" | "right") {
|
||
return status.evaluate((element, side) => {
|
||
const root = element.getRootNode()
|
||
const host = root instanceof ShadowRoot ? root.host : element
|
||
const viewport = host.closest<HTMLElement>("[data-scrollable]")!.getBoundingClientRect()
|
||
const box = element.getBoundingClientRect()
|
||
|
||
return side === "right" ? viewport.right - box.right : box.left - viewport.left
|
||
}, side)
|
||
}
|
||
|
||
function filesystemEvent(directory: string, file: string, event: "add" | "change" | "unlink"): OpenCodeEvent {
|
||
return {
|
||
id: `evt_${file}_${event}`,
|
||
created: 1,
|
||
type: "filesystem.changed",
|
||
location: { directory },
|
||
data: { file, event },
|
||
}
|
||
}
|
||
|
||
async function expectHeaderClearOfToggle(page: Page, toggle: Locator) {
|
||
const geometry = await page.locator('[data-slot="session-chat-panel"]').evaluate((chat) => {
|
||
const row = chat.parentElement!
|
||
const chatBounds = chat.getBoundingClientRect()
|
||
const panelBounds = document.querySelector("#review-panel")!.getBoundingClientRect()
|
||
|
||
return {
|
||
row: row.getBoundingClientRect().width,
|
||
gap:
|
||
getComputedStyle(row).direction === "rtl"
|
||
? chatBounds.left - panelBounds.right
|
||
: panelBounds.left - chatBounds.right,
|
||
panels: chatBounds.width + panelBounds.width + parseFloat(getComputedStyle(row).columnGap),
|
||
}
|
||
})
|
||
|
||
expect(geometry.gap).toBeCloseTo(8, 1)
|
||
expect(Math.abs(geometry.row - geometry.panels)).toBeLessThanOrEqual(1)
|
||
|
||
const clip = (await toggle.boundingBox())!
|
||
// Header contents must make no difference to the pixels behind the fixed toggle.
|
||
expect(await page.screenshot({ clip })).toEqual(
|
||
await page.screenshot({ clip, style: ".session-review-v2-tabs-bar { visibility: hidden !important; }" }),
|
||
)
|
||
}
|