body_test.ts

// Copyright 2018-2023 the oak authors. All rights reserved. MIT license.

import { RequestBody } from "./body.ts";
import { isHttpError, readAll, Status } from "./deps.ts";
import {
  assert,
  assertEquals,
  assertRejects,
  assertStrictEquals,
} from "./test_deps.ts";
import type { ServerRequestBody } from "./types.d.ts";

const decoder = new TextDecoder();

const multipartContentType =
  `multipart/form-data; boundary=OAK-SERVER-BOUNDARY`;

const multipartFixture = `
--OAK-SERVER-BOUNDARY
Content-Disposition: form-data; name="hello"

world
--OAK-SERVER-BOUNDARY--
`;

function toServerRequestBody(request: Request): [ServerRequestBody, Headers] {
  return [{
    // deno-lint-ignore no-explicit-any
    body: request.body as any,
    readBody: async () => {
      const ab = await request.arrayBuffer();
      return new Uint8Array(ab);
    },
  }, request.headers];
}

Deno.test({
  name: "body - form",
  async fn() {
    const rBody = `foo=bar&bar=1&baz=qux+%2B+quux`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request(
          "http://localhost/index.html",
          {
            body: rBody,
            method: "POST",
            headers: {
              "Content-Type": "application/x-www-form-urlencoded",
              "Content-Length": String(rBody.length),
            },
          },
        ),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "form");
    const actual = await body.value;
    assertEquals(
      Array.from(actual.entries()),
      [["foo", "bar"], ["bar", "1"], ["baz", "qux + quux"]],
    );
  },
});

Deno.test({
  name: "body - form-data",
  async fn() {
    const requestBody = new RequestBody(...toServerRequestBody(
      new Request(
        "http://localhost/index.html",
        {
          body: multipartFixture,
          method: "POST",
          headers: {
            "content-type": multipartContentType,
          },
        },
      ),
    ));
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "form-data");
    const actual = await body.value.read();
    assertEquals(actual.fields, { hello: "world" });
  },
});

Deno.test({
  name: "body - form-data - throws http error",
  async fn() {
    const requestBody = new RequestBody(...toServerRequestBody(
      new Request(
        "http://localhost/index.html",
        {
          body: `BAD BODY`,
          method: "POST",
          headers: {
            "content-type": multipartContentType,
          },
        },
      ),
    ));
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "form-data");
    const err = await assertRejects(async () => {
      await body.value.read();
    });
    assert(isHttpError(err));
    assertEquals(err.status, Status.BadRequest);
  },
});

Deno.test({
  name: "body - json",
  async fn() {
    const rBody = JSON.stringify({ hello: "world" });
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request(
          "http://localhost/index.html",
          {
            body: rBody,
            method: "POST",
            headers: {
              "content-type": "application/json",
              "content-length": String(rBody.length),
            },
          },
        ),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "json");
    assertEquals(await body.value, { hello: "world" });
  },
});

Deno.test({
  name: "body - json - does not parse",
  async fn() {
    const rBody = "{hello: world}";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request(
          "http://localhost/index.html",
          {
            body: rBody,
            method: "POST",
            headers: {
              "content-type": "application/json",
              "content-length": String(rBody.length),
            },
          },
        ),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    const err = await assertRejects(async () => {
      await body.value;
    }, Error);
    assert(isHttpError(err));
    assertEquals(err.status, Status.BadRequest);
  },
});

Deno.test({
  name: "body - bytes",
  async fn() {
    const rBody = `console.log("hello world!");\n`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request(
          "http://localhost/index.html",
          {
            body: rBody,
            method: "POST",
            headers: {
              "content-type": "application/javascript",
              "content-length": String(rBody.length),
            },
          },
        ),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "bytes");
    const actual = await body.value;
    assertEquals(decoder.decode(actual), `console.log("hello world!");\n`);
  },
});

Deno.test({
  name: "body - text",
  async fn() {
    const rBody = "hello";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "text");
    assertEquals(await body.value, "hello");
  },
});

Deno.test({
  name: "body - text - does not decode",
  async fn() {
    const rBody = new Uint8Array([240, 159, 152, 177, 240, 159, 152]);
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    assert(requestBody.has());
    const body = requestBody.get({});
    assert(body.type === "text");
    const err = await assertRejects(() => body.value);
    assert(isHttpError(err));
    assertEquals(err.status, Status.BadRequest);
  },
});

