mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-17 05:26:47 +03:00
517 lines
23 KiB
TypeScript
517 lines
23 KiB
TypeScript
import { expect, test, type Page } from "@playwright/test"
|
|
import en from "../../src/runtime/i18n/en"
|
|
import { clientSettings } from "../../src/settings/search-catalog"
|
|
import { NO_PROVIDER, REMOTE_SERVER, holdRoute, project, type SeedInput } from "../utils/app"
|
|
import { mockOpenCodeServer } from "../utils/mock-server"
|
|
import { openSettings } from "../utils/workspace"
|
|
|
|
const directory = "/projects/opencode"
|
|
|
|
test.use({ viewport: { width: 1280, height: 900 }, serviceWorkers: "block" })
|
|
|
|
// `count` replaces the single "OpenCode" project with "OpenCode 00".."OpenCode NN".
|
|
async function open(page: Page, input: { count?: number; seed?: SeedInput } = {}) {
|
|
const projects =
|
|
input.count === undefined
|
|
? undefined
|
|
: Array.from({ length: input.count }, (_, index) =>
|
|
project({
|
|
id: `proj_search_${index}`,
|
|
directory: `${directory}-${index}`,
|
|
name: `OpenCode ${String(index).padStart(2, "0")}`,
|
|
}),
|
|
)
|
|
|
|
await page.route("https://api.github.com/**", (route) => route.fulfill({ json: [] }))
|
|
|
|
const { settings } = await openSettings(page, {
|
|
name: "OpenCode",
|
|
directory,
|
|
project: { icon: { color: "orange" } },
|
|
provider: NO_PROVIDER,
|
|
projects,
|
|
seed: { tabs: [], ...input.seed },
|
|
})
|
|
|
|
const view = {
|
|
settings,
|
|
search: settings.getByRole("combobox", { name: "Search", exact: true }),
|
|
results: settings.getByRole("listbox", { name: "Settings results", exact: true }),
|
|
viewport: settings.locator('.settings-search [data-slot="search-list-scroll"]'),
|
|
}
|
|
|
|
// Readiness includes the server-backed project inventory, not just the settings shell.
|
|
if (input.count === 0) return view
|
|
await view.search.fill("OpenCode")
|
|
// Only the selected server's projects are indexed.
|
|
await expect(view.results.getByRole("option")).toHaveCount(input.count ?? 1)
|
|
await view.search.clear()
|
|
|
|
return view
|
|
}
|
|
|
|
async function findShortcut(page: Page) {
|
|
// Browser emulation can report a different OS than the machine running Playwright.
|
|
const key = await page.evaluate(() => (/Mac|iPhone|iPad|iPod/.test(navigator.platform) ? "Meta+f" : "Control+f"))
|
|
await page.keyboard.press(key)
|
|
}
|
|
|
|
test("pointer selection, keyboard navigation, the empty state, and the local find shortcut", async ({ page }) => {
|
|
const view = await open(page)
|
|
await view.search.fill("font")
|
|
const code = view.results.getByRole("option", { name: "Code Font, Appearance", exact: true })
|
|
const terminal = view.results.getByRole("option", { name: "Terminal Font, Appearance", exact: true })
|
|
const font = view.results.getByRole("option", { name: "UI Font, Appearance", exact: true })
|
|
await expect(view.results.getByRole("option")).toHaveText([
|
|
"Code FontAppearance",
|
|
"Terminal FontAppearance",
|
|
"UI FontAppearance",
|
|
])
|
|
// Keys stay with the field, as in every shared search list.
|
|
await code.click()
|
|
await expect(view.search).toBeFocused()
|
|
await expect(code).toHaveAttribute("aria-selected", "true")
|
|
await expect(view.settings.getByRole("textbox", { name: "Code Font", exact: true })).toBeInViewport()
|
|
await view.search.press("ArrowDown")
|
|
await expect(terminal).toHaveAttribute("aria-selected", "true")
|
|
// Shift+arrows select text in the field instead of moving through the results.
|
|
await view.search.press("Shift+ArrowUp")
|
|
await expect(view.search).toHaveJSProperty("selectionStart", 0)
|
|
await expect(terminal).toHaveAttribute("aria-selected", "true")
|
|
await view.search.press("Enter")
|
|
await expect(view.search).toBeFocused()
|
|
await expect(view.settings.getByRole("textbox", { name: "Terminal Font", exact: true })).toBeInViewport()
|
|
await expect(view.settings.locator('[data-search-target="row"]')).toContainText("Terminal Font")
|
|
await view.search.press("End")
|
|
await expect(font).toHaveAttribute("aria-selected", "true")
|
|
await view.search.press("Home")
|
|
await expect(code).toHaveAttribute("aria-selected", "true")
|
|
await findShortcut(page)
|
|
await expect(view.search).toBeFocused()
|
|
expect(await view.search.evaluate((input: HTMLInputElement) => [input.selectionStart, input.selectionEnd])).toEqual([
|
|
0, 4,
|
|
])
|
|
|
|
await view.search.fill("zzzzzzzzzz")
|
|
await expect(view.results.getByRole("option")).toHaveCount(0)
|
|
await expect(view.settings.getByRole("status")).toHaveText('No results for "zzzzzzzzzz"')
|
|
await view.search.press("Escape")
|
|
await expect(view.search).toHaveValue("")
|
|
|
|
// The narrow layout collapses the results once a result is picked.
|
|
await page.setViewportSize({ width: 390, height: 844 })
|
|
await view.search.fill("terminal font")
|
|
await view.results.getByRole("option").click()
|
|
await expect(view.results).toBeHidden()
|
|
await expect(view.search).toHaveAttribute("aria-expanded", "false")
|
|
await expect(view.search).not.toHaveAttribute("aria-activedescendant", /.+/)
|
|
await findShortcut(page)
|
|
await expect(view.search).toBeFocused()
|
|
await expect(view.results).toBeVisible()
|
|
await expect(view.search).toHaveAttribute("aria-activedescendant", /.+/)
|
|
|
|
await page.setViewportSize({ width: 1280, height: 900 })
|
|
await view.settings.getByRole("button", { name: "Back to app", exact: true }).click()
|
|
await expect(view.settings).toBeHidden()
|
|
await findShortcut(page)
|
|
await expect(page.getByRole("textbox", { name: /Search sessions/ })).toBeFocused()
|
|
})
|
|
|
|
test("the narrow layout floats the results in the shared search list popover", async ({ page }) => {
|
|
const view = await open(page, { count: 30 })
|
|
await page.setViewportSize({ width: 390, height: 844 })
|
|
await view.search.fill("e")
|
|
const popover = view.settings.locator('.settings-search [data-component="search-list"][data-popover]')
|
|
const body = popover.locator('[data-slot="search-list-body"]')
|
|
await expect(body).toBeVisible()
|
|
await expect(body).toHaveCSS("position", "absolute")
|
|
await expect(body.locator('[data-slot="search-list-header"]').first()).toHaveText("Pages")
|
|
await expect(view.results.getByRole("option").first()).toHaveAttribute("data-slot", "search-list-row")
|
|
await expect(body.locator('[data-slot="search-list-footer"]')).toHaveText(en["settings.search.refine"])
|
|
await view.search.fill("zzzzzzzzzz")
|
|
await expect(body.locator('[data-slot="search-list-empty"]').getByRole("status")).toHaveText(
|
|
'No results for "zzzzzzzzzz"',
|
|
)
|
|
|
|
// The message's text, not just its box, sits in the middle of the popover.
|
|
const offset = await body.evaluate((element) => {
|
|
const range = document.createRange()
|
|
range.selectNodeContents(element.querySelector('[role="status"]')!)
|
|
const text = range.getBoundingClientRect()
|
|
const box = element.getBoundingClientRect()
|
|
|
|
return {
|
|
x: text.left + text.width / 2 - (box.left + box.width / 2),
|
|
y: text.top + text.height / 2 - (box.top + box.height / 2),
|
|
}
|
|
})
|
|
|
|
expect(Math.abs(offset.x)).toBeLessThan(1)
|
|
expect(Math.abs(offset.y)).toBeLessThan(1)
|
|
})
|
|
|
|
test("a category's results stay under one run of headers when its groups interleave by rank", async ({ page }) => {
|
|
await mockOpenCodeServer(page, {
|
|
server: REMOTE_SERVER,
|
|
directory: "/remote/opencode",
|
|
project: project({ id: "proj_search_remote", directory: "/remote/opencode", name: "Remote app" }),
|
|
provider: NO_PROVIDER,
|
|
sessions: [],
|
|
pageMessages: () => ({ items: [] }),
|
|
})
|
|
const view = await open(page, { seed: { servers: [{ url: REMOTE_SERVER, name: "Build server" }] } })
|
|
// With two servers, "e" ranks a This computer setting between unscoped settings and the project results.
|
|
await view.search.fill("e")
|
|
const headers = view.results.locator('[data-slot="search-list-header"]')
|
|
await expect(headers.filter({ hasText: "This computer" })).not.toHaveCount(0)
|
|
|
|
const categories = await headers.evaluateAll((elements) =>
|
|
elements.map((element) => element.firstElementChild?.textContent ?? ""),
|
|
)
|
|
|
|
const runs = categories.filter((category, index) => category !== categories[index - 1])
|
|
expect(categories.filter((category) => category === "Settings")).toHaveLength(2)
|
|
expect(runs).toEqual([...new Set(runs)])
|
|
})
|
|
|
|
test("a long empty-state query keeps its closing quote beside the ellipsis while typing and resizing", async ({
|
|
page,
|
|
}) => {
|
|
const view = await open(page)
|
|
const query = "zzzz 🧑🏽💻 ".repeat(40)
|
|
await view.search.fill(query)
|
|
const status = view.settings.getByRole("status")
|
|
const quoted = status.locator("bdi")
|
|
|
|
// Rects, not clientWidth: the centred quote is exactly as wide as its text, and clientWidth rounds.
|
|
const fits = () =>
|
|
quoted.evaluate(
|
|
(element) => element.getBoundingClientRect().width <= element.parentElement!.getBoundingClientRect().width + 0.5,
|
|
)
|
|
|
|
await expect(status).toHaveAccessibleName(`No results for "${query}"`)
|
|
await expect(quoted).toHaveText(/^".+…"$/)
|
|
await expect.poll(fits).toBe(true)
|
|
const text = await quoted.textContent()
|
|
await page.setViewportSize({ width: 390, height: 844 })
|
|
await expect(quoted).toHaveText(/^".+…"$/)
|
|
await expect(quoted).not.toHaveText(text!)
|
|
await expect.poll(fits).toBe(true)
|
|
await view.search.fill("zzzzzzzzzz")
|
|
await view.search.pressSequentially("x")
|
|
await expect(status).toHaveText('No results for "zzzzzzzzzzx"')
|
|
})
|
|
|
|
test("the search input tracks overflow through typing, caret moves, resizing, and clearing", async ({ page }) => {
|
|
const view = await open(page)
|
|
|
|
const overflow = async (start: string, end: string) => {
|
|
await expect(view.search).toHaveAttribute("data-overflow-start", start)
|
|
await expect(view.search).toHaveAttribute("data-overflow-end", end)
|
|
}
|
|
|
|
// Bare Home and End move through the results, so the caret moves with Shift.
|
|
await view.search.fill("zzzz ".repeat(30))
|
|
await view.search.press("Shift+End")
|
|
await overflow("true", "false")
|
|
await view.search.press("Shift+Home")
|
|
await overflow("false", "true")
|
|
await view.search.evaluate((input: HTMLInputElement) => {
|
|
input.scrollLeft = (input.scrollWidth - input.clientWidth) / 2
|
|
})
|
|
await overflow("true", "true")
|
|
await view.search.fill("z".repeat(50))
|
|
await page.setViewportSize({ width: 600, height: 844 })
|
|
await overflow("false", "false")
|
|
await view.search.fill("zzzz ".repeat(30))
|
|
await view.settings.getByRole("button", { name: "Clear", exact: true }).click()
|
|
await expect(view.search).toHaveValue("")
|
|
await expect(view.search).toBeFocused()
|
|
await overflow("false", "false")
|
|
})
|
|
|
|
test("a search result reveal highlights once and cleans up after it finishes", async ({ page }) => {
|
|
const view = await open(page)
|
|
await view.settings.evaluate((root) => {
|
|
root.setAttribute("data-search-flashes", "0")
|
|
root.addEventListener("animationstart", (event) => {
|
|
if (!(event instanceof AnimationEvent) || event.animationName !== "settings-search-reveal") return
|
|
root.setAttribute("data-search-flashes", String(Number(root.getAttribute("data-search-flashes")) + 1))
|
|
})
|
|
})
|
|
await view.search.fill("skills")
|
|
await view.results.getByRole("option").click()
|
|
await expect(view.settings.getByRole("tab", { name: "Skills", exact: true })).toHaveAttribute("aria-selected", "true")
|
|
await expect(view.settings).toHaveAttribute("data-search-flashes", "1")
|
|
await view.settings.evaluate((root) =>
|
|
Promise.all(
|
|
root
|
|
.getAnimations({ subtree: true })
|
|
.filter(
|
|
(animation) => animation instanceof CSSAnimation && animation.animationName === "settings-search-reveal",
|
|
)
|
|
.map((animation) => animation.finished),
|
|
),
|
|
)
|
|
await expect(view.settings.locator("[data-search-target]")).toHaveCount(0)
|
|
|
|
for (const tab of ["MCPs", "Skills"]) {
|
|
await view.settings.getByRole("tab", { name: tab, exact: true }).click()
|
|
await expect(view.settings.getByRole("tab", { name: tab, exact: true })).toHaveAttribute("aria-selected", "true")
|
|
}
|
|
|
|
await expect(view.settings.locator("[data-search-target]")).toHaveCount(0)
|
|
await expect(view.settings).toHaveAttribute("data-search-flashes", "1")
|
|
})
|
|
|
|
test("Models and Shortcuts leave focus on navigation until the user types", async ({ page }) => {
|
|
const view = await open(page)
|
|
|
|
for (const entry of [
|
|
{ tab: "Models", search: "Search models" },
|
|
{ tab: "Shortcuts", search: "Search shortcuts" },
|
|
]) {
|
|
await view.settings.getByRole("tab", { name: entry.tab, exact: true }).click()
|
|
await expect(view.settings.getByRole("searchbox", { name: entry.search, exact: true })).not.toBeFocused()
|
|
}
|
|
|
|
const search = view.settings.getByRole("searchbox", { name: "Search shortcuts", exact: true })
|
|
await page.keyboard.press("e")
|
|
await expect(search).toBeFocused()
|
|
await page.keyboard.type("verything")
|
|
await expect(search).toHaveValue("everything")
|
|
await expect(view.settings.getByText("Search everything", { exact: true })).toBeVisible()
|
|
})
|
|
|
|
test("section search takes typed input, clears in place, and escapes in steps", async ({ page }) => {
|
|
const view = await open(page, { count: 8 })
|
|
await view.settings.getByRole("tab", { name: "Projects", exact: true }).click()
|
|
const field = view.settings.locator('[data-component="settings-filter-search"]')
|
|
const search = field.getByRole("searchbox", { name: "Search projects", exact: true })
|
|
await expect(search).not.toBeFocused()
|
|
|
|
await page.keyboard.type("missing-project")
|
|
await expect(search).toBeFocused()
|
|
await expect(search).toHaveValue("missing-project")
|
|
await expect(view.settings.getByText('No results for "missing-project"', { exact: true })).toBeVisible()
|
|
await field.getByRole("button", { name: "Clear", exact: true }).click()
|
|
await expect(search).toHaveValue("")
|
|
await expect(search).toBeFocused()
|
|
|
|
await search.fill("missing-project")
|
|
await search.press("Escape")
|
|
await expect(search).toHaveValue("")
|
|
await expect(search).toBeFocused()
|
|
await search.press("Escape")
|
|
await expect(search).not.toBeFocused()
|
|
await expect(view.settings).toBeFocused()
|
|
await page.keyboard.press("Escape")
|
|
await expect(view.settings).toBeHidden()
|
|
await expect(page).toHaveURL("/")
|
|
})
|
|
|
|
for (const count of [0, 7, 8]) {
|
|
test(`Projects search appears from 8 added projects (${count} projects)`, async ({ page }) => {
|
|
const view = await open(page, {
|
|
count,
|
|
seed: { usedProjects: { local: Array.from({ length: count }, (_, index) => `proj_search_${index}`) } },
|
|
})
|
|
|
|
await view.settings.getByRole("tab", { name: "Projects", exact: true }).click()
|
|
const search = view.settings.getByRole("searchbox", { name: "Search projects", exact: true })
|
|
const projects = view.settings.getByRole("button", { name: /^OpenCode / })
|
|
|
|
if (count === 0) {
|
|
await expect(view.settings.getByText("No projects yet", { exact: true })).toBeVisible()
|
|
await view.settings.getByRole("button", { name: "Add project", exact: true }).click()
|
|
const picker = page.getByRole("dialog", { name: "Open project", exact: true })
|
|
await expect(picker).toBeVisible()
|
|
await picker.getByRole("button", { name: "Cancel", exact: true }).click()
|
|
await expect(picker).toBeHidden()
|
|
|
|
return
|
|
}
|
|
|
|
await expect(projects).toHaveCount(count)
|
|
|
|
if (count === 7) {
|
|
await expect(search).toHaveCount(0)
|
|
|
|
return
|
|
}
|
|
|
|
await search.fill(" CODE 06 ")
|
|
await expect(projects).toHaveCount(1)
|
|
await expect(projects).toHaveAccessibleName("OpenCode 06")
|
|
await search.fill("missing-project")
|
|
await expect(projects).toHaveCount(0)
|
|
await view.settings.getByRole("button", { name: "Clear", exact: true }).click()
|
|
await expect(projects).toHaveCount(count)
|
|
await search.fill("OpenCode 06")
|
|
await projects.click()
|
|
await expect(view.settings.getByRole("heading", { name: "OpenCode 06", exact: true })).toBeVisible()
|
|
})
|
|
}
|
|
|
|
test("all indexed client controls resolve to visible production controls", async ({ page }) => {
|
|
const view = await open(page)
|
|
|
|
for (const entry of clientSettings.filter((entry) => entry.target && !entry.available)) {
|
|
// SAFETY: catalog labels are typed as i18n keys, and English holds every key.
|
|
await view.search.fill(en[entry.label as keyof typeof en])
|
|
const result = view.results.locator(`[data-setting-target="${entry.target}"]`)
|
|
await expect(result).toHaveCount(1)
|
|
await result.click()
|
|
await expect(view.settings.locator(`[data-action="${entry.target}"]`)).toBeInViewport()
|
|
}
|
|
})
|
|
|
|
test("project results keep the query, selection, and scroll position on return", async ({ page }) => {
|
|
const view = await open(page, { count: 30 })
|
|
await view.search.fill("OpenCode 25 name")
|
|
const name = view.results.getByRole("option")
|
|
await expect(name).toHaveText("Project nameGeneral")
|
|
await name.click()
|
|
await expect(view.search).toHaveCount(0)
|
|
await expect(view.settings.getByRole("textbox", { name: "Project name", exact: true })).toHaveValue("OpenCode 25")
|
|
await page.keyboard.press("Escape")
|
|
await expect(view.search).toBeFocused()
|
|
await expect(view.search).toHaveValue("OpenCode 25 name")
|
|
await expect(name).toHaveAttribute("aria-selected", "true")
|
|
|
|
await view.search.fill("OpenCode")
|
|
await expect(view.results.getByRole("option")).toHaveCount(30)
|
|
const target = view.results.getByRole("option", { name: /^OpenCode 25,/ })
|
|
await target.scrollIntoViewIfNeeded()
|
|
await expect.poll(() => view.viewport.evaluate((list) => list.scrollTop)).toBeGreaterThan(0)
|
|
const scroll = await view.viewport.evaluate((list) => list.scrollTop)
|
|
await target.click()
|
|
await expect(view.settings.getByRole("heading", { name: "OpenCode 25", exact: true })).toBeVisible()
|
|
await view.settings.getByRole("button", { name: "Back to settings", exact: true }).click()
|
|
await expect(view.search).toBeFocused()
|
|
await expect(target).toHaveAttribute("aria-selected", "true")
|
|
await expect.poll(() => view.viewport.evaluate((list) => list.scrollTop)).toBe(scroll)
|
|
})
|
|
|
|
test("a page reached through an opened result keeps its own way back", async ({ page }) => {
|
|
const view = await open(page)
|
|
await view.search.fill("Projects")
|
|
await view.results.getByRole("option", { name: "Projects, This computer", exact: true }).click()
|
|
await expect(view.settings.getByRole("heading", { name: "Projects", exact: true })).toBeVisible()
|
|
await view.settings.getByRole("button", { name: "OpenCode", exact: true }).click()
|
|
await expect(view.settings.getByRole("heading", { name: "OpenCode", exact: true })).toBeVisible()
|
|
await expect(view.settings.getByRole("button", { name: "Back to projects", exact: true })).toBeVisible()
|
|
// Escape leaves the project for its own parent, not for the page the search started on.
|
|
await page.keyboard.press("Escape")
|
|
await expect(view.settings.getByRole("heading", { name: "Projects", exact: true })).toBeVisible()
|
|
await expect(view.search).toHaveValue("Projects")
|
|
|
|
// A Command Palette jump reveals its setting without a way back to a search.
|
|
const key = await page.evaluate(() =>
|
|
/Mac|iPhone|iPad|iPod/.test(navigator.platform) ? "Meta+Shift+P" : "Control+Shift+P",
|
|
)
|
|
|
|
await page.keyboard.press(key)
|
|
const palette = page.getByRole("dialog")
|
|
await palette.getByRole("combobox").fill("OpenCode name")
|
|
await palette.getByRole("option", { name: /^Project name/ }).click()
|
|
await expect(view.settings.getByRole("textbox", { name: "Project name", exact: true })).toHaveValue("OpenCode")
|
|
await expect(view.settings.locator('[data-search-target="row"]')).toContainText("Project name")
|
|
await expect(view.settings.getByRole("button", { name: "Back to projects", exact: true })).toBeVisible()
|
|
})
|
|
|
|
test("project edits queued behind a save reach their project in order across jumps away and back", async ({ page }) => {
|
|
const view = await open(page, { count: 2 })
|
|
await view.search.fill("OpenCode 00 name")
|
|
await view.results.getByRole("option").click()
|
|
const name = view.settings.getByRole("textbox", { name: "Project name", exact: true })
|
|
await expect(name).toHaveValue("OpenCode 00")
|
|
const hold = await holdRoute(page, /\/api\/project\/proj_search_\d+(\?|$)/, { method: "PATCH" })
|
|
|
|
await name.fill("Renamed")
|
|
await name.blur()
|
|
await hold.arrived
|
|
const startup = view.settings.getByRole("textbox", { name: "Worktree startup script", exact: true })
|
|
await startup.fill("bun dev")
|
|
await startup.blur()
|
|
|
|
const key = await page.evaluate(() =>
|
|
/Mac|iPhone|iPad|iPod/.test(navigator.platform) ? "Meta+Shift+P" : "Control+Shift+P",
|
|
)
|
|
|
|
const jump = async (query: string, value: string) => {
|
|
await page.keyboard.press(key)
|
|
const palette = page.getByRole("dialog")
|
|
await palette.getByRole("combobox").fill(query)
|
|
await palette.getByRole("option", { name: /^Project name/ }).click()
|
|
await expect(name).toHaveValue(value)
|
|
}
|
|
|
|
const sent = (projectID: string) =>
|
|
hold.requests
|
|
.filter((request) => new URL(request.url()).pathname === `/api/project/${projectID}`)
|
|
.map((request) => request.postDataJSON())
|
|
|
|
await jump("OpenCode 01 name", "OpenCode 01")
|
|
|
|
// Another project's save does not wait behind the first project's held one.
|
|
await name.fill("Bravo")
|
|
await name.blur()
|
|
await expect.poll(() => sent("proj_search_1")).toEqual([{ name: "Bravo" }])
|
|
|
|
// Back on the first project before its queued edit went out, a new save must not overtake it.
|
|
await jump("OpenCode 00 name", "OpenCode 00")
|
|
await startup.fill("bun start")
|
|
await startup.blur()
|
|
hold.release()
|
|
|
|
await expect
|
|
.poll(() => sent("proj_search_0"))
|
|
.toEqual([{ name: "Renamed" }, { commands: { start: "bun dev" } }, { commands: { start: "bun start" } }])
|
|
})
|
|
|
|
test("IME confirmation does not activate a search result", async ({ page }) => {
|
|
const view = await open(page)
|
|
await view.search.fill("font")
|
|
await expect(view.results.getByRole("option")).toHaveCount(3)
|
|
await view.search.dispatchEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true })
|
|
await expect(view.settings.getByRole("heading", { name: "Preferences", exact: true })).toBeVisible()
|
|
await view.search.press("Enter")
|
|
await expect(view.settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
|
|
})
|
|
|
|
test("multi-server results follow the selected server and keep the query on return", async ({ page }) => {
|
|
await mockOpenCodeServer(page, {
|
|
server: REMOTE_SERVER,
|
|
directory: "/remote/opencode",
|
|
project: project({ id: "proj_search_remote", directory: "/remote/opencode", name: "Remote app" }),
|
|
provider: NO_PROVIDER,
|
|
sessions: [],
|
|
pageMessages: () => ({ items: [] }),
|
|
})
|
|
|
|
const view = await open(page, {
|
|
seed: {
|
|
servers: [{ url: REMOTE_SERVER, name: "Build server" }],
|
|
},
|
|
})
|
|
|
|
await view.search.fill("Remote app")
|
|
await expect(view.results.getByRole("option")).toHaveCount(0)
|
|
await view.search.fill("MCPs")
|
|
await expect(view.results.getByRole("option")).toHaveCount(1)
|
|
await view.search.clear()
|
|
await view.settings.getByRole("tab", { name: "Providers", exact: true }).click()
|
|
await view.settings.getByRole("button", { name: "Server This computer", exact: true }).click()
|
|
await page.getByRole("menuitemradio", { name: "Build server", exact: true }).click()
|
|
|
|
await view.search.fill("MCPs")
|
|
await view.results.getByRole("option", { name: "MCPs, Build server, Extensions", exact: true }).click()
|
|
await expect(view.settings.getByRole("button", { name: "Server Build server", exact: true })).toBeVisible()
|
|
await expect(view.settings.getByRole("tab", { name: "MCPs", exact: true })).toHaveAttribute("aria-selected", "true")
|
|
await view.search.fill("Remote app name")
|
|
await expect(view.results.getByRole("option")).toHaveCount(1)
|
|
await view.results.getByRole("option").click()
|
|
await expect(view.settings.getByRole("textbox", { name: "Project name", exact: true })).toHaveValue("Remote app")
|
|
})
|