@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/logger/index.test.ts

@@ -1,28 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { Writable } from "node:stream";
-import { transports } from "winston";
-import { MASK, registerSecret, resetSecrets } from "../config/mask.js";
-import logger from "./index.js";
-
-test("the real logger masks registered secrets in messages and metadata", () => {
-  let out = "";
-  const transport = new transports.Stream({
-    stream: new Writable({
-      write(chunk, _enc, done) {
-        out += String(chunk);
-        done();
-      },
-    }),
-  });
-  logger.add(transport);
-  registerSecret("TEST_CARD", "4242424242424242");
-  try {
-    logger.info("paying with 4242424242424242", { card: "4242424242424242" });
-  } finally {
-    logger.remove(transport);
-    resetSecrets();
-  }
-  assert.ok(out.includes(MASK), out);
-  assert.ok(!out.includes("4242424242424242"), out);
-});

package/src/logger/index.ts

@@ -1,40 +0,0 @@
-import { createLogger, format, transports } from "winston";
-import { maskFormat } from "../config/mask.js";
-
-const logger = createLogger({
-  level: "debug",
-  format: format.combine(
-    format.timestamp({
-      format: "DD-MM-YYYY HH:mm:ss",
-    }),
-    format.errors({ stack: true }),
-    format.splat(),
-    format.metadata({ key: "meta" }),
-    maskFormat(),
-    format.json({ space: 2 }),
-  ),
-  defaultMeta: { service: "samurai-framework" },
-  transports: [
-    //
-    // - Write to all logs with level `info` and below to `quick-start-combined.log`.
-    // - Write all logs error (and below) to `quick-start-error.log`.
-    //
-    new transports.Console({
-      level: "debug",
-      format: format.combine(
-        format.timestamp(),
-        format.errors({ stack: true }),
-        format.printf(({ level, message, meta }) => {
-          return `${level.toUpperCase()}: ${message}${meta ? `\n${JSON.stringify(meta)}` : null}`;
-        }),
-      ),
-    }),
-    new transports.File({
-      filename: `logs/error.log`,
-      level: "error",
-    }),
-    new transports.File({ filename: `logs/combined.log` }),
-  ],
-});
-
-export default logger;

package/src/network/data-collector.test.ts

