@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/browser/download.test.ts

@@ -1,161 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { autoReply, FakeWebSocket, tick } from "../testing/fake-websocket.js";
-import { BiDiConnector } from "../transport/bidi-connection.js";
-import { ContextTree } from "./context-tree.js";
-import { Download, DownloadError, DownloadTracker } from "./download.js";
-
-const TREE = [
-  { context: "top", parent: null, children: [{ context: "frame", parent: "top", children: [] }] },
-  { context: "other", parent: null, children: [] },
-];
-const stops: Array<() => void> = [];
-afterEach(() => stops.splice(0).forEach((stop) => stop()));
-
-async function setup(options: { timeout?: number } = {}) {
-  const ws = new FakeWebSocket();
-  const connector = new BiDiConnector(ws as unknown as WebSocket);
-  stops.push(autoReply(ws, { "browsingContext.getTree": () => ({ contexts: TREE }) }));
-  const tree = await ContextTree.create(connector);
-  const tracker = await DownloadTracker.start(connector, tree, "top", { timeout: options.timeout ?? 1000 });
-  const seen: Download[] = [];
-  tracker.on("download", (download) => seen.push(download));
-  const begin = (navigation: string, extra: { context?: string; url?: string; filename?: string } = {}) =>
-    ws.emitEvent("browsingContext.downloadWillBegin", {
-      context: extra.context ?? "top",
-      navigation,
-      timestamp: 1,
-      url: extra.url ?? `https://example.test/${navigation}`,
-      suggestedFilename: extra.filename ?? `${navigation}.csv`,
-    });
-  const complete = (navigation: string, filepath = `/tmp/dl/${navigation}.csv`, context = "top") =>
-    ws.emitEvent("browsingContext.downloadEnd", { context, navigation, timestamp: 2, url: "u", status: "complete", filepath });
-  const cancel = (navigation: string, context = "top") =>
-    ws.emitEvent("browsingContext.downloadEnd", { context, navigation, timestamp: 2, url: "u", status: "canceled" });
-  return { ws, tracker, seen, begin, complete, cancel };
-}
-
-describe("DownloadTracker", () => {
-  it("announces a download with its url and suggested file name", async () => {
-    const { seen, begin } = await setup();
-    begin("n1", { url: "https://example.test/file", filename: "report.csv" });
-    assert.equal(seen.length, 1);
-    assert.ok(seen[0] instanceof Download);
-    assert.equal(seen[0]!.url(), "https://example.test/file");
-    assert.equal(seen[0]!.suggestedFilename(), "report.csv");
-  });
-
-  it("path() resolves with the file the browser wrote once the download completed", async () => {
-    const { seen, begin, complete } = await setup();
-    begin("n1");
-    const pending = seen[0]!.path();
-    complete("n1", "/tmp/dl/report.csv");
-    assert.equal(await pending, "/tmp/dl/report.csv");
-    assert.equal(await seen[0]!.failure(), null);
-  });
-
-  it("path() also works when the download finished before it was asked", async () => {
-    const { seen, begin, complete } = await setup();
-    begin("n1");
-    complete("n1", "/tmp/dl/a.csv");
-    await tick(5);
-    assert.equal(await seen[0]!.path(), "/tmp/dl/a.csv");
-    assert.equal(await seen[0]!.path(), "/tmp/dl/a.csv", "and again");
-  });
-
-  it("a cancelled download rejects path() with a DownloadError and reports the failure", async () => {
-    const { seen, begin, cancel } = await setup();
-    begin("n1", { url: "https://example.test/big" });
-    const pending = seen[0]!.path();
-    const rejection = assert.rejects(pending, (err: unknown) => {
-      assert.ok(err instanceof DownloadError);
-      assert.equal(err.url, "https://example.test/big");
-      assert.equal(err.reason, "canceled");
-      assert.match(err.message, /^Download of https:\/\/example\.test\/big failed: canceled/);
-      return true;
-    });
-    cancel("n1");
-    await rejection;
-    assert.equal(await seen[0]!.failure(), "canceled");
-  });
-
-  it("failure() waits for the end, too", async () => {
-    const { seen, begin, cancel } = await setup();
-    begin("n1");
-    let failure: string | null | undefined;
-    void seen[0]!.failure().then((value) => (failure = value));
-    await tick(10);
-    assert.equal(failure, undefined);
-    cancel("n1");
-    await tick(10);
-    assert.equal(failure, "canceled");
-  });
-
-  it("path() times out when the download never ends", async () => {
-    const { seen, begin } = await setup({ timeout: 50 });
-    begin("n1", { url: "https://example.test/slow" });
-    await assert.rejects(seen[0]!.path(), /Download of https:\/\/example\.test\/slow did not finish within 50ms/);
-    await assert.rejects(seen[0]!.path({ timeout: 20 }), /did not finish within 20ms/);
-  });
-
-  it("matches ends to downloads by navigation, however they interleave", async () => {
-    const { seen, begin, complete, cancel } = await setup();
-    begin("a");
-    begin("b");
-    cancel("b");
-    complete("a", "/tmp/dl/a.csv");
-    assert.equal(await seen[0]!.path(), "/tmp/dl/a.csv");
-    await assert.rejects(seen[1]!.path(), DownloadError);
-  });
-
-  it("an end without a beginning is ignored", async () => {
-    const { seen, complete } = await setup();
-    complete("ghost");
-    assert.equal(seen.length, 0);
-  });
-
-  it("takes downloads of iframes, ignores those of other pages", async () => {
-    const { seen, begin } = await setup();
-    begin("f", { context: "frame" });
-    begin("x", { context: "other" });
-    assert.deepEqual(seen.map((d) => d.suggestedFilename()), ["f.csv"]);
-  });
-
-  it("a throwing listener does not stop the others, and off removes one", async () => {
-    const { tracker, begin } = await setup();
-    let second = 0;
-    let removed = 0;
-    const gone = () => removed++;
-    tracker.on("download", () => {
-      throw new Error("listener failed");
-    });
-    tracker.on("download", () => second++);
-    tracker.on("download", gone);
-    tracker.off("download", gone);
-    begin("n1");
-    assert.equal(second, 1);
-    assert.equal(removed, 0);
-  });
-
-  it("subscribes to both events and lets go of them on dispose", async () => {
-    const { ws, tracker, begin, seen } = await setup();
-    const subscribed = ws.sent.filter((m) => m.method === "session.subscribe").map((m) => (m.params as any).events[0]);
-    assert.ok(subscribed.includes("browsingContext.downloadWillBegin"));
-    assert.ok(subscribed.includes("browsingContext.downloadEnd"));
-    await tracker.dispose();
-    await tick(10);
-    begin("late");
-    assert.equal(seen.length, 0);
-    assert.ok(ws.sent.filter((m) => m.method === "session.unsubscribe").length >= 2);
-    await assert.doesNotReject(tracker.dispose());
-  });
-
-  it("dispose rejects downloads still in progress", async () => {
-    const { seen, begin, tracker } = await setup();
-    begin("n1");
-    const pending = seen[0]!.path();
-    const rejection = assert.rejects(pending, /page closed/);
-    await tracker.dispose();
-    await rejection;
-  });
-});

