gerbeur/api/test/remote/fetch.test.ts

import { stubNetwork } from "../helpers.ts";
import { assert, assertEquals, assertFalse, assertRejects } from "@std/assert";
import {
  fetchWithTimeout,
  isValidHttpUrl,
  readTextCapped,
} from "../../remote/fetch.ts";

Deno.test("isValidHttpUrl: http(s) to public hosts, or our own pages", () => {
  assert(isValidHttpUrl("https://example.com/x"));
  assert(isValidHttpUrl("http://gerbeur.test/dumps/abc"));
  assertFalse(isValidHttpUrl("http://localhost:8000/"));
  assertFalse(isValidHttpUrl("http://10.0.0.1/"));
  assertFalse(isValidHttpUrl("file:///etc/passwd"));
  assertFalse(isValidHttpUrl("nope"));
});

Deno.test("fetchWithTimeout: the deadline covers a body that never ends", async () => {
  // Headers at once, then a trickle that never finishes: the read must fail
  // at the deadline rather than hold the request open.
  using _net = stubNetwork((_url, init) =>
    new Response(
      new ReadableStream({
        start(controller) {
          controller.enqueue(new TextEncoder().encode("<html>"));
          init?.signal?.addEventListener(
            "abort",
            () => controller.error(new DOMException("aborted", "AbortError")),
          );
        },
      }),
      { headers: { "content-type": "text/html" } },
    )
  );
  const res = await fetchWithTimeout("https://example.com/slow", 50);
  await assertRejects(() => res.text());
});

Deno.test("readTextCapped: stops reading at the cap", async () => {
  let pulled = 0;
  const body = new ReadableStream<Uint8Array>({
    pull(controller) {
      pulled++;
      controller.enqueue(new TextEncoder().encode("abcdefghij"));
    },
  });
  const text = await readTextCapped(new Response(body), 25);
  assertEquals(text, "abcdefghijabcdefghijabcde");
  assert(pulled < 10);
  assertEquals(await readTextCapped(new Response("short")), "short");
});

Deno.test("fetchWithTimeout: follows redirects, checking every hop", async () => {
  using net = stubNetwork((url) => {
    if (url.pathname === "/start") {
      return new Response(null, { status: 302, headers: { location: "/end" } });
    }
    if (url.pathname === "/to-private") {
      return new Response(null, {
        status: 301,
        headers: { location: "http://169.254.169.254/latest/meta-data" },
      });
    }
    if (url.pathname === "/loop") {
      return new Response(null, {
        status: 302,
        headers: { location: "/loop" },
      });
    }
    return new Response("done");
  });
  const res = await fetchWithTimeout("https://example.com/start");
  assertEquals(await res.text(), "done");
  assertEquals(net.calls.map((u) => u.pathname), ["/start", "/end"]);

  await assertRejects(
    () => fetchWithTimeout("https://example.com/to-private"),
    Error,
    "private",
  );
  await assertRejects(
    () => fetchWithTimeout("https://example.com/loop"),
    TypeError,
    "Too many redirects",
  );
  await assertRejects(
    () => fetchWithTimeout("ftp://example.com/"),
    TypeError,
    "Unsupported protocol",
  );
});