@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/browser/goto.browser-test.ts

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import { createServer, type Server } from "node:http";
-import type { AddressInfo, Socket } from "node:net";
-import { after, before, test } from "node:test";
-import { Browser } from "./browser.js";
-import type Page from "./page.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-const sockets = new Set<Socket>();
-
-before(async () => {
-  server = createServer((req, res) => {
-    res.setHeader("content-type", "text/html").end(`<!doctype html><title>${req.url}</title>`);
-  });
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.on("close", () => sockets.delete(socket));
-  });
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-  ({ browser, page } = await Browser.launch("firefox", { port: 9251, headless: true }, AbortSignal.timeout(30000)));
-});
-
-after(async () => {
-  try {
-    await page?.dispose().catch(() => {});
-    await browser?.close().catch(() => {});
-  } finally {
-    sockets.forEach((socket) => socket.destroy());
-    if (server) await new Promise((resolve) => server.close(resolve));
-  }
-});
-
-test("goto resolves a path against the base URL", { timeout: 40000 }, async () => {
-  page.setBaseURL(`${base}/shop/`);
-  await page.goto("/products?id=1");
-  assert.equal(await page.url(), `${base}/products?id=1`);
-  assert.equal(await page.title(), "/products?id=1");
-  await page.goto("./cart");
-  assert.equal(await page.url(), `${base}/shop/cart`);
-});

package/src/browser/navigation-error.ts

@@ -1,26 +0,0 @@
-import { WaitTimeoutError } from "../wait/wait-until.js";
-
-/** A navigation did not end in a loaded page */
-export class NavigationError extends Error {
-  public readonly url: string;
-  public readonly reason: string;
-  /** The BiDi error code, or "timeout" */
-  public readonly code: string | undefined;
-
-  constructor(url: string, reason: string, code?: string, operation = "navigateTo") {
-    super(`${operation}(): ${url} failed: ${reason}`);
-    this.name = "NavigationError";
-    this.url = url;
-    this.reason = reason;
-    this.code = code;
-  }
-}
-
-/** The page did not reach the awaited load state in time */
-export class LoadStateTimeoutError extends WaitTimeoutError<undefined> {
-  constructor(state: string, timeout: number) {
-    super(timeout, undefined);
-    this.name = "LoadStateTimeoutError";
-    this.message = `waitForLoadState("${state}") did not finish within ${timeout}ms`;
-  }
-}

package/src/browser/navigation.browser-test.ts