Deno.test({
  name: "body - undefined",
  fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(new Request("http://localhost/index.html")),
    );
    assertEquals(requestBody.has(), false);
    const body = requestBody.get({});
    assert(body.type === "undefined");
    assertEquals(body.value, undefined);
  },
});

Deno.test({
  name: "body - type: reader",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "hello world",
          method: "POST",
          headers: {
            "content-type": "text/plain",
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "reader" });
    assert(body.type === "reader");
    const actual = await readAll(body.value);
    assertEquals(decoder.decode(actual), "hello world");
  },
});

Deno.test({
  name: "body - type: stream",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "hello world",
          method: "POST",
          headers: {
            "content-type": "text/plain",
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "stream" });
    assert(body.type === "stream");
    const actual = await new Response(body.value).text();
    assertEquals(actual, "hello world");
  },
});

Deno.test({
  name: "body - type: form",
  async fn() {
    const rBody = `foo=bar&bar=1&baz=qux+%2B+quux`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "Content-Type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "form" });
    assert(body.type === "form");
    const actual = await body.value;
    assertEquals(
      Array.from(actual.entries()),
      [["foo", "bar"], ["bar", "1"], ["baz", "qux + quux"]],
    );
  },
});

Deno.test({
  name: "body - type: form-data",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: multipartFixture,
          method: "POST",
          headers: {
            "content-type":
              "application/javascript; boundary=OAK-SERVER-BOUNDARY",
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "form-data" });
    assert(body.type === "form-data");
    const actual = await body.value.read();
    assertEquals(actual.fields, { hello: "world" });
  },
});

Deno.test({
  name: "body - type: bytes",
  async fn() {
    const rBody = `console.log("hello world!");\n`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "bytes" });
    assert(body.type === "bytes");
    const actual = await body.value;
    assertEquals(decoder.decode(actual), `console.log("hello world!");\n`);
  },
});

Deno.test({
  name: "body - type: json",
  async fn() {
    const rBody = JSON.stringify({ hello: "world" });
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "json" });
    assert(body.type === "json");
    assertEquals(await body.value, { hello: "world" });
  },
});

Deno.test({
  name: "body - type: text",
  async fn() {
    const rBody = "hello";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get({ type: "text" });
    assert(body.type === "text");
    assertEquals(await body.value, "hello");
  },
});

Deno.test({
  name: "body - type - body undefined",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(new Request("http://localhost/index.html")),
    );
    assertEquals(requestBody.has(), false);
    const body = requestBody.get({ type: "text" });
    assert(body.type === "text");
    assertEquals(await body.value, "");
  },
});

Deno.test({
  name: "body - contentTypes: form",
  async fn() {
    const rBody = `foo=bar&bar=1&baz=qux+%2B+quux`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "Content-Type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get(
      { contentTypes: { form: ["application/javascript"] } },
    );
    assert(body.type === "form");
    const actual = await body.value;
    assertEquals(
      Array.from(actual.entries()),
      [["foo", "bar"], ["bar", "1"], ["baz", "qux + quux"]],
    );
  },
});

Deno.test({
  name: "body - contentTypes: form-data",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: multipartFixture,
          method: "POST",
          headers: {
            "content-type":
              "application/javascript; boundary=OAK-SERVER-BOUNDARY",
          },
        }),
      ),
    );
    const body = requestBody.get(
      { contentTypes: { formData: ["application/javascript"] } },
    );
    assert(body.type === "form-data");
    const actual = await body.value.read();
    assertEquals(actual.fields, { hello: "world" });
  },
});

Deno.test({
  name: "body - contentTypes: bytes",
  async fn() {
    const rBody = `console.log("hello world!");\n`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get({ contentTypes: { bytes: ["text/plain"] } });
    assert(body.type === "bytes");
    const actual = await body.value;
    assertEquals(decoder.decode(actual), `console.log("hello world!");\n`);
  },
});

Deno.test({
  name: "body - contentTypes: json",
  async fn() {
    const rBody = JSON.stringify({ hello: "world" });
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get(
      { contentTypes: { json: ["application/javascript"] } },
    );
    assert(body.type === "json");
    assertEquals(await body.value, { hello: "world" });
  },
});

Deno.test({
  name: "body - contentTypes: text",
  async fn() {
    const rBody = "hello";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const body = requestBody.get(
      { contentTypes: { text: ["application/javascript"] } },
    );
    assert(body.type === "text");
    assertEquals(await body.value, "hello");
  },
});

