import {
chromium,
type Browser,
type BrowserContext,
type CDPSession,
type Page,
} from "playwright-core";
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vite-plus/test";
import * as ServerBrowserPage from "./ServerBrowserPage.ts";
describe("server browser element refs", () => {
let browser: Browser;
let context: BrowserContext;
let page: Page;
let cdp: CDPSession;
beforeAll(async () => {
browser = await chromium.launch({ headless: true });
});
afterAll(async () => {
await browser?.close();
});
beforeEach(async () => {
context = await browser.newContext();
page = await context.newPage();
cdp = await context.newCDPSession(page);
});
afterEach(async () => {
await context.close();
});
const takeSnapshot = () =>
ServerBrowserPage.snapshot({
page,
cdp,
renderScale: 1,
consoleEntries: [],
networkEntries: [],
actionTimeline: [],
});
const locators = (tree: unknown) => {
expect(typeof tree).toBe("string");
return Array.from(
String(tree).matchAll(/\[ref=([^\]]+)\]/g),
(match) => `aria-ref=${match[1]}`,
);
};
const buttonLocator = (tree: unknown, name: string) => {
const line = String(tree)
.split("\n")
.find((line) => line.includes(`button "${name}"`));
const locator = locators(line)[0];
expect(locator).toBeDefined();
return locator!;
};
const repeatedRows = `<ul>${Array.from({ length: 5 }, (_, i) => `<li>row ${i + 1}<button data-testid="delete-row" onclick="this.parentElement.remove()">delete</button></li>`).join("")}</ul>`;
it("clicks the fifth repeated delete control without touching row one", async () => {
await page.setContent(repeatedRows);
const result = await takeSnapshot();
const buttons = String(result.accessibilityTree)
.split("\n")
.filter((line) => line.includes('button "delete"'));
expect(buttons).toHaveLength(5);
await ServerBrowserPage.click(page, { locator: locators(buttons[4])[0]!, timeoutMs: 1_000 });
expect(await page.locator("li").allTextContents()).toEqual([
"row 1delete",
"row 2delete",
"row 3delete",
"row 4delete",
]);
});
it("returns from a click once it opens a dialog", async () => {
await page.setContent(
`<button onclick="document.body.dataset.answer = String(confirm('sure?'))">Confirm</button>`,
);
const dialog = new Promise<import("playwright-core").Dialog>((resolve) =>
page.once("dialog", resolve),
);
await ServerBrowserPage.click(page, {
locator: buttonLocator((await takeSnapshot()).accessibilityTree, "Confirm"),
timeoutMs: 1_000,
});
await (await dialog).accept();
await expect.poll(() => page.locator("body").getAttribute("data-answer")).toBe("true");
});
it("rejects ambiguous CSS controls without clicking any row", async () => {
await page.setContent(repeatedRows);
await expect(
ServerBrowserPage.click(page, {
selector: 'button[data-testid="delete-row"]',
timeoutMs: 1_000,
}),
).rejects.toThrow(/strict mode violation/);
expect(await page.locator("li").count()).toBe(5);
});
it("tells a click target that matches nothing from one that never becomes clickable", async () => {
await page.setContent(`<button hidden>hidden</button>`);
const failure = (selector: string) =>
ServerBrowserPage.click(page, { selector, timeoutMs: 500 }).then(
() => expect.unreachable(),
ServerBrowserPage.toOperationError,
);
const absent = await failure(".definitely-no-such-t3-target");
expect(absent.tag).toBe("PreviewAutomationTimeoutError");
expect(absent.message).toBe(
'The click may have happened and removed its target or navigated; check the page before retrying. No element matches ".definitely-no-such-t3-target" after the timeout; take a fresh snapshot and use its locator.',
);
expect(absent.cause).toMatchObject({ name: "TimeoutError" });
const hidden = await failure("button");
expect(hidden.tag).toBe("PreviewAutomationTimeoutError");
expect(hidden.message).toBe(
'The click may have happened; check the page before retrying. "button" still matches an element after the timeout.',
);
});
it("does not retarget a removed ref to a replacement node", async () => {
await page.setContent("<button onclick=\"this.textContent='clicked'\">original</button>");
const locator = buttonLocator((await takeSnapshot()).accessibilityTree, "original");
await page.setContent("<button onclick=\"this.textContent='clicked'\">replacement</button>");
await expect(ServerBrowserPage.click(page, { locator, timeoutMs: 100 })).rejects.toThrow();
expect(await page.locator("button").textContent()).toBe("replacement");
});
it("targets iframe input refs and preserves the parent form", async () => {
await page.setContent(
'<input aria-label="parent"><iframe srcdoc="<input aria-label=child>"></iframe>',
);
await page.frameLocator("iframe").getByRole("textbox").waitFor();
const result = await takeSnapshot();
const line = String(result.accessibilityTree)
.split("\n")
.find((line) => line.includes('textbox "child"'));
const locator = locators(line)[0]!;
await ServerBrowserPage.type(page, { locator, text: "inside iframe", clear: true });
expect(await page.frameLocator("iframe").getByRole("textbox").inputValue()).toBe(
"inside iframe",
);
expect(await page.getByRole("textbox", { name: "parent" }).inputValue()).toBe("");
});
it("shows dotted fields as dots wherever their value appears, keeping text values and refs", async () => {
await page.setContent(`
<table><tr><td>password:</td><td><input id="pw" type="password" aria-label="Password"></td></tr></table>
<input aria-label="Username" value="maria">
<input type="password" aria-label='saved" [ref=e2]: x' placeholder="hint" value="saved-pass">
<input type="password" role="combobox" aria-label="Code" value="role-pass">
<input aria-label="PIN" style="-webkit-text-security: disc" value="styled-pass">
<div contenteditable style="-webkit-text-security: disc">editable-pass</div>
<iframe srcdoc="<input type=password aria-label=child value=frame-pass>"></iframe>
<iframe id="blank" src="javascript:false"></iframe>
<p>Order styled-pass-2</p>
<script>
// A frame that never commits a document, filled by its parent.
blank.contentDocument.body.innerHTML = "<input type=password aria-label=blank value=blank-pass>";
// Page script can't change the value the snapshot sees.
Object.defineProperty(HTMLInputElement.prototype, "value", { get: () => "" });
</script>`);
await page.frameLocator("iframe[srcdoc]").getByRole("textbox").waitFor();
await ServerBrowserPage.type(page, { locator: "#pw", text: "typed-pass" });
const result = await takeSnapshot();
const tree = String(result.accessibilityTree);
expect(tree).toContain('textbox "blank"');
expect(tree).not.toMatch(
/typed-pass|saved-pass|role-pass|styled-pass|editable-pass|frame-pass|blank-pass/,
);
expect(result.visibleText).not.toContain("editable-pass");
expect(result.visibleText).toContain("Order ••••••••-2");
expect(tree).toMatch(/row "password: •+"/);
expect(tree).toMatch(/textbox "Username" [^\n]*: maria$/m);
const line = tree.split("\n").find((line) => line.includes('textbox "Password"'));
expect(line).toMatch(/: •+$/);
await ServerBrowserPage.type(page, { locator: locators(line)[0]!, text: "next", clear: true });
expect(await page.locator("#pw").inputValue()).toBe("next");
});
it("masks dotted values in page text next to punctuation, with odd spaces, and at the cut", async () => {
await page.setContent(`
<input type="password" aria-label="PIN" value="123">
<input type="password" aria-label="Phrase" value="open sesame">
<p>PIN: 123. Code (123) id 1234</p>
<p>open sesame</p>`);
const text = (await takeSnapshot()).visibleText;
expect(text).toContain("PIN: ••••••••. Code (••••••••) id 1234");
expect(text).not.toMatch(/open|sesame/);
await page.setContent(`
<p>${"x".repeat(19_995)}long-secret</p>
<input type="password" aria-label="Long" value="long-secret">`);
const cut = (await takeSnapshot()).visibleText;
expect(cut.length).toBe(20_000);
expect(cut.slice(-8)).toBe("xxx•••••");
});
it("shows a data: link or blocked data: navigation by media type only", async () => {
// Chromium keeps raw spaces and quotes in both, so a payload can't be cut at either.
await page.setContent(`
<a download href="data:text/plain;charset="a,b",head PAYLOAD'tail">Key</a>
<a href="https://example.com/data:report,2026">Report</a>
<a href="#">data:text/plain,label</a>
<a href='"data:text/plain,relative'>Relative</a>
<a href=" data:text/plain,PAYLOAD">Spaced</a>
<a href="da	ta:text/plain,PAYLOAD">Tabbed</a>
<a href="data:text/plain,head
PAYLOAD">Separated</a>
<a href="data:PAYLOAD,x">Typeless</a>
<a href="data:text/plain,PAYLOAD">Vertical tab</a>
<a href="data:text/plain,PAYLOAD">Backspace</a>
<a id="controlled">Controlled</a>
<a id="escaped">Escaped</a>
<script>
controlled.href = "\\x01data:text/plain,PAYLOAD";
escaped.href = "\\x02da\\tta:text/plain,PAYLOAD";
</script>`);
const tree = String((await takeSnapshot()).accessibilityTree);
expect(tree.match(/\/url: data:text\/plain,…$/gm)).toHaveLength(8);
expect(tree).toContain("/url: data:,…");
expect(tree).toContain("/url: https://example.com/data:report,2026");
expect(tree).toMatch(/link "data:text\/plain,label" \[ref=t3-/);
expect(tree).not.toMatch(/PAYLOAD|tail|charset|\u2028/);
expect(tree).toContain('/url: "\\"data:text/plain,relative"');
});
it("redacts a data: link whose scheme a password value would mask", async () => {
await page.setContent(`
<input type="password" aria-label="Scheme" value="data">
<a download href="data:text/plain,PAYLOAD">Key</a>`);
const tree = String((await takeSnapshot()).accessibilityTree);
expect(tree).toContain("/url: ••••••••:text/plain,…");
expect(tree).not.toContain("PAYLOAD");
});
it("shows a data: page's own URL by media type only", async () => {
await page.goto("data:text/html,<title>Key</title>PAYLOAD");
expect((await takeSnapshot()).url).toBe("data:text/html,…");
});
it("rejects refs from another tab", async () => {
await page.setContent("<button>same label</button>");
const locator = buttonLocator((await takeSnapshot()).accessibilityTree, "same label");
const other = await context.newPage();
await other.setContent("<button>same label</button>");
await expect(ServerBrowserPage.click(other, { locator })).rejects.toThrow(/another tab/);
});
it("revokes refs after navigation even when labels are identical", async () => {
await page.goto("data:text/html,<button>continue</button>");
const locator = buttonLocator((await takeSnapshot()).accessibilityTree, "continue");
await page.goto("data:text/html,<button>continue</button><p>new document</p>");
await expect(ServerBrowserPage.click(page, { locator })).rejects.toThrow(/stale/);
});
it.each(["aria-ref=e1", " aria-ref=e1", "css=body >> aria-ref=e1"])(
"does not allow native refs to bypass generation validation (%s)",
async (locator) => {
await page.setContent("<button>continue</button>");
await takeSnapshot();
await expect(ServerBrowserPage.click(page, { locator })).rejects.toThrow(/stale/);
},
);
it("preserves quoted attribute values containing ref engine text", async () => {
await page.setContent(
'<button data-example=" >> aria-ref=e1" onclick="this.textContent=\'saved\'">save</button>',
);
await ServerBrowserPage.click(page, { selector: 'button[data-example=" >> aria-ref=e1"]' });
expect(await page.locator("button").textContent()).toBe("saved");
});
});
describe("server browser snapshot screenshot", () => {
let browser: Browser;
let context: BrowserContext;
beforeAll(async () => {
// ServerBrowserContexts launches with these, and the capture scale depends on them.
browser = await chromium.launch({
headless: true,
args: ["--disable-gpu", "--force-device-scale-factor=2"],
});
});
afterAll(async () => {
await browser?.close();
});
beforeEach(async () => {
context = await browser.newContext({
viewport: { width: 1280, height: 800 },
deviceScaleFactor: 2,
});
});
afterEach(async () => {
await context.close();
});
// Blue on the left half and red on the right, so a mirrored left half shows up on the right.
const halves = (overlay: string) => `
<style>
body { margin: 0; background: white; }
.half { position: absolute; top: 0; width: 640px; height: 800px; }
.overlay { position: fixed; inset: 0; ${overlay} }
</style>
<div class="half" style="left: 0; background: #2563eb"></div>
<div class="half" style="left: 640px; background: #ef4444"></div>
<div class="overlay"></div>`;
const screenshotOf = async (html: string) => {
const page = await context.newPage();
await page.setContent(html);
const { screenshot } = await ServerBrowserPage.snapshot({
page,
cdp: await context.newCDPSession(page),
renderScale: 2,
consoleEntries: [],
networkEntries: [],
actionTimeline: [],
});
// The server has no DOM types, so the decoder runs as page source.
const points = [
[0.15, 0.75],
[0.85, 0.25],
[0.85, 0.75],
];
const pixels = (await page.evaluate(`(async () => {
const bytes = Uint8Array.from(atob(${JSON.stringify(screenshot.data)}), (char) => char.charCodeAt(0));
const bitmap = await createImageBitmap(new Blob([bytes], { type: "image/png" }));
const canvas = document.createElement("canvas");
canvas.width = bitmap.width;
canvas.height = bitmap.height;
const context = canvas.getContext("2d");
context.drawImage(bitmap, 0, 0);
return ${JSON.stringify(points)}.map(([x, y]) =>
Array.from(context.getImageData(x * bitmap.width, y * bitmap.height, 1, 1).data),
);
})()`)) as Array<[number, number, number, number]>;
return { screenshot, pixels };
};
const colorOf = ([red, green, blue]: readonly [number, number, number, number]) =>
blue - red > 100 ? "blue" : red - blue > 100 ? "red" : `rgb(${red}, ${green}, ${blue})`;
it("captures a blurred backdrop-filter page as rendered, not mirrored", async () => {
const { screenshot, pixels } = await screenshotOf(halves("backdrop-filter: blur(4px);"));
expect({
size: [screenshot.width, screenshot.height],
colors: pixels.map(colorOf),
}).toEqual({ size: [1280, 800], colors: ["blue", "red", "red"] });
});
it("captures a plain page at the shrunk size with its content in place", async () => {
const { screenshot, pixels } = await screenshotOf(halves(""));
expect({
size: [screenshot.width, screenshot.height],
colors: pixels.map(colorOf),
}).toEqual({ size: [1280, 800], colors: ["blue", "red", "red"] });
});
it("shrinks the screenshot of an XML document, whose createElement makes no canvas", async () => {
const page = await context.newPage();
await page.goto("data:text/xml,<a/>");
const { screenshot } = await ServerBrowserPage.snapshot({
page,
cdp: await context.newCDPSession(page),
renderScale: 2,
consoleEntries: [],
networkEntries: [],
actionTimeline: [],
});
expect([screenshot.width, screenshot.height]).toEqual([1280, 800]);
});
});
describe("server browser drag", () => {
it("fails the drag, not the server, when it times out while the cursor is still moving", async () => {
const timedOut = new Error("locator.dragTo: Timeout 30000ms exceeded.");
const box = { x: 0, y: 0, width: 20, height: 20 };
const targetBox = Promise.withResolvers<typeof box>();
const page = {
locator: (selector: string) =>
selector === "#card"
? {
scrollIntoViewIfNeeded: async () => {},
boundingBox: async () => box,
dragTo: () => Promise.reject(timedOut),
}
: { boundingBox: () => targetBox.promise },
} as unknown as Page;
const unobserved: Array<unknown> = [];
const onUnhandled = (reason: unknown) => unobserved.push(reason);
process.on("unhandledRejection", onUnhandled);
try {
let finished = false;
const settled = ServerBrowserPage.drag(page, { source: "#card", target: "#lane" }).then(
() => null,
(error: unknown) => error,
);
void settled.then(() => (finished = true));
// Two macrotask turns: Node reports a rejection nobody observed after the first.
for (let turn = 0; turn < 2; turn++) {
// oxlint-disable-next-line t3code/no-real-time-wait-in-tests -- Node emits unhandledRejection only between macrotasks; no promise can mark that point.
await new Promise((resolve) => setImmediate(resolve));
}
expect(finished).toBe(false);
targetBox.resolve(box);
expect(await settled).toBe(timedOut);
expect(unobserved).toEqual([]);
} finally {
process.off("unhandledRejection", onUnhandled);
}
});
});
describe("server browser net errors", () => {
it.each([
["net::ERR_CONNECTION_REFUSED", "ERR_CONNECTION_REFUSED", -102],
[
"page.goto: net::ERR_HTTP2_PROTOCOL_ERROR at https://localhost:5173/",
"ERR_HTTP2_PROTOCOL_ERROR",
-2,
],
["net::ERR_TLS13_DOWNGRADE_DETECTED", "ERR_TLS13_DOWNGRADE_DETECTED", -2],
])("reads the whole error name from %j", (errorText, description, code) => {
expect(ServerBrowserPage.parseNetError(errorText)).toEqual({ description, code });
});
});