buninu-browser 0.2.0 → 0.2.2

package/test/navigation.test.js

@@ -0,0 +1,61 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { createBrowser } from "../lib/headless-shell.js";
+
+let server;
+let browser;
+const posts = [];
+beforeAll(async () => {
+  server = Bun.serve({
+    port: 0,
+    async fetch(request) {
+      const { pathname } = new URL(request.url);
+      const html = (body, init = {}) => new Response(`<!doctype html>${body}`, { ...init, headers: { "content-type": "text/html" } });
+      if (pathname === "/start") return new Response(null, { status: 302, headers: { location: "/dir/form?step=1#top" } });
+      if (pathname === "/dir/form") {
+        // An error status with a page, as some challenge pages come.
+        return html(`<title>form</title><form id="f" action="submit" method="post">
+          <input name="q" value="a b&amp;c"><input type="hidden" name="continue" value="/next"></form>`, { status: 429 });
+      }
+      if (pathname === "/dir/submit") {
+        posts.push({
+          method: request.method,
+          body: await request.text(),
+          type: request.headers.get("content-type"),
+          origin: request.headers.get("origin"),
+          referer: request.headers.get("referer"),
+        });
+        return new Response(null, { status: 303, headers: { location: "/done" } });
+      }
+      if (pathname === "/done") return html(`<title>done ${request.method}</title>`);
+      return new Response("missing", { status: 404 });
+    },
+  });
+  browser = await createBrowser({ spareRenderer: false });
+});
+afterAll(() => {
+  browser?.close();
+  server?.stop(true);
+});
+
+test("a redirected document has the URL it ended on, and its POST form submits there", async () => {
+  const { context } = browser;
+  const origin = `http://127.0.0.1:${server.port}`;
+  await context.navigate(`${origin}/start`);
+  // The final URL, with the request's fragment carried over; relative URLs resolve against it.
+  expect(await context.evaluate(`[location.href, document.baseURI, document.getElementById("f").action]`))
+    .toEqual([`${origin}/dir/form?step=1#top`, `${origin}/dir/form?step=1#top`, `${origin}/dir/submit`]);
+
+  await context.evaluate(`document.getElementById("f").submit()`);
+  const deadline = Date.now() + 10_000;
+  while (await context.title() !== "done GET" && Date.now() < deadline) await Bun.sleep(50);
+  expect(await context.title()).toBe("done GET");
+  expect(posts).toEqual([{
+    method: "POST",
+    body: "q=a+b%26c&continue=%2Fnext",
+    type: "application/x-www-form-urlencoded",
+    origin,
+    referer: `${origin}/dir/form?step=1`,
+  }]);
+  // The 303 after it was followed with a GET, and the document is at its URL.
+  expect(await context.evaluate("location.href")).toBe(`${origin}/done`);
+});

package/test/network-service.test.js

@@ -26,6 +26,8 @@ beforeAll(() => {
           });
         case "/home":
           return new Response("home");
+        case "/moved":
+          return new Response("moved here", { status: 301, headers: { location: "/home", ...cors() } });
         case "/app/deep/set":
           return new Response("ok", { headers: [["set-cookie", "scoped=1"]] });
         case "/api/simple":
@@ -65,6 +67,18 @@ test("follows redirects by hand and stores cookies on every hop", async () => {
   expect(response.headers.some(([name]) => name === "set-cookie")).toBeFalse();
 });
 