@@ -1,111 +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 { DataCollector, ResponseBodyUnavailableError } from "./data-collector.js";
-
-const stops: Array<() => void> = [];
-afterEach(() => stops.splice(0).forEach((stop) => stop()));
-
-const failing = (code: string, message = "nope") => Object.assign(new Error(message), { code });
-
-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, { "network.addDataCollector": () => ({ collector: "c1" }), ...handlers }));
-  const commands = (method: string) => ws.sent.filter((m) => m.method === method).map((m) => m.params as any);
-  return { ws, connector, commands };
-}
-
-describe("DataCollector.start", () => {
-  it("collects response bodies of this page, up to maxBodySize", async () => {
-    const { connector, commands } = await setup();
-    await DataCollector.start(connector, "top", { maxBodySize: 5000 });
-    assert.deepEqual(commands("network.addDataCollector"), [
-      { dataTypes: ["response"], maxEncodedDataSize: 5000, contexts: ["top"] },
-    ]);
-  });
-
-  it("defaults to 10 MiB", async () => {
-    const { connector, commands } = await setup();
-    await DataCollector.start(connector, "top");
-    assert.equal(commands("network.addDataCollector")[0].maxEncodedDataSize, 10 * 1024 * 1024);
-  });
-});
-
-describe("DataCollector.read", () => {
-  it("returns a text body as its UTF-8 bytes", async () => {
-    const { connector, commands } = await setup({
-      "network.getData": () => ({ bytes: { type: "string", value: "héllo" } }),
-    });
-    const collector = await DataCollector.start(connector, "top");
-    const body = await collector.read("r1", "https://e.test/x");
-    assert.deepEqual([...body], [...Buffer.from("héllo", "utf8")]);
-    assert.deepEqual(commands("network.getData"), [{ dataType: "response", request: "r1", collector: "c1" }]);
-  });
-
-  it("decodes a base64 body byte for byte", async () => {
-    const bytes = Buffer.from([0, 1, 2, 250, 255]);
-    const { connector } = await setup({
-      "network.getData": () => ({ bytes: { type: "base64", value: bytes.toString("base64") } }),
-    });
-    const collector = await DataCollector.start(connector, "top");
-    assert.deepEqual([...(await collector.read("r1", "u"))], [...bytes]);
-  });
-
-  it("explains missing data: collected too late, or larger than the limit", async () => {
-    const { connector } = await setup({ "network.getData": () => failing("no such network data") });
-    const collector = await DataCollector.start(connector, "top");
-    await assert.rejects(collector.read("r1", "https://e.test/x"), (err: unknown) => {
-      assert.ok(err instanceof ResponseBodyUnavailableError);
-      assert.equal(err.url, "https://e.test/x");
-      assert.match(err.reason, /no body was collected/);
-      assert.match(err.reason, /started after the request/);
-      assert.match(err.reason, /larger than maxBodySize/);
-      assert.match(err.message, /^Response body of https:\/\/e\.test\/x is unavailable: /);
-      return true;
-    });
-  });
-
-  it("says when the data is not there yet", async () => {
-    const { connector } = await setup({ "network.getData": () => failing("unavailable network data") });
-    const collector = await DataCollector.start(connector, "top");
-    await assert.rejects(collector.read("r1", "u"), /not available yet/);
-  });
-
-  it("other browser errors are rethrown as they are", async () => {
-    const { connector } = await setup({ "network.getData": () => failing("unknown error") });
-    const collector = await DataCollector.start(connector, "top");
-    await assert.rejects(collector.read("r1", "u"), { name: "BiDiError", code: "unknown error" });
-  });
-});
-
-describe("DataCollector.release and dispose", () => {
-  it("release frees the browser's copy", async () => {
-    const { connector, commands } = await setup();
-    const collector = await DataCollector.start(connector, "top");
-    await collector.release("r1");
-    assert.deepEqual(commands("network.disownData"), [{ dataType: "response", collector: "c1", request: "r1" }]);
-  });
-
-  it("release never throws: the copy may be gone already", async () => {
-    const { connector } = await setup({ "network.disownData": () => failing("no such network data") });
-    const collector = await DataCollector.start(connector, "top");
-    await assert.doesNotReject(collector.release("r1"));
-  });
-
-  it("dispose removes the collector once", async () => {
-    const { connector, commands } = await setup();
-    const collector = await DataCollector.start(connector, "top");
-    await collector.dispose();
-    await collector.dispose();
-    await tick(5);
-    assert.deepEqual(commands("network.removeDataCollector"), [{ collector: "c1" }]);
-  });
-
-  it("dispose ignores a collector the browser no longer knows", async () => {
-    const { connector } = await setup({ "network.removeDataCollector": () => failing("no such network collector") });
-    const collector = await DataCollector.start(connector, "top");
-    await assert.doesNotReject(collector.dispose());
-  });
-});

package/src/network/data-collector.ts