@@ -1,172 +0,0 @@
-import assert from "node:assert/strict";
-import { createServer, type Server } from "node:http";
-import type { AddressInfo, Socket } from "node:net";
-import { after, before, test } from "node:test";
-import { callFunction } from "../script/call-function.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { Browser } from "./browser.js";
-import { LoadStateTimeoutError, NavigationError } from "./navigation-error.js";
-import type Page from "./page.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-const sockets = new Set<Socket>();
-
-const GIF = Buffer.from("R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==", "base64");
-
-before(async () => {
-  server = createServer((req, res) => {
-    const url = new URL(req.url ?? "/", "http://localhost");
-    switch (url.pathname) {
-      case "/late": // DOMContentLoaded at once, load only after the slow image
-        res.setHeader("content-type", "text/html").end('<!doctype html><body>late<img src="/img?ms=700"></body>');
-        break;
-      case "/img":
-        setTimeout(() => res.setHeader("content-type", "image/gif").end(GIF), Number(url.searchParams.get("ms")));
-        break;
-      case "/hang":
-        break;
-      case "/link":
-        res.setHeader("content-type", "text/html").end('<!doctype html><body><a id="go" href="/late">go</a></body>');
-        break;
-      default:
-        res.setHeader("content-type", "text/html").end(`<!doctype html><body>page ${url.pathname}</body>`);
-    }
-  });
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.on("close", () => sockets.delete(socket));
-  });
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-
-  ({ browser, page } = await Browser.launch("firefox", { port: 9238, headless: true }));
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-});
-
-const OPTIONS = { timeout: 40000 };
-const readyState = () =>
-  callFunction<string>(
-    (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector,
-    page.contextId,
-    "() => document.readyState",
-  );
-const imageLoaded = () =>
-  callFunction<boolean>(
-    (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector,
-    page.contextId,
-    "() => Array.from(document.images).every((image) => image.complete)",
-  );
-
-async function timed<T>(action: () => Promise<T>) {
-  const started = Date.now();
-  const value = await action();
-  return { value, took: Date.now() - started };
-}
-
-test("complete (the default) resolves after the slow subresource, interactive before it", OPTIONS, async () => {
-  const complete = await timed(() => page.navigateTo(`${base}/late?complete`));
-  assert.ok(complete.took >= 650, `resolved before the image loaded: ${complete.took}ms`);
-  assert.equal(await imageLoaded(), true);
-  assert.equal(typeof complete.value.navigation, "string");
-  assert.equal(complete.value.url, `${base}/late?complete`);
-
-  const interactive = await timed(() => page.navigateTo(`${base}/late?interactive`, { wait: "interactive" }));
-  assert.ok(interactive.took < 500, `interactive waited for the image: ${interactive.took}ms`);
-  assert.equal(await imageLoaded(), false);
-  await page.waitForLoadState("load", { timeout: 5000 });
-  assert.equal(await imageLoaded(), true);
-});
-
-test("none returns at once; waitForLoadState then waits for that navigation, not the old document", OPTIONS, async () => {
-  await page.navigateTo(`${base}/quiet`); // a loaded document to start from
-  const none = await timed(() => page.navigateTo(`${base}/late?none`, { wait: "none" }));
-  assert.ok(none.took < 400, `none waited: ${none.took}ms`);
-  const load = await timed(() => page.waitForLoadState("load", { timeout: 10000 }));
-  assert.ok(none.took + load.took >= 600 || load.took >= 400, `resolved on the old document: ${load.took}ms`);
-  assert.equal(await imageLoaded(), true);
-  assert.equal(await readyState(), "complete");
-});
-
-test("domcontentloaded comes before load", OPTIONS, async () => {
-  await page.navigateTo(`${base}/quiet`);
-  await page.navigateTo(`${base}/late?dcl`, { wait: "none" });
-  const dcl = await timed(() => page.waitForLoadState("domcontentloaded", { timeout: 10000 }));
-  assert.ok(dcl.took < 600, `domcontentloaded waited for the image: ${dcl.took}ms`);
-  await page.waitForLoadState("load", { timeout: 10000 });
-});
-
-test("networkidle waits for the load and a quiet network", OPTIONS, async () => {
-  await page.navigateTo(`${base}/quiet`);
-  await page.navigateTo(`${base}/late?idle`, { wait: "none" });
-  const idle = await timed(() => page.waitForLoadState("networkidle", { timeout: 10000 }));
-  assert.ok(idle.took >= 500, `did not wait for the image: ${idle.took}ms`);
-  assert.equal(await imageLoaded(), true);
-});
-
-test("an already loaded page is ready at once", OPTIONS, async () => {
-  await page.navigateTo(`${base}/quiet`);
-  const load = await timed(() => page.waitForLoadState("load", { timeout: 5000 }));
-  assert.ok(load.took < 300, `took ${load.took}ms`);
-});
-
-test("a refused connection is a NavigationError naming the url", OPTIONS, async () => {
-  const probe = createServer();
-  await new Promise<void>((resolve) => probe.listen(0, "127.0.0.1", resolve));
-  const closedPort = (probe.address() as AddressInfo).port;
-  await new Promise((resolve) => probe.close(resolve));
-  const url = `http://127.0.0.1:${closedPort}/`;
-  await assert.rejects(page.navigateTo(url), (err) => {
-    assert.ok(err instanceof NavigationError, String(err));
-    assert.equal(err.url, url);
-    assert.ok(err.reason.length > 0);
-    assert.match(err.message, /^navigateTo\(\): http:\/\/127\.0\.0\.1:\d+\/ failed: /);
-    return true;
-  });
-});
-
-test("Firefox reports a refused connection from navigate itself, even with wait none", OPTIONS, async () => {
-  const probe = createServer();
-  await new Promise<void>((resolve) => probe.listen(0, "127.0.0.1", resolve));
-  const closedPort = (probe.address() as AddressInfo).port;
-  await new Promise((resolve) => probe.close(resolve));
-  await page.navigateTo(`${base}/quiet`);
-  await assert.rejects(page.navigateTo(`http://127.0.0.1:${closedPort}/`, { wait: "none" }), NavigationError);
-});
-
-test("a link click followed by waitForLoadState ends up on the loaded target", OPTIONS, async () => {
-  await page.navigateTo(`${base}/link`);
-  await page.locator("a[@id='go']").click({ timeout: 5000 });
-  // the navigation has started once the URL changes
-  await page.locator("img").waitFor({ state: "attached", timeout: 10000 });
-  await page.waitForLoadState("load", { timeout: 10000 });
-  assert.equal(await imageLoaded(), true);
-});
-
-test("a server that never answers hits the navigation timeout", OPTIONS, async () => {
-  const { took } = await timed(async () => {
-    await assert.rejects(page.navigateTo(`${base}/hang`, { timeout: 800 }), (err) => {
-      assert.ok(err instanceof NavigationError);
-      assert.equal(err.reason, "timeout after 800ms");
-      assert.equal(err.code, "timeout");
-      return true;
-    });
-  });
-  assert.ok(took >= 750 && took < 3000, `took ${took}ms`);
-});
-
-test("waitForLoadState times out with its own error", OPTIONS, async () => {
-  await page.navigateTo(`${base}/quiet`);
-  await page.navigateTo(`${base}/late?timeout`, { wait: "none" });
-  // the image needs 700ms: the load state is not reached in 250ms
-  await assert.rejects(page.waitForLoadState("load", { timeout: 250 }), LoadStateTimeoutError);
-  await page.waitForLoadState("load", { timeout: 5000 });
-});

package/src/browser/page-api.browser-test.ts

@@ -1,228 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { inflateSync } from "node:zlib";
-import { createServer, type Server } from "node:http";
-import type { AddressInfo, Socket } from "node:net";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, before, test } from "node:test";
-import { UnsupportedOperationError } from "../locator/selector-errors.js";
-import { callFunction } from "../script/call-function.js";
-import { setContent } from "../testing/browser-fixture.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { Browser } from "./browser.js";
-import type Page from "./page.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-const sockets = new Set<Socket>();
-let requests = 0;
-const dir = mkdtempSync(path.join(tmpdir(), "samurai-page-api-"));
-
-before(async () => {
-  server = createServer((req, res) => {
-    requests++;
-    const url = new URL(req.url ?? "/", "http://localhost");
-    res.setHeader("content-type", "text/html").setHeader("cache-control", "no-store").end(
-      `<!doctype html><title>Title ${url.pathname}</title><body style="margin:0">` +
-        `<div id="tall" style="width:200px;height:3000px;background:linear-gradient(red,blue)">${url.pathname} hit ${requests}</div>` +
-        `<div id="card" style="position:absolute;top:100px;left:20px;width:120px;height:80px;background:#3a7"></div></body>`,
-    );
-  });
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.on("close", () => sockets.delete(socket));
-  });
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-
-  ({ browser, page } = await Browser.launch("firefox", { port: 9244, headless: true }));
-  await page.navigateTo(`${base}/one`);
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-  rmSync(dir, { recursive: true, force: true });
-});
-
-const OPTIONS = { timeout: 40000 };
-const connector = () => (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-const run = <T>(source: string) => callFunction<T>(connector(), page.contextId, source);
-const size = () => run<[number, number, number]>("() => [innerWidth, innerHeight, devicePixelRatio]");
-const png = (image: Buffer) => ({
-  magic: image.subarray(0, 8).toString("hex"),
-  width: image.readUInt32BE(16),
-  height: image.readUInt32BE(20),
-});
-const PNG_MAGIC = "89504e470d0a1a0a";
-
-test("a page opens at the default viewport, 1280x720", OPTIONS, async () => {
-  assert.deepEqual((await size()).slice(0, 2), [1280, 720]);
-});
-
-test("setViewport changes the size and the pixel ratio, null puts the browser's size back", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  assert.deepEqual(await size(), [400, 300, 1]);
-  await page.setViewport({ width: 500, height: 320, devicePixelRatio: 2 });
-  assert.deepEqual(await size(), [500, 320, 2]);
-  await page.setViewport(null);
-  const reset = await size();
-  assert.notDeepEqual(reset.slice(0, 2), [500, 320]);
-  await page.applyDefaultViewport();
-  assert.deepEqual((await size()).slice(0, 2), [1280, 720]);
-});
-
-test("screenshot returns a PNG of the viewport, with the viewport's size", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  const image = await page.screenshot();
-  assert.deepEqual(png(image), { magic: PNG_MAGIC, width: 400, height: 300 });
-});
-
-test("a device pixel ratio of 2 doubles the image", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300, devicePixelRatio: 2 });
-  assert.deepEqual(png(await page.screenshot()), { magic: PNG_MAGIC, width: 800, height: 600 });
-  await page.setViewport(null); // an omitted ratio keeps the current one, so put both back
-  await page.applyDefaultViewport();
-});
-
-test("fullPage captures the whole document", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  const { width, height } = png(await page.screenshot({ fullPage: true }));
-  assert.ok(width > 350 && width <= 400, `width ${width} (a scrollbar takes some of the 400)`);
-  assert.ok(height >= 3000, `height ${height}`);
-});
-
-test("clip captures a box, in viewport or document coordinates", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  assert.deepEqual(png(await page.screenshot({ clip: { x: 10, y: 20, width: 50, height: 60 } })), { magic: PNG_MAGIC, width: 50, height: 60 });
-  const inDocument = png(await page.screenshot({ fullPage: true, clip: { x: 0, y: 2000, width: 40, height: 70 } }));
-  assert.deepEqual([inDocument.width, inDocument.height], [40, 70]);
-});
-
-test("jpeg is a JPEG, and a lower quality is smaller", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  const high = await page.screenshot({ type: "jpeg", quality: 95 });
-  const low = await page.screenshot({ type: "jpeg", quality: 5 });
-  assert.equal(high.subarray(0, 3).toString("hex"), "ffd8ff");
-  assert.equal(low.subarray(0, 3).toString("hex"), "ffd8ff");
-  assert.ok(low.length < high.length, `q5 ${low.length} bytes vs q95 ${high.length} bytes`);
-});
-
-test("path writes the screenshot, folders included", OPTIONS, async () => {
-  const file = path.join(dir, "shots", "home.png");
-  const image = await page.screenshot({ path: file });
-  assert.ok(existsSync(file));
-  assert.deepEqual([...readFileSync(file)], [...image]);
-});
-
-test("a locator's screenshot is the size of its element", OPTIONS, async () => {
-  await page.setViewport({ width: 400, height: 300 });
-  const image = await page.locator("div[@id='card']").screenshot({ timeout: 5000 });
-  assert.deepEqual(png(image), { magic: PNG_MAGIC, width: 120, height: 80 });
-});
-
-test("a locator's screenshot scrolls an element below the fold into view", OPTIONS, async () => {
-  await setContent(page, `<div style="height:2000px"></div><div id="low" style="width:90px;height:50px;background:#c33"></div>`);
-  await page.setViewport({ width: 400, height: 300 });
-  const image = await page.locator("div[@id='low']").screenshot({ timeout: 5000 });
-  assert.deepEqual(png(image), { magic: PNG_MAGIC, width: 90, height: 50 });
-  await page.navigateTo(`${base}/one`);
-});
-
-/** The page box of the first page, looked up in the PDF text and in its compressed streams */
-function mediaBox(pdf: Buffer): number[] | undefined {
-  const pattern = /\/MediaBox\s*\[\s*(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s*\]/;
-  const raw = pdf.toString("latin1");
-  const texts = [raw];
-  for (const match of raw.matchAll(/stream\r?\n/g)) {
-    const start = match.index! + match[0].length;
-    const end = raw.indexOf("endstream", start);
-    try {
-      texts.push(inflateSync(pdf.subarray(start, end)).toString("latin1"));
-    } catch {
-      // not a Flate stream
-    }
-  }
-  for (const text of texts) {
-    const found = pattern.exec(text);
-    if (found) return [Math.round(Number(found[3]) - Number(found[1])), Math.round(Number(found[4]) - Number(found[2]))];
-  }
-  return undefined;
-}
-
-test("pdf returns a PDF with the requested paper size", OPTIONS, async () => {
-  const a4 = await page.pdf({ format: "A4" });
-  assert.equal(a4.subarray(0, 5).toString(), "%PDF-");
-  const near = (actual: number[] | undefined, expected: number[]) =>
-    assert.ok(actual && actual.every((value, i) => Math.abs(value - expected[i]!) <= 2), `${actual} is not about ${expected}`);
-  near(mediaBox(a4), [595, 842]);
-  near(mediaBox(await page.pdf({ format: "A4", landscape: true })), [842, 595]);
-  near(mediaBox(await page.pdf({ format: "Letter" })), [612, 792]);
-  const file = path.join(dir, "pdfs", "page.pdf");
-  await page.pdf({ path: file });
-  assert.equal(readFileSync(file).subarray(0, 5).toString(), "%PDF-");
-});
-
-test("url and title describe the page now", OPTIONS, async () => {
-  await page.navigateTo(`${base}/titled`);
-  assert.equal(await page.url(), `${base}/titled`);
-  assert.equal(await page.title(), "Title /titled");
-});
-
-test("goBack and goForward walk the history; at the ends they say false", OPTIONS, async () => {
-  const tab = await browser.newPage({ type: "tab" }); // its initial about:blank is not a history entry
-  try {
-    await tab.navigateTo(`${base}/first`);
-    await tab.navigateTo(`${base}/second`);
-    assert.equal(await tab.goBack(), true);
-    assert.equal(await tab.url(), `${base}/first`);
-    assert.equal(await tab.goForward(), true);
-    assert.equal(await tab.url(), `${base}/second`);
-    assert.equal(await tab.goForward(), false, "nothing ahead");
-    assert.equal(await tab.goBack(), true);
-    assert.equal(await tab.goBack(), false, "nothing behind the first page");
-    assert.equal(await tab.goBack(), false, "however often it is asked");
-    assert.equal(await tab.url(), `${base}/first`);
-    assert.equal(await tab.goForward(), true, "and the way forward is still there");
-    assert.equal(await tab.url(), `${base}/second`);
-  } finally {
-    await tab.close();
-  }
-});
-
-test("reload fetches the page again and waits for it", OPTIONS, async () => {
-  await page.navigateTo(`${base}/reloaded`);
-  const before = requests;
-  const result = await page.reload();
-  assert.ok(requests > before, "the server was asked again");
-  assert.equal(result.url, `${base}/reloaded`);
-  assert.equal(typeof result.navigation, "string");
-  assert.equal(await run("() => document.readyState"), "complete");
-});
-
-test("reload({ ignoreCache }) is reported as unsupported by this Firefox", OPTIONS, async () => {
-  await assert.rejects(page.reload({ ignoreCache: true }), UnsupportedOperationError);
-});
-
-test("close closes a tab; the page then refuses further use", OPTIONS, async () => {
-  const tab = await browser.newPage({ type: "tab" });
-  await tab.navigateTo(`${base}/tab`);
-  assert.equal(await tab.title(), "Title /tab");
-  await tab.close();
-  assert.equal(tab.closed, true);
-  await assert.rejects(tab.url(), /page closed/);
-  await assert.rejects(tab.screenshot(), /page closed/);
-  await tab.close(); // idempotent
-});
-
-test("close({ runBeforeUnload }) works on a page without handlers", OPTIONS, async () => {
-  const tab = await browser.newPage({ type: "tab" });
-  await tab.navigateTo(`${base}/tab2`);
-  await tab.close({ runBeforeUnload: true });
-  assert.equal(tab.closed, true);
-});

package/src/browser/page-logs.browser-test.ts

@@ -1,119 +0,0 @@
-import assert from "node:assert/strict";
-import { after, before, test } from "node:test";
-import { judgePageLogs } from "../runner/page-logs-report.js";
-import { callFunction } from "../script/call-function.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { Browser } from "./browser.js";
-import type { ConsoleMessage, PageError } from "./page-logs.js";
-import type Page from "./page.js";
-
-let browser: Browser;
-let page: Page;
-
-before(async () => {
-  ({ browser, page } = await Browser.launch("firefox", { port: 9240, headless: true }));
-  await page.navigateTo("about:blank");
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-});
-
-const OPTIONS = { timeout: 30000 };
-const run = (source: string) =>
-  callFunction((page as unknown as { biDiConnector: BiDiConnector }).biDiConnector, page.contextId, source, [], {
-    awaitPromise: false,
-  });
-
-test("console calls arrive with method, text and plain arguments", OPTIONS, async () => {
-  page.clearLogs();
-  const seen: ConsoleMessage[] = [];
-  const onConsole = (message: ConsoleMessage) => seen.push(message);
-  page.on("console", onConsole);
-  await page.startLogging();
-  await run(`() => {
-    console.log("hello", 42, { a: [1, 2], b: "x" });
-    console.warn("careful");
-    console.error("bad but handled");
-    console.info("fyi");
-    console.debug("details");
-  }`);
-  await page.syncLogs();
-  page.off("console", onConsole);
-
-  assert.deepEqual(seen.map((message) => message.type()), ["log", "warn", "error", "info", "debug"]);
-  assert.match(seen[0]!.text(), /^hello 42 Object/, "the browser's own rendering of the call");
-  assert.deepEqual(seen[0]!.args, ["hello", 42, { a: [1, 2], b: "x" }]);
-  assert.equal(seen[1]!.level, "warn");
-  assert.equal(seen[2]!.level, "error");
-  assert.ok(seen[0]!.location(), "a location is reported");
-  assert.deepEqual(page.getLogs().map((log) => [log.type, log.method]), [
-    ["console", "log"], ["console", "warn"], ["console", "error"], ["console", "info"], ["console", "debug"],
-  ]);
-  assert.equal(page.pageErrors().length, 0, "console.error is not an uncaught exception");
-});
-
-test("an uncaught exception is a page error with a stack", OPTIONS, async () => {
-  page.clearLogs();
-  const errors: PageError[] = [];
-  const onError = (error: PageError) => errors.push(error);
-  page.on("pageerror", onError);
-  await run(`() => { setTimeout(function explode() { throw new TypeError("boom from the page"); }, 0); }`);
-  await new Promise((resolve) => setTimeout(resolve, 200));
-  await page.syncLogs();
-  page.off("pageerror", onError);
-
-  assert.equal(errors.length, 1);
-  assert.match(errors[0]!.message, /TypeError: boom from the page/);
-  assert.match(errors[0]!.stack ?? "", /explode/);
-  assert.equal(page.pageErrors().length, 1);
-  assert.deepEqual(page.getLogs().map((log) => [log.type, log.level]), [["javascript", "error"]]);
-});
-
-test("an unhandled promise rejection is reported as a page error too (Firefox)", OPTIONS, async () => {
-  page.clearLogs();
-  await run(`() => { Promise.reject(new Error("nobody catches me")); }`);
-  await new Promise((resolve) => setTimeout(resolve, 200));
-  await page.syncLogs();
-  assert.deepEqual(page.pageErrors().map((error) => error.message), ["Error: nobody catches me"]);
-});
-
-test("logs of an iframe belong to the page", OPTIONS, async () => {
-  page.clearLogs();
-  await run(`() => {
-    const frame = document.body.appendChild(document.createElement("iframe"));
-    frame.src = "about:blank";
-    frame.addEventListener("load", () => frame.contentWindow.console.log("from the frame"), { once: true });
-  }`);
-  await new Promise((resolve) => setTimeout(resolve, 300));
-  await page.syncLogs();
-  assert.deepEqual(page.getLogs().map((log) => log.text), ["from the frame"]);
-});
-
-test("the first log of a new document is not lost", OPTIONS, async () => {
-  page.clearLogs();
-  await page.navigateTo(`data:text/html,<script>console.log("very early")</script>`);
-  await page.syncLogs();
-  assert.ok(page.getLogs().some((log) => log.text === "very early"), JSON.stringify(page.getLogs()));
-});
-
-test("what the runner would do with these logs", OPTIONS, async () => {
-  page.clearLogs();
-  await run(`() => { console.log("context"); setTimeout(() => { throw new Error("uncaught in test"); }, 0); }`);
-  await new Promise((resolve) => setTimeout(resolve, 200));
-  await page.syncLogs();
-
-  const input = {
-    entries: page.getLogs(),
-    errors: page.pageErrors(),
-    dropped: page.logsDropped,
-    testFailed: false,
-    allowPageErrors: page.pageErrorsAllowed,
-  };
-  const verdict = judgePageLogs({ ...input, config: { failOnPageError: true } });
-  assert.match(verdict.error!.message, /^1 uncaught page error\(s\): .*uncaught in test/);
-  assert.deepEqual(verdict.logs!.map((log) => log.text.replace(/^.*(context|uncaught in test).*$/, "$1")), ["context", "uncaught in test"]);
-  assert.equal(judgePageLogs({ ...input, config: { failOnPageError: true, ignoreErrors: ["uncaught in test"] } }).error, undefined);
-  assert.equal(judgePageLogs({ ...input, config: {} }).error, undefined);
-});