package/src/browser/download.ts

@@ -1,172 +0,0 @@
-import EventEmitter from "node:events";
-import logger from "../logger/index.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import type { Subscription } from "../transport/subscriptions.js";
-import type {
-  DownloadEndParams,
-  DownloadWillBeginParams,
-} from "../types/bidi-modules/browsing-context.js";
-import { WaitTimeoutError } from "../wait/wait-until.js";
-import type { ContextTree } from "./context-tree.js";
-
-/** A download did not complete */
-export class DownloadError extends Error {
-  public readonly url: string;
-  /** "canceled": the browser stopped it or the server broke the connection; "page closed" */
-  public readonly reason: string;
-
-  constructor(url: string, reason: string) {
-    super(`Download of ${url} failed: ${reason}`);
-    this.name = "DownloadError";
-    this.url = url;
-    this.reason = reason;
-  }
-}
-
-/** A download did not finish in time */
-export class DownloadTimeoutError extends WaitTimeoutError<undefined> {
-  constructor(url: string, timeout: number) {
-    super(timeout, undefined);
-    this.name = "DownloadTimeoutError";
-    this.message = `Download of ${url} did not finish within ${timeout}ms`;
-  }
-}
-
-type Outcome = { status: "complete"; path: string } | { status: "canceled" } | { status: "closed" };
-
-/** A file the page started to download */
-export class Download {
-  private settle!: (outcome: Outcome) => void;
-  private outcome = new Promise<Outcome>((resolve) => (this.settle = resolve));
-
-  constructor(
-    private readonly address: string,
-    private readonly filename: string,
-    private readonly defaultTimeout: number,
-  ) {}
-
-  public url(): string {
-    return this.address;
-  }
-
-  /** The name the server (or the link) suggested */
-  public suggestedFilename(): string {
-    return this.filename;
-  }
-
-  /**
-   * Waits until the download finished and returns where the browser saved it. Rejects with DownloadError when it was
-   * cancelled, and with DownloadTimeoutError after `timeout` ms (default: the navigation timeout).
-   */
-  public async path(options: { timeout?: number } = {}): Promise<string> {
-    const timeout = options.timeout ?? this.defaultTimeout;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const late = new Promise<never>((_, reject) => {
-      timer = setTimeout(() => reject(new DownloadTimeoutError(this.address, timeout)), timeout);
-    });
-    try {
-      const outcome = await Promise.race([this.outcome, late]);
-      if (outcome.status === "complete") return outcome.path;
-      throw new DownloadError(this.address, outcome.status === "closed" ? "page closed" : "canceled");
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  /** Waits for the end of the download: null when it completed, otherwise why it did not ("canceled") */
-  public async failure(): Promise<string | null> {
-    const outcome = await this.outcome;
-    if (outcome.status === "complete") return null;
-    return outcome.status === "closed" ? "page closed" : "canceled";
-  }
-
-  /** @internal */
-  public finish(outcome: Outcome): void {
-    this.settle(outcome);
-  }
-}
-
-interface EventMap {
-  download: [Download];
-}
-
-/** Follows the downloads of one page (frames included) */
-export class DownloadTracker {
-  private events = new EventEmitter();
-  private active = new Map<string, Download>();
-  private subscription: Subscription | undefined;
-  private disposed = false;
-
-  private constructor(
-    private connector: BiDiConnector,
-    private tree: ContextTree,
-    private contextId: string,
-    private timeout: number,
-  ) {}
-
-  public static async start(
-    connector: BiDiConnector,
-    tree: ContextTree,
-    contextId: string,
-    options: { timeout: number },
-  ): Promise<DownloadTracker> {
-    const tracker = new DownloadTracker(connector, tree, contextId, options.timeout);
-    connector.onEvent("browsingContext.downloadWillBegin", tracker.onBegin);
-    connector.onEvent("browsingContext.downloadEnd", tracker.onEnd);
-    try {
-      tracker.subscription = await connector.subscribe([
-        "browsingContext.downloadWillBegin",
-        "browsingContext.downloadEnd",
-      ]);
-    } catch (err) {
-      tracker.removeListeners();
-      throw err;
-    }
-    return tracker;
-  }
-
-  public on(event: "download", listener: (...args: EventMap["download"]) => void): void {
-    this.events.on(event, listener as (...args: unknown[]) => void);
-  }
-
-  public off(event: "download", listener: (...args: EventMap["download"]) => void): void {
-    this.events.off(event, listener as (...args: unknown[]) => void);
-  }
-
-  /** Stops tracking; downloads still going on reject with "page closed". Idempotent */
-  public async dispose(): Promise<void> {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.removeListeners();
-    for (const download of this.active.values()) download.finish({ status: "closed" });
-    this.active.clear();
-    await this.subscription?.unsubscribe();
-  }
-
-  private removeListeners() {
-    this.connector.offEvent("browsingContext.downloadWillBegin", this.onBegin);
-    this.connector.offEvent("browsingContext.downloadEnd", this.onEnd);
-  }
-
-  private onBegin = (params: DownloadWillBeginParams) => {
-    if (!this.tree.isWithin(params.context, this.contextId)) return;
-    const download = new Download(params.url, params.suggestedFilename, this.timeout);
-    this.active.set(params.navigation, download);
-    for (const listener of this.events.rawListeners("download")) {
-      try {
-        listener(download);
-      } catch (err) {
-        logger.error("A download listener threw", { err });
-      }
-    }
-  };
-
-  private onEnd = (params: DownloadEndParams) => {
-    const download = this.active.get(params.navigation);
-    if (!download) return;
-    this.active.delete(params.navigation);
-    download.finish(
-      params.status === "complete" ? { status: "complete", path: params.filepath } : { status: "canceled" },
-    );
-  };
-}

package/src/browser/downloads-dir.test.ts

@@ -1,75 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, afterEach, describe, it } from "node:test";
-import { autoReply, FakeWebSocket } from "../testing/fake-websocket.js";
-import { BiDiConnector } from "../transport/bidi-connection.js";
-import { prepareDownloadsDir, removeIfEmpty } from "./downloads-dir.js";
-
-const stops: Array<() => void> = [];
-afterEach(() => stops.splice(0).forEach((stop) => stop()));
-const base = mkdtempSync(path.join(tmpdir(), "samurai-downloads-"));
-after(() => rmSync(base, { recursive: true, force: true }));
-
-function setup(handlers: Record<string, (params: any) => object | Error> = {}) {
-  const ws = new FakeWebSocket();
-  const connector = new BiDiConnector(ws as unknown as WebSocket);
-  stops.push(autoReply(ws, { "browser.setDownloadBehavior": () => ({}), ...handlers }));
-  return { ws, connector };
-}
-const failing = (code: string) => Object.assign(new Error(code), { code });
-
-describe("prepareDownloadsDir", () => {
-  it("makes a folder below the base and tells the browser to save there", async () => {
-    const { ws, connector } = setup();
-    const dir = await prepareDownloadsDir(connector, path.join(base, "a"));
-    assert.ok(dir);
-    assert.equal(path.dirname(dir), path.join(base, "a"));
-    assert.ok(existsSync(dir));
-    assert.deepEqual(ws.sent[0]!.params, { downloadBehavior: { type: "allowed", destinationFolder: dir } });
-  });
-
-  it("every call gets a folder of its own", async () => {
-    const { connector } = setup();
-    const first = await prepareDownloadsDir(connector, path.join(base, "b"));
-    const second = await prepareDownloadsDir(connector, path.join(base, "b"));
-    assert.notEqual(first, second);
-  });
-
-  it("a browser that cannot be told gets no folder, and none is left behind", async () => {
-    const { connector } = setup({ "browser.setDownloadBehavior": () => failing("unknown command") });
-    const target = path.join(base, "c");
-    assert.equal(await prepareDownloadsDir(connector, target), undefined);
-    assert.deepEqual(readdirSync(target), []);
-  });
-
-  it("other errors are thrown, folder removed", async () => {
-    const { connector } = setup({ "browser.setDownloadBehavior": () => failing("invalid argument") });
-    const target = path.join(base, "d");
-    await assert.rejects(prepareDownloadsDir(connector, target), { name: "BiDiError", code: "invalid argument" });
-    assert.deepEqual(readdirSync(target), []);
-  });
-});
-
-describe("removeIfEmpty", () => {
-  it("removes an empty folder, keeps one that has files", () => {
-    const empty = path.join(base, "empty");
-    const full = path.join(base, "full");
-    for (const dir of [empty, full]) {
-      rmSync(dir, { recursive: true, force: true });
-    }
-    mkdirSync(empty);
-    mkdirSync(full);
-    writeFileSync(path.join(full, "report.csv"), "x");
-    removeIfEmpty(empty);
-    removeIfEmpty(full);
-    assert.equal(existsSync(empty), false);
-    assert.equal(existsSync(path.join(full, "report.csv")), true);
-  });
-
-  it("does nothing for a missing folder or no folder", () => {
-    assert.doesNotThrow(() => removeIfEmpty(path.join(base, "never-existed")));
-    assert.doesNotThrow(() => removeIfEmpty(undefined));
-  });
-});

package/src/browser/downloads-dir.ts

@@ -1,39 +0,0 @@
-import { mkdirSync, rmdirSync } from "node:fs";
-import path from "node:path";
-import logger from "../logger/index.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { BiDiError } from "../transport/bidi-error.js";
-
-let counter = 0;
-
-/**
- * Makes downloads land in a folder of their own, so a test knows where to look and runs do not mix: a new folder
- * below `baseDir` is created and the browser told to save there. Returns it, or undefined when the browser cannot be told.
- */
-export async function prepareDownloadsDir(connector: BiDiConnector, baseDir: string): Promise<string | undefined> {
-  const dir = path.join(path.resolve(baseDir), `dl-${Date.now().toString(36)}-${process.pid}-${counter++}`);
-  mkdirSync(dir, { recursive: true });
-  try {
-    await connector.send("browser.setDownloadBehavior", {
-      downloadBehavior: { type: "allowed", destinationFolder: dir },
-    });
-  } catch (err) {
-    removeIfEmpty(dir);
-    if (err instanceof BiDiError && (err.code === "unknown command" || err.code === "unsupported operation")) {
-      logger.warn("The browser cannot be told where to save downloads; they go to its own folder");
-      return undefined;
-    }
-    throw err;
-  }
-  return dir;
-}
-
-/** Removes `dir` when nothing was downloaded into it. Never throws */
-export function removeIfEmpty(dir: string | undefined): void {
-  if (!dir) return;
-  try {
-    rmdirSync(dir);
-  } catch {
-    // Not empty, or already gone: leave it
-  }
-}

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

@@ -1,186 +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 { UnsupportedOperationError } from "../locator/selector-errors.js";
-import { callFunction } from "../script/call-function.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { Browser } from "./browser.js";
-import type { BrowserContext } from "./browser-context.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 userAgents: string[] = [];
-const contexts: BrowserContext[] = [];
-
-before(async () => {
-  server = createServer((req, res) => {
-    if (req.url?.startsWith("/ping")) {
-      userAgents.push(String(req.headers["user-agent"]));
-      res.setHeader("content-type", "text/plain").end("pong");
-      return;
-    }
-    res.setHeader("content-type", "text/html").end(`<!doctype html><body>emulation<script>window.__inline = "ran"</script></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: 9248, headless: true }));
-  await page.navigateTo(`${base}/`);
-});
-
-after(async () => {
-  for (const context of contexts) await context.close().catch(() => undefined);
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-});
-
-const OPTIONS = { timeout: 40000 };
-const connector = (p: Page) => (p as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-const evaluate = <T>(p: Page, source: string) => callFunction<T>(connector(p), p.contextId, source);
-
-async function freshPage(options?: Parameters<Browser["newContext"]>[0]) {
-  const context = await browser.newContext(options);
-  contexts.push(context);
-  const tab = await context.newPage();
-  await tab.navigateTo(`${base}/`);
-  return { context, tab };
-}
-
-test("locale changes navigator.language and Intl formatting, and resets", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  const read = () => evaluate<{ language: string; number: string }>(tab, `() => ({ language: navigator.language, number: new Intl.NumberFormat().format(1234.5) })`);
-  // The starting locale is the machine's own, so it is read rather than assumed
-  const before = await read();
-  await tab.emulate({ locale: "nl-NL" });
-  assert.deepEqual(await read(), { language: "nl-NL", number: "1.234,5" });
-  await tab.emulate({ locale: null });
-  assert.deepEqual(await read(), before);
-});
-
-test("timezone changes what Date and Intl report, and resets", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  const read = () => evaluate<{ zone: string; offset: number }>(tab, `() => ({ zone: Intl.DateTimeFormat().resolvedOptions().timeZone, offset: new Date(0).getTimezoneOffset() })`);
-  const before = await read();
-  await tab.emulate({ timezone: "Asia/Tokyo" });
-  assert.deepEqual(await read(), { zone: "Asia/Tokyo", offset: -540 });
-  await tab.emulate({ timezone: "America/New_York" });
-  assert.deepEqual(await read(), { zone: "America/New_York", offset: 300 });
-  await tab.emulate({ timezone: null });
-  assert.deepEqual(await read(), before);
-});
-
-test("userAgent changes navigator.userAgent and the header the server receives", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  await tab.emulate({ userAgent: "Samurai/1.0 (test)" });
-  assert.equal(await evaluate<string>(tab, "() => navigator.userAgent"), "Samurai/1.0 (test)");
-  userAgents.length = 0;
-  await evaluate(tab, `async () => { await fetch(${JSON.stringify(base + "/ping")}); }`);
-  assert.deepEqual(userAgents, ["Samurai/1.0 (test)"]);
-  await tab.emulate({ userAgent: null });
-  assert.match(await evaluate<string>(tab, "() => navigator.userAgent"), /Firefox/);
-});
-
-test("offline stops the network, and going online again restores it", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  const read = () => evaluate<{ online: boolean; fetch: string }>(tab, `async () => ({ online: navigator.onLine, fetch: await fetch(${JSON.stringify(base + "/ping")}).then(() => "ok", () => "failed") })`);
-  assert.deepEqual(await read(), { online: true, fetch: "ok" });
-  await tab.emulate({ offline: true });
-  assert.deepEqual(await read(), { online: false, fetch: "failed" });
-  await tab.emulate({ offline: false });
-  assert.deepEqual(await read(), { online: true, fetch: "ok" });
-});
-
-test("orientation changes screen.orientation", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  await tab.emulate({ orientation: "portrait" });
-  assert.equal(await evaluate<string>(tab, "() => screen.orientation.type"), "portrait-primary");
-  await tab.emulate({ orientation: "landscape-secondary" });
-  assert.equal(await evaluate<string>(tab, "() => screen.orientation.type"), "landscape-secondary");
-  await tab.emulate({ orientation: null });
-  assert.equal(await evaluate<string>(tab, "() => screen.orientation.type"), "landscape-primary");
-});
-
-test("screen changes screen.width and screen.height", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  await tab.emulate({ screen: { width: 800, height: 600 } });
-  assert.deepEqual(await evaluate<number[]>(tab, "() => [screen.width, screen.height]"), [800, 600]);
-  await tab.emulate({ screen: null });
-  assert.notDeepEqual(await evaluate<number[]>(tab, "() => [screen.width, screen.height]"), [800, 600]);
-});
-
-test("geolocation answers once the permission is granted", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  const position = () =>
-    evaluate<{ lat?: number; lon?: number; accuracy?: number; error?: string }>(
-      tab,
-      `() => new Promise((resolve) => navigator.geolocation.getCurrentPosition(
-        (p) => resolve({ lat: p.coords.latitude, lon: p.coords.longitude, accuracy: p.coords.accuracy }),
-        (e) => resolve({ error: e.code + " " + e.message }),
-        { timeout: 4000, maximumAge: 0 }))`,
-    );
-  await tab.grantPermission("geolocation");
-  await tab.emulate({ geolocation: { latitude: 52.37, longitude: 4.9, accuracy: 10 } });
-  assert.deepEqual(await position(), { lat: 52.37, lon: 4.9, accuracy: 10 });
-  await tab.emulate({ geolocation: { latitude: -33.87, longitude: 151.21 } });
-  const sydney = await position();
-  assert.deepEqual([sydney.lat, sydney.lon], [-33.87, 151.21]);
-});
-
-test("a context's emulation reaches its pages, also the ones opened later; other contexts are untouched", OPTIONS, async () => {
-  const language = (p: Page) => evaluate<string>(p, "() => navigator.language");
-  const ownLanguage = await language(page);
-  const { context, tab } = await freshPage({ locale: "de-DE" });
-  assert.equal(await language(tab), "de-DE", "options given to newContext are in place for its first page");
-  await context.emulate({ locale: "es-ES" });
-  assert.equal(await language(tab), "es-ES", "an open page follows a change");
-  const later = await context.newPage();
-  await later.navigateTo(`${base}/`);
-  assert.equal(await language(later), "es-ES", "a page opened later is emulated too");
-  assert.equal(await language(page), ownLanguage, "the default context is not");
-});
-
-test("a page's own emulation wins over its context's, and null falls back to the context", OPTIONS, async () => {
-  const { context, tab } = await freshPage({ locale: "de-DE" });
-  const language = () => evaluate<string>(tab, "() => navigator.language");
-  await tab.emulate({ locale: "fr-FR" });
-  assert.equal(await language(), "fr-FR");
-  await tab.emulate({ locale: null });
-  assert.equal(await language(), "de-DE");
-  void context;
-});
-
-test("touch and javaScriptEnabled are reported as unsupported by this Firefox, after what came before them was applied", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  await assert.rejects(tab.emulate({ locale: "it-IT", touch: 5 }), (err: unknown) => {
-    assert.ok(err instanceof UnsupportedOperationError);
-    assert.equal((err as { option?: string }).option, "touch");
-    assert.deepEqual((err as { applied?: string[] }).applied, ["locale"]);
-    return true;
-  });
-  assert.equal(await evaluate<string>(tab, "() => navigator.language"), "it-IT", "nothing is rolled back");
-  await assert.rejects(tab.emulate({ javaScriptEnabled: false }), UnsupportedOperationError);
-});
-
-test("newContext refuses an unsupported option and leaves no context behind", OPTIONS, async () => {
-  const before = browser.contexts().length;
-  await assert.rejects(browser.newContext({ locale: "nl-NL", touch: 3 }), UnsupportedOperationError);
-  assert.equal(browser.contexts().length, before);
-  await assert.rejects(browser.newContext({ timezone: "Not/AZone" }), RangeError);
-  assert.equal(browser.contexts().length, before);
-});
-
-test("invalid values are refused by the framework before the browser is asked", OPTIONS, async () => {
-  const { tab } = await freshPage();
-  await assert.rejects(tab.emulate({ geolocation: { latitude: 100, longitude: 0 } }), RangeError);
-  await assert.rejects(tab.emulate({ timezone: "Mars/Olympus" }), RangeError);
-});