@@ -1,92 +0,0 @@
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import type { Collector } from "../types/bidi-modules/network.js";
-
-/** How large a response body may be to be kept: 10 MiB */
-const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024;
-
-/** The body of a response cannot be read */
-export class ResponseBodyUnavailableError extends Error {
-  public readonly url: string;
-  public readonly reason: string;
-
-  constructor(url: string, reason: string) {
-    super(`Response body of ${url} is unavailable: ${reason}`);
-    this.name = "ResponseBodyUnavailableError";
-    this.url = url;
-    this.reason = reason;
-  }
-}
-
-/**
- * A browser only keeps response bodies for a request when a data collector was registered before the request
- * started. This registers one for a page and reads bodies through it.
- */
-export class DataCollector {
-  private disposed = false;
-
-  private constructor(
-    private connector: BiDiConnector,
-    private id: Collector,
-  ) {}
-
-  public static async start(
-    connector: BiDiConnector,
-    contextId: string,
-    options: { maxBodySize?: number } = {},
-  ): Promise<DataCollector> {
-    const { collector } = await connector.send("network.addDataCollector", {
-      dataTypes: ["response"],
-      maxEncodedDataSize: options.maxBodySize ?? DEFAULT_MAX_BODY_SIZE,
-      contexts: [contextId],
-    });
-    return new DataCollector(connector, collector);
-  }
-
-  /** The body of the response to request `requestId`; `url` only names it in errors */
-  public async read(requestId: string, url: string): Promise<Buffer> {
-    try {
-      const { bytes } = await this.connector.send("network.getData", {
-        dataType: "response",
-        request: requestId,
-        collector: this.id,
-      });
-      return bytes.type === "base64" ? Buffer.from(bytes.value, "base64") : Buffer.from(bytes.value, "utf8");
-    } catch (err) {
-      if (err instanceof BiDiError && err.code === "no such network data") {
-        throw new ResponseBodyUnavailableError(
-          url,
-          "no body was collected: the collector started after the request, or the response is larger than maxBodySize",
-        );
-      }
-      if (err instanceof BiDiError && err.code === "unavailable network data") {
-        throw new ResponseBodyUnavailableError(url, "the body is not available yet");
-      }
-      throw err;
-    }
-  }
-
-  /** Lets the browser drop its copy of a body that has been read. Never throws */
-  public async release(requestId: string): Promise<void> {
-    try {
-      await this.connector.send("network.disownData", {
-        dataType: "response",
-        collector: this.id,
-        request: requestId,
-      });
-    } catch {
-      // Already gone: nothing left to free
-    }
-  }
-
-  /** Idempotent */
-  public async dispose(): Promise<void> {
-    if (this.disposed) return;
-    this.disposed = true;
-    try {
-      await this.connector.send("network.removeDataCollector", { collector: this.id });
-    } catch (err) {
-      if (!(err instanceof BiDiError && err.code === "no such network collector")) throw err;
-    }
-  }
-}

package/src/network/network-data.browser-test.ts