+test("a manual redirect gives the page an opaque-redirect response", async () => {
+  seen = [];
+  const network = new NetworkService();
+  const same = await network.pageFetch({ url: local("/moved"), redirect: "manual" }, local("/"));
+  expect(same).toMatchObject({ type: "opaqueredirect", status: 0, url: "", headers: [] });
+  expect(same.body.byteLength).toBe(0);
+  // Cross-origin: the redirect still passes the CORS check.
+  const cross = await network.pageFetch({ url: local(`/moved?allow=${encodeURIComponent(loopback(""))}`), redirect: "manual" }, loopback("/"));
+  expect(cross).toMatchObject({ type: "opaqueredirect", status: 0 });
+  expect(seen.map((entry) => entry.path)).toEqual(["/moved", "/moved"]);
+});
+
 test("applies the default path and SameSite to cross-site requests", async () => {
   seen = [];
   const network = new NetworkService();
@@ -149,6 +163,73 @@ test("preflights non-simple requests and strips forbidden headers", async () =>
   await expect(network.pageFetch({ url: "file:///etc/passwd" }, document)).rejects.toThrow("cannot load file:");
 });
 
+test("coalesces identical subresources, caches fresh bodies, and revalidates ETags", async () => {
+  let freshRequests = 0;
+  let validatedRequests = 0;
+  const network = new NetworkService({ fetch: async (input, init = {}) => {
+    const url = new URL(typeof input === "string" ? input : input.url);
+    const headers = new Headers(init.headers ?? input.headers);
+    if (url.pathname === "/fresh") {
+      freshRequests++;
+      await Bun.sleep(10);
+      return new Response("fresh", { headers: { "cache-control": "public, max-age=60" } });
+    }
+    validatedRequests++;
+    if (headers.get("if-none-match") === '"v1"') return new Response(null, { status: 304 });
+    return new Response("validated", { headers: { "cache-control": "no-cache", etag: '"v1"' } });
+  } });
+  const document = "https://page.test/";
+  const [left, right] = await Promise.all([
+    network.subresource("https://asset.test/fresh", document),
+    network.subresource("https://asset.test/fresh", document),
+  ]);
+  expect([new TextDecoder().decode(left.body), new TextDecoder().decode(right.body), freshRequests])
+    .toEqual(["fresh", "fresh", 1]);
+  await network.subresource("https://asset.test/fresh", document);
+  expect(freshRequests).toBe(1);
+
+  const first = await network.subresource("https://asset.test/revalidate", document);
+  const second = await network.subresource("https://asset.test/revalidate", document);
+  expect([new TextDecoder().decode(first.body), new TextDecoder().decode(second.body), validatedRequests])
+    .toEqual(["validated", "validated", 2]);
+});
+
+test("at most six requests per host are in flight; waiting stylesheets go before scripts", async () => {
+  let active = 0;
+  let peak = 0;
+  const started = [];
+  const gates = [];
+  const network = new NetworkService({ fetch: async (input) => {
+    const url = new URL(typeof input === "string" ? input : input.url);
+    started.push(url.host + url.pathname);
+    if (url.host === "slow.test") {
+      active++;
+      peak = Math.max(peak, active);
+      await new Promise((resolve) => gates.push(resolve));
+      active--;
+    }
+    return new Response("x", { headers: { "cache-control": "no-store" } });
+  } });
+  const document = "https://page.test/";
+  const scripts = Array.from({ length: 8 }, (_, index) => network.subresource(`https://slow.test/s${index}.js`, document, "script"));
+  await Bun.sleep(5);
+  const stylesheet = network.subresource("https://slow.test/late.css", document, "stylesheet");
+  // Another host is not held up by this one's queue.
+  await network.subresource("https://other.test/free.js", document, "script");
+  expect(started.filter((entry) => entry.startsWith("slow.test"))).toHaveLength(6);
+  gates.shift()();
+  await Bun.sleep(5);
+  // The freed slot went to the stylesheet that came after the waiting scripts.
+  expect(started.at(-1)).toBe("slow.test/late.css");
+  while (active || gates.length) {
+    gates.shift()?.();
+    await Bun.sleep(1);
+  }
+  await Promise.all([...scripts, stylesheet]);
+  expect(peak).toBe(6);
+  expect(started.filter((entry) => entry.startsWith("slow.test"))).toHaveLength(9);
+});
+
 /** Opens a page WebSocket and resolves with how it ended. */
 function socketOutcome(socket) {
   return new Promise((resolve) => {