buninu-browser 0.2.1 → 0.2.2

package/test/media-source.test.js

@@ -0,0 +1,156 @@
+import { expect, test } from "bun:test";
+import { createMediaSourceScope } from "../lib/renderer/media-source.js";
+
+function scope(options = {}) {
+  const tasks = [];
+  const media = createMediaSourceScope({
+    origin: "https://page.test",
+    schedule: (task) => tasks.push(task),
+    DOMException,
+    ...options,
+  });
+  const flush = () => {
+    while (tasks.length) tasks.shift()();
+  };
+  return { media, flush };
+}
+
+function openBuffer(context) {
+  const source = new context.media.MediaSource();
+  source.attach("blob:https://page.test/media");
+  context.flush();
+  return { source, buffer: source.addSourceBuffer('video/mp4; codecs="avc1.4d401e"') };
+}
+
+function box(type, ...parts) {
+  const size = 8 + parts.reduce((sum, part) => sum + part.byteLength, 0);
+  const bytes = new Uint8Array(size);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, size);
+  for (let index = 0; index < 4; index++) bytes[4 + index] = type.charCodeAt(index);
+  let offset = 8;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.byteLength;
+  }
+  return bytes;
+}
+
+function fragmentedMp4Pieces() {
+  const mdhd = new Uint8Array(20);
+  new DataView(mdhd.buffer).setUint32(12, 1000);
+  const init = box("moov", box("trak", box("mdia", box("mdhd", mdhd))));
+  const segment = (base) => {
+    const tfhd = new Uint8Array(12);
+    tfhd[3] = 8; // default_sample_duration_present
+    new DataView(tfhd.buffer).setUint32(4, 1);
+    new DataView(tfhd.buffer).setUint32(8, 1000);
+    const tfdt = new Uint8Array(8);
+    new DataView(tfdt.buffer).setUint32(4, base);
+    const trun = new Uint8Array(8);
+    new DataView(trun.buffer).setUint32(4, 5);
+    return box("moof", box("traf", box("tfhd", tfhd), box("tfdt", tfdt), box("trun", trun)));
+  };
+  return [init, segment(0), segment(5000)];
+}
+
+test("SourceBuffer.abort is harmless while idle and cancels a pending append", () => {
+  const context = scope();
+  const { buffer } = openBuffer(context);
+  expect(() => buffer.abort()).not.toThrow();
+
+  const events = [];
+  buffer.addEventListener("abort", () => events.push("abort"));
+  buffer.addEventListener("updateend", () => events.push("updateend"));
+  buffer.appendBuffer(new Uint8Array([1, 2, 3]));
+  buffer.abort();
+  context.flush();
+
+  expect(buffer.updating).toBe(false);
+  expect(buffer._pipe.size).toBe(0);
+  expect(events).toEqual(["abort", "updateend"]);
+});
+
+test("removing an old buffered prefix releases append quota", () => {
+  const context = scope({ appendQuota: 10 });
+  const { source, buffer } = openBuffer(context);
+  buffer.appendBuffer(box("mdat", new Uint8Array(2)));
+  context.flush();
+  source.noteBuffered(10);
+
+  expect(() => buffer.appendBuffer(new Uint8Array(1))).toThrow("SourceBuffer is full");
+  buffer.remove(0, 5);
+  context.flush();
+  expect(buffer.buffered.length).toBe(1);
+  expect(buffer.buffered.start(0)).toBe(5);
+  expect(buffer.buffered.end(0)).toBe(10);
+  expect(() => buffer.appendBuffer(new Uint8Array(5))).not.toThrow();
+  context.flush();
+  expect(buffer.updating).toBe(false);
+});
+
+test("fragmented MP4 buffered end follows appended segments, not presentation duration", () => {
+  const context = scope();
+  const { source, buffer } = openBuffer(context);
+  const [init, first, second] = fragmentedMp4Pieces();
+  buffer.appendBuffer(init);
+  context.flush();
+  // Probing an init segment can expose the full presentation duration before
+  // the first media fragment supplies the actual buffered timeline.
+  source.noteBuffered(700);
+  for (const bytes of [first, second]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  expect(buffer.buffered.length).toBe(1);
+  expect(buffer.buffered.end(0)).toBe(10);
+});
+
+test("WebM buffered end follows Cluster timecodes, not presentation duration", () => {
+  const context = scope();
+  const source = new context.media.MediaSource();
+  source.attach("blob:https://page.test/audio");
+  context.flush();
+  const buffer = source.addSourceBuffer('audio/webm; codecs="opus"');
+  // Cluster timecode 0, one SimpleBlock at +1000 ms, with a dummy payload.
+  buffer.appendBuffer(Uint8Array.from([
+    0x1f, 0x43, 0xb6, 0x75, 0x8a,
+    0xe7, 0x81, 0x00,
+    0xa3, 0x85, 0x81, 0x03, 0xe8, 0x00, 0x00,
+  ]));
+  context.flush();
+  source.noteBuffered(700);
+  expect(buffer.buffered.end(0)).toBeCloseTo(1.02, 5);
+});
+
+test("a media element reports the intersection of separate audio and video buffers", () => {
+  const context = scope();
+  const { source, buffer: video } = openBuffer(context);
+  const audio = source.addSourceBuffer('audio/webm; codecs="opus"');
+  video.noteEnd(5);
+  audio.noteEnd(8);
+  expect(source.bufferedEnd()).toBe(5);
+});
+
+test("a media segment appended again is not concatenated twice, while gaps are still filled", () => {
+  const context = scope();
+  const { buffer } = openBuffer(context);
+  const [init, first, second] = fragmentedMp4Pieces();
+  let updates = 0;
+  buffer.addEventListener("updateend", () => updates++);
+  // The second segment arrives first; the first then fills the gap before it.
+  for (const bytes of [init, second, first]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  const size = buffer._pipe.size;
+  expect(size).toBe(init.byteLength + second.byteLength + first.byteLength);
+  // A player retrying both segments on a slow network.
+  for (const bytes of [first, second]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  expect(buffer._pipe.size).toBe(size);
+  expect(updates).toBe(5);
+  expect(buffer.buffered.end(0)).toBe(10);
+});

package/test/media-sync.test.js

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+
+test("renderer follows output progress, not wall time or submitted audio", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/media-sync.js", import.meta.url).pathname], {
+    stdout: "pipe", stderr: "pipe",
+  });
+  const [out, error, code] = await Promise.all([
+    new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+  ]);
+  expect({ code, error }).toEqual({ code: 0, error: "" });
+  expect(out).toContain("media clock integration passed");
+}, 30_000);

package/test/mobile.test.js

@@ -52,8 +52,8 @@ test("--mobile sends the mobile user agent, ignores overrides and applies touch
   });
 }, 30_000);
 
-test("without --mobile nothing changes: overrides apply and touch rules do not", async () => {
-  const state = await pageState({});
+test("Chromium desktop allows overrides and does not apply touch rules", async () => {
+  const state = await pageState({ webkit: false });
   expect(state).toMatchObject({
     requestUserAgent: "Desktop/1.0 (casty override)",
     navigatorUserAgent: "Desktop/1.0 (casty override)",

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();