@@ -1,192 +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, beforeEach, test } from "node:test";
-import { Browser } from "../browser/browser.js";
-import Page from "../browser/page.js";
-import { callFunction } from "../script/call-function.js";
-import { setContent } from "../testing/browser-fixture.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { ResponseBodyUnavailableError } from "./data-collector.js";
-import { ResponseTimeoutError } from "./network-wait.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-const sockets = new Set<Socket>();
-const BINARY = Buffer.from([0, 1, 2, 3, 128, 200, 254, 255]);
-let cachedHits = 0;
-
-before(async () => {
-  server = createServer((req, res) => {
-    const path = (req.url ?? "").split("?")[0];
-    switch (path) {
-      case "/real":
-        res.setHeader("content-type", "text/html; charset=utf-8").end("<!doctype html><body id='b'>héllo document</body>");
-        break;
-      case "/json":
-        res.setHeader("content-type", "application/json").end(JSON.stringify({ users: [{ id: 1, name: "Zoë" }] }));
-        break;
-      case "/text":
-        res.setHeader("content-type", "text/plain; charset=utf-8").end("plain ✓ text");
-        break;
-      case "/binary":
-        res.setHeader("content-type", "application/octet-stream").end(BINARY);
-        break;
-      case "/big":
-        res.setHeader("content-type", "text/plain").end("x".repeat(5000));
-        break;
-      case "/redirect":
-        res.writeHead(302, { location: "/json" }).end();
-        break;
-      case "/cached":
-        cachedHits++;
-        res.setHeader("content-type", "text/plain").setHeader("cache-control", "max-age=600").end(`hit ${cachedHits}`);
-        break;
-      case "/empty":
-        res.writeHead(204).end();
-        break;
-      default:
-        res.setHeader("content-type", "text/plain").end("ok");
-    }
-  });
-  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: 9243, headless: true }));
-  await page.navigateTo(`${base}/real`);
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-});
-
-beforeEach(async () => {
-  await page.setCacheDisabled(false);
-});
-
-const OPTIONS = { timeout: 30000 };
-const connector = () => (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-const run = <T>(source: string) => callFunction<T>(connector(), page.contextId, source);
-const fetchInPage = (path: string) => run(`() => { fetch(${JSON.stringify(base + path)}).catch(() => {}); }`);
-
-test("json() reads a JSON body", OPTIONS, async () => {
-  const response = await page.waitForResponse("**/json", { trigger: () => fetchInPage("/json") });
-  assert.equal(response.status, 200);
-  assert.equal(response.headers["content-type"], "application/json");
-  assert.deepEqual(await response.json(), { users: [{ id: 1, name: "Zoë" }] });
-});
-
-test("text() decodes UTF-8", OPTIONS, async () => {
-  const response = await page.waitForResponse("**/text", { trigger: () => fetchInPage("/text") });
-  assert.equal(await response.text(), "plain ✓ text");
-});
-
-test("body() returns binary content byte for byte", OPTIONS, async () => {
-  const response = await page.waitForResponse("**/binary", { trigger: () => fetchInPage("/binary") });
-  assert.deepEqual([...(await response.body())], [...BINARY]);
-});
-
-test("the body can be read again and again", OPTIONS, async () => {
-  const response = await page.waitForResponse("**/json", { trigger: () => fetchInPage("/json") });
-  const first = await response.text();
-  assert.equal(await response.text(), first);
-  assert.deepEqual(await response.json(), JSON.parse(first));
-});
-
-test("an empty response has an empty body", OPTIONS, async () => {
-  const response = await page.waitForResponse("**/empty", { trigger: () => fetchInPage("/empty") });
-  assert.equal(response.status, 204);
-  assert.equal((await response.body()).length, 0);
-});
-
-test("the document of a navigation has a body too", OPTIONS, async () => {
-  const document = await page.waitForResponse((r) => r.request.resourceType === "document" && r.url.endsWith("/real?doc"), {
-    trigger: async () => {
-      await page.navigateTo(`${base}/real?doc`);
-    },
-  });
-  assert.match(await document.text(), /héllo document/);
-});
-
-test("a redirect response has no body, the target has", OPTIONS, async () => {
-  const seen: string[] = [];
-  const onResponse = (response: { status: number; url: string }) => {
-    if (/\/(redirect|json)$/.test(response.url)) seen.push(`${response.status} ${new URL(response.url).pathname}`);
-  };
-  page.on("response", onResponse);
-  const first = await page.waitForResponse("**/redirect", { trigger: () => fetchInPage("/redirect") });
-  await page.waitForNetworkIdle({ idleTime: 100, timeout: 5000 });
-  page.off("response", onResponse);
-  assert.equal(first.status, 302);
-  await assert.rejects(first.body(), (err: unknown) => {
-    assert.ok(err instanceof ResponseBodyUnavailableError);
-    assert.equal(err.reason, "redirect response");
-    return true;
-  });
-  assert.deepEqual(seen, ["302 /redirect", "200 /json"]);
-});
-
-test("waitForResponse with a click as its trigger", OPTIONS, async () => {
-  await setContent(
-    page,
-    `<button id="load">Load</button>`,
-    `document.getElementById("load").addEventListener("click", () => fetch(${JSON.stringify(base + "/json?click")}));`,
-  );
-  const response = await page.waitForResponse((r) => r.url.endsWith("/json?click"), {
-    trigger: () => page.locator("button[@id='load']").click({ timeout: 5000 }),
-  });
-  assert.equal((await response.json<{ users: unknown[] }>()).users.length, 1);
-});
-
-test("waitForRequest sees the request before its response", OPTIONS, async () => {
-  const request = await page.waitForRequest("**/text?req", { trigger: () => fetchInPage("/text?req") });
-  assert.equal(request.method, "GET");
-  assert.equal(request.url, `${base}/text?req`);
-});
-
-test("a body over maxBodySize is reported as unavailable, with the reason", OPTIONS, async () => {
-  // A second view of the same page, with a small limit
-  const small = new Page(connector(), page.contextId, { network: { maxBodySize: 100 } });
-  try {
-    const response = await small.waitForResponse("**/big", { trigger: () => fetchInPage("/big") });
-    await assert.rejects(response.text(), (err: unknown) => {
-      assert.ok(err instanceof ResponseBodyUnavailableError);
-      assert.match(err.reason, /larger than maxBodySize/);
-      return true;
-    });
-    const fits = await small.waitForResponse("**/text", { trigger: () => fetchInPage("/text") });
-    assert.equal(await fits.text(), "plain ✓ text");
-  } finally {
-    await small.dispose();
-  }
-});
-
-test("waitForResponse times out naming what it waited for", OPTIONS, async () => {
-  await assert.rejects(page.waitForResponse("**/never", { timeout: 300 }), (err: unknown) => {
-    assert.ok(err instanceof ResponseTimeoutError);
-    assert.equal(err.message, 'waitForResponse(): no response matching "**/never" within 300ms');
-    return true;
-  });
-});
-
-test("setCacheDisabled makes every request reach the server", OPTIONS, async () => {
-  const twice = async (path: string) => {
-    cachedHits = 0;
-    await run(`async () => { await (await fetch(${JSON.stringify(base + path)})).text(); await (await fetch(${JSON.stringify(base + path)})).text(); }`);
-    return cachedHits;
-  };
-  assert.equal(await twice("/cached?default"), 1, "the second fetch came from the cache");
-  await page.setCacheDisabled(true);
-  assert.equal(await twice("/cached?bypass"), 2, "with the cache off both fetches hit the server");
-  await page.setCacheDisabled(false);
-  assert.equal(await twice("/cached?again"), 1, "back on");
-});

package/src/network/network-tracker.browser-test.ts

@@ -1,151 +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/browser.js";
-import type Page from "../browser/page.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { callFunction } from "../script/call-function.js";
-import { NetworkIdleTimeoutError } from "./network-tracker.js";
-import type { FailedRequest, NetworkRequest, NetworkResponse } from "./network-tracker.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-const sockets = new Set<Socket>();
-const hits: string[] = [];
-
-before(async () => {
-  server = createServer((req, res) => {
-    hits.push(req.url ?? "");
-    switch (req.url?.split("?")[0]) {
-      case "/":
-        res.setHeader("content-type", "text/html").end("<!doctype html><title>t</title><body>home</body>");
-        break;
-      case "/slow":
-        setTimeout(() => res.setHeader("content-type", "text/plain").end("slow"), 300);
-        break;
-      case "/redirect":
-        res.writeHead(302, { location: "/slow" }).end();
-        break;
-      case "/fail":
-        req.socket.destroy();
-        break;
-      case "/hang":
-        break; // never answers
-      case "/frame":
-        res.setHeader("content-type", "text/html").end('<body>frame<script>fetch("/slow")</script></body>');
-        break;
-      default:
-        res.setHeader("content-type", "text/plain").end("ok");
-    }
-  });
-  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: 9237, headless: true }));
-  await page.navigateTo(`${base}/`, "complete");
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-});
-
-const OPTIONS = { timeout: 30000 };
-const connector = () => (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-const run = (source: string) => callFunction(connector(), page.contextId, source);
-const IDLE = { idleTime: 200, timeout: 10000 };
-
-test("idle waits for the last of several timed requests, then for idleTime", OPTIONS, async () => {
-  await run(`() => {
-    fetch("/slow?a");
-    setTimeout(() => fetch("/slow?b"), 200);
-    setTimeout(() => fetch("/slow?c"), 400);
-  }`);
-  const started = Date.now();
-  await page.waitForNetworkIdle(IDLE);
-  const took = Date.now() - started;
-  // last request starts at ~400ms, takes 300ms, then 200ms of quiet
-  assert.ok(took >= 850, `resolved too early: ${took}ms`);
-  assert.ok(hits.includes("/slow?c"));
-});
-
-test("an already quiet page is idle after idleTime", OPTIONS, async () => {
-  await page.waitForNetworkIdle({ idleTime: 100, timeout: 5000 });
-  const started = Date.now();
-  await page.waitForNetworkIdle({ idleTime: 150, timeout: 5000 });
-  const took = Date.now() - started;
-  assert.ok(took >= 140 && took < 2000, `took ${took}ms`);
-});
-
-test("a redirect chain is followed to its end and linked", OPTIONS, async () => {
-  const requests: NetworkRequest[] = [];
-  const responses: NetworkResponse[] = [];
-  const onRequest = (request: NetworkRequest) => requests.push(request);
-  const onResponse = (response: NetworkResponse) => responses.push(response);
-  page.on("request", onRequest);
-  page.on("response", onResponse);
-  await run(`() => { fetch("/redirect"); }`);
-  await page.waitForNetworkIdle(IDLE);
-  page.off("request", onRequest);
-  page.off("response", onResponse);
-
-  const hops = requests.filter((request) => request.url.includes("/redirect") || request.url.endsWith("/slow"));
-  assert.equal(hops.length, 2);
-  assert.equal(hops[0]!.url, `${base}/redirect`);
-  assert.equal(hops[1]!.url, `${base}/slow`);
-  assert.equal(hops[1]!.redirectedFrom, hops[0]);
-  assert.deepEqual(responses.map((response) => response.status), [302, 200]);
-  assert.equal(responses[1]!.headers["content-type"], "text/plain");
-});
-
-test("a failed request is reported and does not keep the page busy", OPTIONS, async () => {
-  const failed: FailedRequest[] = [];
-  const onFailed = (request: FailedRequest) => failed.push(request);
-  page.on("requestfailed", onFailed);
-  await run(`() => { fetch("/fail").catch(() => {}); }`);
-  await page.waitForNetworkIdle(IDLE);
-  page.off("requestfailed", onFailed);
-  assert.equal(failed.length, 1);
-  assert.equal(failed[0]!.url, `${base}/fail`);
-  assert.ok(failed[0]!.errorText.length > 0);
-});
-
-test("requests of an iframe count towards the page", OPTIONS, async () => {
-  await run(`() => {
-    const frame = document.createElement("iframe");
-    frame.src = "/frame";
-    document.body.appendChild(frame);
-  }`);
-  const started = Date.now();
-  await page.waitForNetworkIdle(IDLE);
-  // frame document, then the frame's own slow fetch (300ms)
-  assert.ok(Date.now() - started >= 450, `resolved before the frame's request finished: ${Date.now() - started}ms`);
-});
-
-test("a request that never ends is named when the wait times out", OPTIONS, async () => {
-  await run(`() => { fetch("/hang").catch(() => {}); }`);
-  await assert.rejects(page.waitForNetworkIdle({ idleTime: 100, timeout: 1000 }), (err) => {
-    assert.ok(err instanceof NetworkIdleTimeoutError);
-    assert.deepEqual(err.last, [`${base}/hang`]);
-    return true;
-  });
-});
-
-test("navigation requests are tracked from the start of the browser", OPTIONS, async () => {
-  const requests: string[] = [];
-  const onRequest = (request: NetworkRequest) => requests.push(`${request.resourceType} ${request.url}`);
-  page.on("request", onRequest);
-  await page.navigateTo(`${base}/?nav`, "complete");
-  await page.waitForNetworkIdle(IDLE);
-  page.off("request", onRequest);
-  assert.ok(requests.includes(`document ${base}/?nav`), requests.join("\n"));
-});