Deno.test({
  name: "body - multiple gets memoized",
  fn() {
    const rBody = `console.log("hello world!");\n`;
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: rBody,
          method: "POST",
          headers: {
            "content-type": "application/javascript",
            "content-length": String(rBody.length),
          },
        }),
      ),
    );
    const a = requestBody.get({});
    const b = requestBody.get({});
    assertStrictEquals(a.type, b.type);
    assertStrictEquals(a.value, b.value);
    assert(a !== b);
  },
});

Deno.test({
  name: "body - can get different types",
  async fn() {
    const body = JSON.stringify({ hello: "world" });
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body,
          method: "POST",
          headers: {
            "content-type": "application/json",
            "content-length": String(body.length),
          },
        }),
      ),
    );
    const textBody = requestBody.get({ type: "text" });
    assert(textBody.type === "text");
    assertEquals(await textBody.value, body);
    const bodyJson = requestBody.get({});
    assert(bodyJson.type === "json");
    assertEquals(await bodyJson.value, { hello: "world" });
  },
});

Deno.test({
  name: "body - multiple streams",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "hello world",
          method: "POST",
          headers: {
            "content-type": "text/plain",
          },
        }),
      ),
    );
    const a = requestBody.get({ type: "stream" });
    const b = requestBody.get({ type: "stream" });
    assert(a.type === "stream");
    assert(b.type === "stream");
    const textA = await new Response(a.value).text();
    const textB = await new Response(b.value).text();
    assertEquals(textA, textB);
  },
});

Deno.test({
  name: "body - decode JSON with null body",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", { method: "POST" }),
      ),
    );
    const actual = requestBody.get({ type: "json" });
    assertEquals(actual.type, "json");
    assertEquals(await actual.value, null);
  },
});

Deno.test({
  name:
    "body - default limit, 0 content-length (content-length greater than or equal to zero is a valid value - https://datatracker.ietf.org/doc/html/rfc2616#section-14.13)",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "",
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": "0",
          },
        }),
      ),
    );
    const actual = requestBody.get({ type: "text" });
    assertEquals(await actual.value, "");
  },
});

Deno.test({
  name: "body - limit set to 0",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "hello world",
          method: "POST",
          headers: {
            "content-type": "text/plain",
          },
        }),
      ),
    );
    const actual = requestBody.get({ type: "text", limit: 0 });
    assertEquals(await actual.value, "hello world");
  },
});

Deno.test({
  name: "body - limit set to Infinity",
  async fn() {
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body: "hello world",
          method: "POST",
          headers: {
            "content-type": "text/plain",
          },
        }),
      ),
    );
    const actual = requestBody.get({ type: "text", limit: Infinity });
    assertEquals(await actual.value, "hello world");
  },
});

Deno.test({
  name: "body - limit set to 1000",
  async fn() {
    const body = "hello world";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(body.length),
          },
        }),
      ),
    );
    const actual = requestBody.get({ type: "text", limit: 1000 });
    assertEquals(await actual.value, "hello world");
  },
});

Deno.test({
  name: "body - exceeds limit",
  async fn() {
    const body = "hello world";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(body.length),
          },
        }),
      ),
    );
    const actual = requestBody.get({ type: "text", limit: 2 });
    const err = await assertRejects(
      async () => {
        await actual.value;
      },
    );
    assert(isHttpError(err));
    assertEquals(err.status, Status.BadRequest);
    assertEquals(err.message, `Body exceeds a limit of 2.`);
  },
});

Deno.test({
  name: "body - exceeds limit but can retrieve with different limit",
  async fn() {
    const body = "hello world";
    const requestBody = new RequestBody(
      ...toServerRequestBody(
        new Request("http://localhost/index.html", {
          body,
          method: "POST",
          headers: {
            "content-type": "text/plain",
            "content-length": String(body.length),
          },
        }),
      ),
    );
    let actual = requestBody.get({ type: "text", limit: 2 });
    const err = await assertRejects(
      async () => {
        await actual.value;
      },
    );
    assert(isHttpError(err));
    assertEquals(err.status, Status.BadRequest);
    assert(err.message.includes("Body exceeds a limit of "));
    actual = requestBody.get();
    assertEquals(await actual.value, "hello world");
  },
});