@superblocksteam/sdk-api 0.0.12-body-types → 0.0.12

package/src/integrations/base/request-body.test.ts

@@ -1,402 +0,0 @@
-import { describe, expect, expectTypeOf, it } from "vitest";
-
-import { RestApiBodyDataType } from "@superblocksteam/shared";
-
-import {
-  REDACTED_BINARY_RESPONSE_DATA,
-  RestApiValidationError,
-} from "../../errors.js";
-import { encodeRequestBody, MAX_BINARY_BODY_BYTES } from "./request-body.js";
-import { REST_API_BODY_TYPES, type RestApiBodyType } from "./types.js";
-
-const PNG_BYTES = [137, 80, 78, 71];
-const PNG_BASE64 = Buffer.from(PNG_BYTES).toString("base64");
-const AGENT_REQUEST_CAP_BYTES = 28 * 1024 * 1024;
-
-function arrayBufferFrom(bytes: readonly number[]): ArrayBuffer {
-  const buffer = new ArrayBuffer(bytes.length);
-  new Uint8Array(buffer).set(bytes);
-  return buffer;
-}
-
-function getRestApiValidationError(fn: () => unknown): RestApiValidationError {
-  try {
-    fn();
-  } catch (error) {
-    if (error instanceof RestApiValidationError) return error;
-    throw error;
-  }
-  throw new Error("Expected RestApiValidationError");
-}
-
-function expectBinaryDataRedacted(data: unknown): void {
-  if (data !== REDACTED_BINARY_RESPONSE_DATA) {
-    throw new Error("Expected binary validation data to be redacted");
-  }
-}
-
-describe("encodeRequestBody", () => {
-  it("keeps the public body type contract SDK-owned", () => {
-    expect(REST_API_BODY_TYPES).toEqual([
-      "json",
-      "raw",
-      "formUrlencoded",
-      "multipartForm",
-      "binary",
-    ]);
-    expectTypeOf<RestApiBodyType>().toEqualTypeOf<
-      "json" | "raw" | "formUrlencoded" | "multipartForm" | "binary"
-    >();
-    expect(Object.values(RestApiBodyDataType).sort()).toEqual([
-      "fileForm",
-      "formData",
-      "jsonBody",
-      "rawBody",
-    ]);
-    expect(Object.values(RestApiBodyDataType)).not.toContain("binaryBody");
-    expect(Object.values(RestApiBodyDataType)).not.toContain("formDataBase64");
-  });
-
-  it("preserves default and explicit JSON wire behavior", () => {
-    expect(encodeRequestBody({ body: undefined })).toEqual({
-      injectedHeaders: [],
-    });
-    expect(encodeRequestBody({ body: undefined, bodyType: "json" })).toEqual({
-      injectedHeaders: [],
-    });
-    expect(encodeRequestBody({ body: { amount: 42 } })).toEqual({
-      body: JSON.stringify({ amount: 42 }),
-      bodyType: "jsonBody",
-      injectedHeaders: [],
-    });
-    expect(
-      encodeRequestBody({ body: { amount: 42 }, bodyType: "json" }),
-    ).toEqual({
-      body: JSON.stringify({ amount: 42 }),
-      bodyType: "jsonBody",
-      injectedHeaders: [],
-    });
-  });
-
-  it("rejects invalid JSON and bodyType inputs", () => {
-    expect(() =>
-      encodeRequestBody({ body: Uint8Array.from(PNG_BYTES) }),
-    ).toThrow(/bodyType: "binary"/);
-    const circular: Record<string, unknown> = {};
-    circular.self = circular;
-    for (const body of [circular, 1n, () => undefined]) {
-      expect(() => encodeRequestBody({ body })).toThrow(RestApiValidationError);
-    }
-    for (const bodyType of [
-      "jsonBody",
-      "rawBody",
-      "formData",
-      "fileForm",
-      "binaryBody",
-      "formDataBase64",
-    ]) {
-      expect(() => encodeRequestBody({ body: {}, bodyType })).toThrow(
-        new RegExp(`Unsupported bodyType ${JSON.stringify(bodyType)}`),
-      );
-    }
-  });
-
-  it("passes raw non-empty string bodies through unchanged", () => {
-    expect(
-      encodeRequestBody({ body: "<note>hello</note>", bodyType: "raw" }),
-    ).toEqual({
-      body: "<note>hello</note>",
-      bodyType: "rawBody",
-      injectedHeaders: [],
-    });
-    expect(() => encodeRequestBody({ body: "", bodyType: "raw" })).toThrow(
-      RestApiValidationError,
-    );
-    expect(() =>
-      encodeRequestBody({ body: { value: "hello" }, bodyType: "raw" }),
-    ).toThrow(RestApiValidationError);
-  });
-
-  it("encodes form-urlencoded bodies and injects Content-Type only when absent", () => {
-    expect(
-      encodeRequestBody({
-        body: {
-          amount: 2000,
-          currency: "usd",
-          empty: [],
-          enabled: true,
-          optional: undefined,
-          "metadata[order_id]": "6735",
-          tag: ["vip", "repeat"],
-        },
-        bodyType: "formUrlencoded",
-      }),
-    ).toEqual({
-      body: "amount=2000&currency=usd&enabled=true&metadata%5Border_id%5D=6735&tag=vip&tag=repeat",
-      bodyType: "rawBody",
-      injectedHeaders: [
-        { key: "Content-Type", value: "application/x-www-form-urlencoded" },
-      ],
-    });
-    expect(
-      encodeRequestBody({
-        body: { amount: 2000 },
-        bodyType: "formUrlencoded",
-        headers: { "content-type": "application/custom-form" },
-      }),
-    ).toEqual({
-      body: "amount=2000",
-      bodyType: "rawBody",
-      injectedHeaders: [],
-    });
-  });
-
-  it("rejects invalid form-urlencoded bodies", () => {
-    const invalidBodies = [
-      undefined,
-      [],
-      { "": "missing" },
-      { amount: Number.NaN },
-      { metadata: { orderId: "6735" } },
-      { empty: [] },
-    ];
-    for (const body of invalidBodies) {
-      expect(() =>
-        encodeRequestBody({ body, bodyType: "formUrlencoded" }),
-      ).toThrow(RestApiValidationError);
-    }
-    expect(() =>
-      encodeRequestBody({
-        body: { metadata: { orderId: "6735" } },
-        bodyType: "formUrlencoded",
-      }),
-    ).toThrow(/metadata\[order_id\]/);
-  });
-
-  it.each([
-    ["Uint8Array", Uint8Array.from(PNG_BYTES)],
-    ["ArrayBuffer", arrayBufferFrom(PNG_BYTES)],
-    ["DataView", new DataView(arrayBufferFrom([0, ...PNG_BYTES, 1]), 1, 4)],
-    ["subarray view", Uint8Array.from([0, ...PNG_BYTES, 1]).subarray(1, 5)],
-    ["Buffer", Buffer.from(PNG_BYTES)],
-  ])("base64-encodes exact bytes from %s", (_name, body) => {
-    expect(encodeRequestBody({ body, bodyType: "binary" })).toEqual({
-      body: PNG_BASE64,
-      bodyType: "binaryBody",
-      injectedHeaders: [
-        { key: "Content-Type", value: "application/octet-stream" },
-      ],
-    });
-  });
-
-  it("rejects invalid binary bodies and preserves caller Content-Type", () => {
-    expect(
-      encodeRequestBody({
-        body: Uint8Array.from(PNG_BYTES),
-        bodyType: "binary",
-        headers: { "CONTENT-TYPE": "image/png" },
-      }),
-    ).toEqual({
-      body: PNG_BASE64,
-      bodyType: "binaryBody",
-      injectedHeaders: [],
-    });
-    for (const body of [
-      new ArrayBuffer(0),
-      "not bytes",
-      new Uint8Array(MAX_BINARY_BODY_BYTES + 1),
-    ]) {
-      expect(() => encodeRequestBody({ body, bodyType: "binary" })).toThrow(
-        RestApiValidationError,
-      );
-    }
-  });
-
-  it("keeps the binary request cap below the serialized agent request cap", () => {
-    expect(Math.ceil(MAX_BINARY_BODY_BYTES / 3) * 4).toBeLessThan(
-      AGENT_REQUEST_CAP_BYTES,
-    );
-  });
-
-  it("redacts binary validation data for invalid request bodies", () => {
-    const binaryError = getRestApiValidationError(() =>
-      encodeRequestBody({
-        body: new ArrayBuffer(MAX_BINARY_BODY_BYTES + 1),
-        bodyType: "binary",
-      }),
-    );
-    expectBinaryDataRedacted(binaryError.details.data);
-
-    const multipartError = getRestApiValidationError(() =>
-      encodeRequestBody({
-        body: {
-          file: {
-            value: new Uint8Array(MAX_BINARY_BODY_BYTES + 1),
-            filename: "too-large.bin",
-          },
-        },
-        bodyType: "multipartForm",
-      }),
-    );
-    expectBinaryDataRedacted(multipartError.details.data);
-
-    const invalidPartError = getRestApiValidationError(() =>
-      encodeRequestBody({
-        body: {
-          file: {
-            contentType: "application/octet-stream",
-            filename: "too-large.bin",
-            value: Uint8Array.from(PNG_BYTES),
-          },
-        },
-        bodyType: "multipartForm",
-      }),
-    );
-    expect(invalidPartError.details.data).toEqual({
-      contentType: "application/octet-stream",
-      filename: "too-large.bin",
-      value: REDACTED_BINARY_RESPONSE_DATA,
-    });
-  });
-
-  it("encodes multipart primitive, string-file, and mixed binary file parts", () => {
-    expect(
-      encodeRequestBody({
-        body: { active: true, amount: 42, note: "hello" },
-        bodyType: "multipartForm",
-      }),
-    ).toEqual({
-      bodyType: "formData",
-      formData: [
-        { key: "active", value: "true" },
-        { key: "amount", value: "42" },
-        { key: "note", value: "hello" },
-      ],
-      injectedHeaders: [],
-    });
-    expect(
-      encodeRequestBody({
-        body: {
-          empty: { value: "", filename: "empty.txt" },
-          file: {
-            value: "hello",
-            filename: "hello.txt",
-            contentType: undefined,
-          },
-        },
-        bodyType: "multipartForm",
-      }),
-    ).toEqual({
-      bodyType: "formData",
-      formData: [
-        { key: "empty", value: "", file: { filename: "empty.txt" } },
-        { key: "file", value: "hello", file: { filename: "hello.txt" } },
-      ],
-      injectedHeaders: [],
-    });
-    expect(
-      encodeRequestBody({
-        body: {
-          image: { value: Uint8Array.from(PNG_BYTES), filename: "b.png" },
-          note: "mixed",
-          textFile: { value: "cafe \u00e9", filename: "note.txt" },
-        },
-        bodyType: "multipartForm",
-      }),
-    ).toEqual({
-      bodyType: "formDataBase64",
-      formData: [
-        { key: "image", value: PNG_BASE64, file: { filename: "b.png" } },
-        { key: "note", value: "mixed" },
-        {
-          key: "textFile",
-          value: Buffer.from("cafe \u00e9", "utf8").toString("base64"),
-          file: { filename: "note.txt" },
-        },
-      ],
-      injectedHeaders: [],
-    });
-  });
-
-  it("rejects malformed multipart bodies", () => {
-    expect(() =>
-      encodeRequestBody({
-        body: { file: "hello" },
-        bodyType: "multipartForm",
-        headers: { "Content-Type": "multipart/form-data" },
-      }),
-    ).toThrow(/boundary/);
-    const invalidBodies = [
-      {},
-      { "": "missing" },
-      { file: Uint8Array.from(PNG_BYTES) },
-      {
-        file: {
-          contentType: "image/png",
-          filename: "b.png",
-          value: Uint8Array.from(PNG_BYTES),
-        },
-      },
-      { file: { value: "hello", filename: "" } },
-      {
-        file: {
-          value: new Uint8Array(MAX_BINARY_BODY_BYTES + 1),
-          filename: "too-large.bin",
-        },
-      },
-    ];
-    for (const body of invalidBodies) {
-      expect(() =>
-        encodeRequestBody({ body, bodyType: "multipartForm" }),
-      ).toThrow(RestApiValidationError);
-    }
-    expect(() =>
-      encodeRequestBody({
-        body: { file: { value: "contents" } },
-        bodyType: "multipartForm",
-      }),
-    ).toThrow(/missing required key: filename/);
-    expect(() =>
-      encodeRequestBody({
-        body: {
-          file: {
-            value: "contents",
-            filename: "contents.txt",
-            contentType: "text/plain",
-          },
-        },
-        bodyType: "multipartForm",
-      }),
-    ).toThrow(/unexpected key: contentType/);
-  });
-
-  it("rejects multipart bodies whose total file-part bytes exceed the request budget", () => {
-    const partBytes = Math.floor(MAX_BINARY_BODY_BYTES / 2) + 1;
-    const first = "a".repeat(partBytes);
-    const second = "b".repeat(partBytes);
-
-    expect(() =>
-      encodeRequestBody({
-        body: {
-          first: { value: first, filename: "first.txt" },
-          second: { value: second, filename: "second.txt" },
-        },
-        bodyType: "multipartForm",
-      }),
-    ).toThrow(/20 MiB/);
-  });
-
-  it("rejects raw and multipart field bodies that exceed the request budget", () => {
-    const tooLarge = "x".repeat(MAX_BINARY_BODY_BYTES + 1);
-
-    expect(() =>
-      encodeRequestBody({ body: tooLarge, bodyType: "raw" }),
-    ).toThrow(/request bodies must be 20 MiB or smaller/);
-    expect(() =>
-      encodeRequestBody({
-        body: { csv: tooLarge },
-        bodyType: "multipartForm",
-      }),
-    ).toThrow(/request bodies must be 20 MiB or smaller/);
-  });
-});