Files
reverse-engineering-anything/tests/boundary/browser/cdpScreenshotDocumentIdentity.test.ts
T

914 lines
29 KiB
TypeScript

import { crc32 } from "node:zlib";
import { describe, expect, it, onTestFinished } from "vitest";
import { CdpBrowserProvider } from "../../../src/browser/CdpBrowserProvider.js";
import { captureWebScreenshotInputSchema } from "../../../src/domain/webScreenshot.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import {
startFakeCdpBrowser,
type FakeOptions,
} from "../../fixtures/fakeCdpBrowser.js";
import { frameNavigated } from "./cdpBrowserProvider.support.js";
const captureWithFake = async (options: FakeOptions) => {
const browser = await startFakeCdpBrowser(options);
onTestFinished(() => browser.close());
const result = await new CdpBrowserProvider().captureScreenshot(
captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
}),
);
return { browser, result };
};
// These wire tests validate PNG headers; actual rendering has its own browser lane.
const screenshotData = (width: number, height: number) => {
const bytes = Buffer.from(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
"base64",
);
bytes.writeUInt32BE(width, 16);
bytes.writeUInt32BE(height, 20);
bytes.writeUInt32BE(crc32(bytes.subarray(12, 29)), 29);
return { data: bytes.toString("base64") };
};
const withCssViewport = (metrics: Readonly<Record<string, unknown>>) => ({
...metrics,
cssVisualViewport: metrics.visualViewport,
});
describe("screenshot authorization during metrics reads", () => {
it("stops at either metrics read when navigation invalidates capture", async () => {
const viewport = {
pageX: 0,
pageY: 0,
clientWidth: 2,
clientHeight: 2,
scale: 1,
};
const beforeAndAfter = [
{ read: 1, captures: 0 },
{ read: 2, captures: 1 },
];
const foreign = "https://outside.test/";
const scenarios = [
...beforeAndAfter.flatMap((phase) => [
{
...phase,
url: foreign,
identity: { id: "frame-main", loaderId: "outside-loader" },
reason: "target_changed",
},
{
...phase,
url: foreign,
identity: { id: "frame-main" },
reason: "target_not_allowed",
},
]),
{
read: 1,
captures: 0,
identity: { id: "frame-main", loaderId: "new-loader" },
reason: "target_changed",
},
{
read: 1,
captures: 0,
identity: { id: "candidate-root", parentId: "candidate-root" },
reason: "protocol_error",
},
] as const;
let scenario: (typeof scenarios)[number] | undefined;
let reads = 0;
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["Page.getLayoutMetrics"],
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? withCssViewport({ visualViewport: viewport })
: undefined,
commandEvents: (command, origin) =>
command.method === "Page.getLayoutMetrics" &&
scenario !== undefined &&
++reads === scenario.read
? [
frameNavigated(command, {
...scenario.identity,
url:
"url" in scenario
? scenario.url
: `${origin}/app?token=frame-secret`,
}),
]
: undefined,
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
try {
for (const transition of scenarios) {
scenario = transition;
reads = 0;
const label = `metrics read ${transition.read}: ${JSON.stringify(transition.identity)}`;
const before = browser.commands.length;
expect(await provider.captureScreenshot(input), label).toMatchObject({
ok: false,
error: { reason: transition.reason },
});
expect(
browser.commands
.slice(before)
.filter(({ method }) => method === "Page.captureScreenshot"),
label,
).toHaveLength(transition.captures);
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
}
} finally {
await provider.close();
}
});
});
describe("screenshot initial root identity", () => {
it("requires a valid, authorized root before measuring or capturing even with a readable child", async () => {
const invalidRoots = [
{ label: "missing ID", identity: {} },
{ label: "wrong ID type", identity: { id: 7 } },
{ label: "empty ID", identity: { id: "" } },
{
label: "parented root",
identity: { id: "frame-main", parentId: "parent" },
},
{
label: "malformed parent",
identity: { id: "frame-main", parentId: null },
},
{
label: "self parent",
identity: { id: "frame-main", parentId: "frame-main" },
},
];
let identity: Readonly<Record<string, unknown>> = {};
let foreign = false;
const browser = await startFakeCdpBrowser({
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
...identity,
url: foreign
? "https://outside.example/page"
: `${origin}/app?token=frame-secret`,
},
childFrames: [
{
frame: {
id: "frame-child",
parentId: "frame-main",
url: `${origin}/child`,
},
},
],
},
}
: undefined,
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
try {
const refusal = {
code: "target_unavailable",
message: expect.stringContaining(
"outside the permitted HTTP(S) origin scope",
),
remediation: { action: expect.stringContaining("allowed_origins") },
details: { reason: "target_not_allowed" },
};
const cases = [
...invalidRoots.map((row) => ({
...row,
foreign: false,
expected: {
code: "unreadable_output",
details: { reason: "protocol_error" },
},
})),
{
label: "foreign root",
identity: { id: "frame-main", loaderId: "loader-main" },
foreign: true,
expected: refusal,
},
{
label: "foreign root with malformed ID",
identity: { id: 7 },
foreign: true,
expected: refusal,
},
];
for (const invalid of cases) {
identity = invalid.identity;
foreign = invalid.foreign;
const before = browser.commands.length;
const result = await provider.captureScreenshot(input);
if (result.ok) throw new Error(`Expected refusal for ${invalid.label}`);
expect(projectAnalysisError(result.error), invalid.label).toMatchObject(
invalid.expected,
);
const methods = browser.commands
.slice(before)
.map(({ method }) => method);
expect(methods, invalid.label).not.toContain("Page.getLayoutMetrics");
expect(methods, invalid.label).not.toContain("Page.captureScreenshot");
}
foreign = false;
identity = { id: "frame-main", loaderId: "loader-main" };
const valid = await provider.captureScreenshot(input);
if (!valid.ok) throw valid.error;
expect(valid.value.target).toMatchObject({
target_id: "allowed-page",
url: `${browser.allowedOrigin}/app?token=frame-secret`,
});
expect(valid.value.viewport).toEqual({ width: 1, height: 1 });
} finally {
await provider.close();
}
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
});
});
describe("screenshot viewport freshness", () => {
it.each([
{ phase: "normal capture", imageSize: 4 },
{ phase: "before recovery", imageSize: 1 },
])("rejects scrolling $phase without retrying", async ({ imageSize }) => {
let reads = 0;
const { browser, result } = await captureWithFake({
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? withCssViewport({
visualViewport: {
pageX: 0,
pageY: ++reads === 1 ? 0 : 50,
clientWidth: 4,
clientHeight: 4,
scale: 1,
},
})
: method === "Page.captureScreenshot"
? screenshotData(imageSize, imageSize)
: undefined,
});
expect(result).toMatchObject({
ok: false,
error: {
reason: "target_changed",
detail: expect.stringContaining("visual viewport changed"),
},
});
expect(
browser.commands.filter(
({ method }) => method === "Page.captureScreenshot",
),
).toHaveLength(1);
});
it("rejects independently changed CSS size, zoom, and pixel dimensions during recovery", async () => {
const base = {
pageX: 0,
pageY: 0,
clientWidth: 4,
clientHeight: 4,
scale: 1,
};
const changes = [
{ label: "CSS width", css: { clientWidth: 8 }, pixels: {} },
{ label: "page zoom", css: { scale: 2 }, pixels: { scale: 2 } },
{ label: "pixel width", css: {}, pixels: { clientWidth: 8 } },
{ label: "pixel height", css: {}, pixels: { clientHeight: 8 } },
];
let change: (typeof changes)[number] | undefined;
let metricsReads = 0;
let captures = 0;
const browser = await startFakeCdpBrowser({
commandResult: ({ method }) => {
if (method === "Page.getLayoutMetrics") {
const current = ++metricsReads >= 3 ? change : undefined;
return {
cssVisualViewport: { ...base, ...current?.css },
visualViewport: { ...base, ...current?.pixels },
};
}
if (method === "Page.captureScreenshot")
return ++captures === 1
? screenshotData(1, 1)
: screenshotData(16, 16);
return undefined;
},
});
onTestFinished(() => browser.close());
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
const provider = new CdpBrowserProvider();
try {
for (const scenario of changes) {
change = scenario;
metricsReads = 0;
captures = 0;
expect(
await provider.captureScreenshot(input),
scenario.label,
).toMatchObject({
ok: false,
error: {
reason: "target_changed",
detail: expect.stringContaining("visual viewport changed"),
},
});
expect(captures, scenario.label).toBe(2);
}
} finally {
await provider.close();
}
});
});
it("uses CSS clip coordinates and scaled device-pixel dimensions for clipped recovery", async () => {
let captures = 0;
const recovered = screenshotData(2560, 1440);
const { browser, result } = await captureWithFake({
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? {
cssVisualViewport: {
pageX: 12,
pageY: 34,
clientWidth: 640,
clientHeight: 360,
scale: 2,
},
visualViewport: {
pageX: 24,
pageY: 68,
clientWidth: 1280,
clientHeight: 720,
scale: 2,
},
}
: method === "Page.captureScreenshot"
? ++captures === 1
? screenshotData(1280, 720)
: recovered
: undefined,
});
if (!result.ok) throw result.error;
const screenshots = browser.commands.filter(
({ method }) => method === "Page.captureScreenshot",
);
expect(screenshots).toHaveLength(2);
expect(screenshots[0]?.params).toMatchObject({
captureBeyondViewport: false,
});
expect(screenshots[0]?.params).not.toHaveProperty("clip");
expect(screenshots[1]?.params).toMatchObject({
fromSurface: true,
captureBeyondViewport: true,
clip: { x: 12, y: 34, width: 640, height: 360, scale: 2 },
});
expect(result.value.viewport).toEqual({ width: 2560, height: 1440 });
expect(result.value.artifact.data_base64).toBe(recovered.data);
});
describe("screenshot surface compatibility", () => {
it("preserves an original high-density surface including pixels outside the visual viewport", async () => {
const image = screenshotData(1295, 735);
const cssViewport = {
pageX: 0,
pageY: 0,
clientWidth: 640,
clientHeight: 360,
scale: 1,
};
const { browser, result } = await captureWithFake({
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? {
cssVisualViewport: cssViewport,
visualViewport: {
...cssViewport,
clientWidth: 1280,
clientHeight: 720,
},
}
: method === "Page.captureScreenshot"
? image
: undefined,
});
if (!result.ok) throw result.error;
expect(result.value.viewport).toEqual({ width: 1295, height: 735 });
expect(result.value.artifact.data_base64).toBe(image.data);
expect(
browser.commands.filter(
({ method }) => method === "Page.captureScreenshot",
),
).toHaveLength(1);
});
it("refuses a clipped recovery that still omits visible content", async () => {
const { browser, result } = await captureWithFake({
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? withCssViewport({
visualViewport: {
pageX: 0,
pageY: 0,
clientWidth: 2,
clientHeight: 2,
scale: 1,
},
})
: undefined,
});
expect(result).toMatchObject({
ok: false,
error: { reason: "protocol_error" },
});
expect(
browser.commands.filter(
({ method }) => method === "Page.captureScreenshot",
),
).toHaveLength(2);
});
it("does not retry a cropped surface after the target leaves scope", async () => {
const { browser, result } = await captureWithFake({
navigateDuringScreenshotUrl: "https://outside.test/",
commandResult: ({ method }) =>
method === "Page.getLayoutMetrics"
? withCssViewport({
visualViewport: {
pageX: 0,
pageY: 0,
clientWidth: 2,
clientHeight: 2,
scale: 1,
},
})
: undefined,
});
expect(result).toMatchObject({
ok: false,
error: { reason: "target_not_allowed" },
});
expect(
browser.commands.filter(
({ method }) => method === "Page.captureScreenshot",
),
).toHaveLength(1);
});
});
it("rejects malformed viewport metrics at the relevant field before capture can proceed", async () => {
const viewport = {
pageX: 0,
pageY: 0,
clientWidth: 2,
clientHeight: 2,
scale: 1,
};
const valid = withCssViewport({ visualViewport: viewport });
const scenarios = [
{ read: 1, reply: {}, pointer: "/visualViewport", captures: 0 },
{
read: 1,
reply: { ...valid, cssVisualViewport: { ...viewport, pageX: null } },
pointer: "/cssVisualViewport/pageX",
captures: 0,
},
{
read: 1,
reply: { ...valid, visualViewport: { ...viewport, clientWidth: 0 } },
pointer: "/visualViewport/clientWidth",
captures: 0,
},
{
read: 1,
reply: { ...valid, cssVisualViewport: { ...viewport, scale: 0 } },
pointer: "/cssVisualViewport/scale",
captures: 0,
},
{
read: 2,
reply: { visualViewport: viewport },
pointer: "/cssVisualViewport",
captures: 1,
},
{
read: 3,
reply: { ...valid, visualViewport: { ...viewport, scale: null } },
pointer: "/visualViewport/scale",
captures: 2,
},
] as const;
let scenario: (typeof scenarios)[number] = scenarios[0];
let reads = 0;
const browser = await startFakeCdpBrowser({
commandResult: ({ method, params }) => {
if (method === "Page.getLayoutMetrics")
return ++reads === scenario.read ? scenario.reply : valid;
if (method === "Page.captureScreenshot") {
const size = params.clip === undefined ? 1 : 2;
return screenshotData(size, size);
}
return undefined;
},
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
const screenshotCount = () =>
browser.commands.filter(({ method }) => method === "Page.captureScreenshot")
.length;
try {
for (const invalid of scenarios) {
scenario = invalid;
reads = 0;
const before = screenshotCount();
const label = `metrics reply ${invalid.read} at ${invalid.pointer}`;
expect(await provider.captureScreenshot(input), label).toMatchObject({
ok: false,
error: {
reason: "protocol_error",
command: "Page.getLayoutMetrics",
pointer: invalid.pointer,
},
});
expect(screenshotCount() - before, label).toBe(invalid.captures);
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
}
} finally {
await provider.close();
}
});
it("rejects unreadable and self-parented root navigation before retrying a cropped screenshot", async () => {
const viewport = {
pageX: 0,
pageY: 0,
clientWidth: 2,
clientHeight: 2,
scale: 1,
};
const cases = ["unreadable event", "self-parented root"] as const;
let scenario: (typeof cases)[number] = cases[0];
let captures = 0;
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["Page.captureScreenshot"],
commandResult: ({ method }) => {
if (method === "Page.getLayoutMetrics")
return withCssViewport({ visualViewport: viewport });
if (method === "Page.captureScreenshot") captures += 1;
return undefined;
},
commandEvents: (command, origin) => {
if (command.method !== "Page.captureScreenshot") return undefined;
if (scenario === "unreadable event")
return [
{
method: "Page.frameNavigated",
...(command.sessionId === undefined
? {}
: { sessionId: command.sessionId }),
params: undefined,
},
];
return [
frameNavigated(command, {
id: "candidate-root",
parentId: "candidate-root",
url: `${origin}/app`,
}),
];
},
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
try {
for (const invalid of cases) {
scenario = invalid;
captures = 0;
expect(await provider.captureScreenshot(input), invalid).toMatchObject({
ok: false,
error: { reason: "protocol_error" },
});
expect(captures, invalid).toBe(1);
await expect
.poll(() => browser.activeConnectionCount(), { message: invalid })
.toBe(0);
}
} finally {
await provider.close();
}
});
it("preserves the screenshot when navigation events leave the selected document unchanged", async () => {
const image = screenshotData(1, 1);
const { result } = await captureWithFake({
extraCollections: true,
eventsBeforeReply: ["Page.captureScreenshot"],
commandResult: ({ method }) =>
method === "Page.captureScreenshot" ? image : undefined,
commandEvents: (command, origin) => {
if (command.method !== "Page.captureScreenshot") return undefined;
const sessionId = command.sessionId;
const selectedUrl = `${origin}/app?token=frame-secret`;
const outside = "https://outside.invalid/";
return [
...["frame-main", "frame-child"].map((frameId) => ({
method: "Page.frameRequestedNavigation",
sessionId,
params: {
frameId,
url: outside,
reason: "scriptInitiated",
disposition: "currentTab",
},
})),
{
method: "Page.navigatedWithinDocument",
sessionId,
params: {
frameId: "frame-main",
url: selectedUrl,
navigationType: "historyApi",
},
},
{
method: "Page.navigatedWithinDocument",
sessionId,
params: {
frameId: "frame-child",
url: `${outside}child`,
navigationType: "historyApi",
},
},
frameNavigated(command, {
id: "frame-main",
loaderId: "loader-main",
url: selectedUrl,
}),
{
method: "Runtime.consoleAPICalled",
sessionId,
params: {
type: "log",
args: [],
executionContextId: 1,
timestamp: 1,
},
},
{
method: "Page.lifecycleEvent",
sessionId,
params: {
frameId: "frame-main",
loaderId: "loader-main",
name: "DOMContentLoaded",
timestamp: 1,
},
},
{
method: "Runtime.consoleAPICalled",
sessionId,
params: { frameId: "frame-main", args: "not-an-array" },
},
frameNavigated(command, {
id: 7,
parentId: "frame-main",
url: `${outside}malformed-child`,
}),
];
},
});
if (!result.ok) throw result.error;
expect(result.value.artifact.data_base64).toBe(image.data);
expect(result.value.completeness.excluded).toEqual([
{ section: "screenshot", reason: "invalid_protocol_value", count: 1 },
]);
expect(result.value.completeness.attach_limited_sections).toEqual([]);
});
it("rejects a changed root frame or loader even when the screenshot URL is unchanged", async () => {
const replacements = [
{ id: "replacement-main", loaderId: "loader-main" },
{ id: "frame-main", loaderId: "loader-reloaded" },
] as const;
let replacement: (typeof replacements)[number] = replacements[0];
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["Page.captureScreenshot"],
commandEvents: (command, origin) =>
command.method === "Page.captureScreenshot"
? [
frameNavigated(command, {
...replacement,
url: `${origin}/app?token=frame-secret`,
}),
]
: undefined,
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
try {
for (const changed of replacements) {
replacement = changed;
const before = browser.commands.length;
expect(
await provider.captureScreenshot(input),
JSON.stringify(changed),
).toMatchObject({
ok: false,
error: { reason: "target_changed" },
});
expect(
browser.commands
.slice(before)
.filter(({ method }) => method === "Page.getFrameTree"),
).toHaveLength(1);
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
}
} finally {
await provider.close();
}
});
it("separates unreadable screenshot document URLs from known scope loss at each capture phase", async () => {
const phases = [
{ phase: "initial", captures: 0 },
{ phase: "event", captures: 1 },
{ phase: "final", captures: 1 },
] as const;
const invalidDocuments = [
{ source: "allowed", fragment: 7, reason: "protocol_error" },
{ source: "foreign", fragment: 7, reason: "target_not_allowed" },
{ source: "missing", reason: "protocol_error" },
] as const;
const scenarios = [
...phases.flatMap((phase) =>
invalidDocuments.map((document) => ({
...phase,
...document,
loader: "loader-main",
})),
),
{
phase: "event",
captures: 1,
source: "foreign",
fragment: 7,
reason: "target_changed",
loader: "new-loader",
},
] as const;
let scenario: (typeof scenarios)[number] | undefined;
let treeReads = 0;
const frame = (origin: string) => {
if (scenario === undefined) throw new Error("Missing screenshot scenario");
return {
id: "frame-main",
loaderId: scenario.loader,
...(scenario.source === "missing"
? {}
: {
url:
scenario.source === "foreign"
? "https://foreign.test/"
: `${origin}/app?token=frame-secret`,
urlFragment: scenario.fragment,
}),
};
};
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["Page.captureScreenshot"],
commandResult: ({ method }, origin) => {
if (method !== "Page.getFrameTree") return undefined;
treeReads += 1;
return (scenario?.phase === "initial" && treeReads === 1) ||
(scenario?.phase === "final" && treeReads === 2)
? { frameTree: { frame: frame(origin) } }
: undefined;
},
commandEvents: (command, origin) =>
scenario?.phase === "event" && command.method === "Page.captureScreenshot"
? [frameNavigated(command, frame(origin))]
: undefined,
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
try {
for (const invalid of scenarios) {
scenario = invalid;
treeReads = 0;
const before = browser.commands.length;
const label = `${invalid.phase}/${invalid.source}/${invalid.loader}`;
expect(await provider.captureScreenshot(input), label).toMatchObject({
ok: false,
error: { reason: invalid.reason },
});
expect(
browser.commands
.slice(before)
.filter(({ method }) => method === "Page.captureScreenshot"),
label,
).toHaveLength(invalid.captures);
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
}
} finally {
await provider.close();
}
});
it("rejects invalid screenshot replies without attempting a clipped capture", async () => {
let data: string | number = "";
const browser = await startFakeCdpBrowser({
commandResult: ({ method }) =>
method === "Page.captureScreenshot" ? { data } : undefined,
});
onTestFinished(() => browser.close());
const provider = new CdpBrowserProvider();
const input = captureWebScreenshotInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
});
const png = screenshotData(1, 1).data;
const invalidHeader = Buffer.from(png, "base64");
invalidHeader[0] = 0;
const screenshotCount = () =>
browser.commands.filter(({ method }) => method === "Page.captureScreenshot")
.length;
try {
const replies = [
{
label: "invalid data field",
data: 5,
detail: { command: "Page.captureScreenshot", pointer: "/data" },
},
// Keep the length divisible by four so this reaches the canonical byte check.
{ label: "noncanonical base64", data: ` ${png}` },
{ label: "invalid PNG header", data: invalidHeader.toString("base64") },
];
for (const invalid of replies) {
data = invalid.data;
const before = screenshotCount();
expect(
await provider.captureScreenshot(input),
invalid.label,
).toMatchObject({
ok: false,
error: { reason: "protocol_error", ...invalid.detail },
});
expect(screenshotCount() - before, invalid.label).toBe(1);
await expect
.poll(() => browser.activeConnectionCount(), { message: invalid.label })
.toBe(0);
}
} finally {
await provider.close();
}
});