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

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

@@ -1,17 +1,10 @@
-import { describe, expect, expectTypeOf, it } from "vitest";
+import { describe, expect, it, vi } 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";
+import { RestApiValidationError } from "../../errors.js";
+import { encodeRequestBody } from "./request-body.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);
@@ -19,62 +12,25 @@ function arrayBufferFrom(bytes: readonly number[]): ArrayBuffer {
   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 })).toEqual({ wire: {} });
     expect(encodeRequestBody({ body: undefined, bodyType: "json" })).toEqual({
-      injectedHeaders: [],
+      wire: {},
     });
     expect(encodeRequestBody({ body: { amount: 42 } })).toEqual({
-      body: JSON.stringify({ amount: 42 }),
-      bodyType: "jsonBody",
-      injectedHeaders: [],
+      wire: { body: JSON.stringify({ amount: 42 }), bodyType: "jsonBody" },
     });
     expect(
       encodeRequestBody({ body: { amount: 42 }, bodyType: "json" }),
     ).toEqual({
-      body: JSON.stringify({ amount: 42 }),
-      bodyType: "jsonBody",
-      injectedHeaders: [],
+      wire: { body: JSON.stringify({ amount: 42 }), bodyType: "jsonBody" },
+    });
+    expect(encodeRequestBody({ body: "plain text" })).toEqual({
+      wire: { body: '"plain text"', bodyType: "jsonBody" },
+    });
+    expect(encodeRequestBody({ body: null })).toEqual({
+      wire: { body: "null", bodyType: "jsonBody" },
     });
   });
 
@@ -84,8 +40,15 @@ describe("encodeRequestBody", () => {
     ).toThrow(/bodyType: "binary"/);
     const circular: Record<string, unknown> = {};
     circular.self = circular;
-    for (const body of [circular, 1n, () => undefined]) {
+    expect(() => encodeRequestBody({ body: circular })).toThrow(
+      /the body contains a circular reference/,
+    );
+    expect(() => encodeRequestBody({ body: 1n })).toThrow(
+      /not JSON-serializable/,
+    );
+    for (const body of [() => undefined, Symbol("token")]) {
       expect(() => encodeRequestBody({ body })).toThrow(RestApiValidationError);
+      expect(() => encodeRequestBody({ body })).toThrow(/cannot serialize a/);
     }
     for (const bodyType of [
       "jsonBody",
@@ -99,15 +62,220 @@ describe("encodeRequestBody", () => {
         new RegExp(`Unsupported bodyType ${JSON.stringify(bodyType)}`),
       );
     }
+    // Only an omitted bodyType defaults to "json"; an explicit null is an
+    // invalid value like any other, not a synonym for omission.
+    expect(() => encodeRequestBody({ body: {}, bodyType: null })).toThrow(
+      /Unsupported bodyType null/,
+    );
+  });
+
+  it("classifies a circular body under both V8's and QuickJS's JSON.stringify wording", () => {
+    // Node/V8 throws "Converting circular structure to JSON"; the QuickJS
+    // sandbox sdk-api actually runs in throws "circular reference"
+    // (workers/javascript/packages/quickjs-emscripten vendored quickjs.c).
+    // Both must classify as the same bounded message.
+    for (const message of [
+      "Converting circular structure to JSON",
+      "circular reference",
+    ]) {
+      const stringifySpy = vi
+        .spyOn(JSON, "stringify")
+        .mockImplementationOnce(() => {
+          throw new TypeError(message);
+        });
+      expect(() => encodeRequestBody({ body: {} })).toThrow(
+        /the body contains a circular reference/,
+      );
+      stringifySpy.mockRestore();
+    }
+  });
+
+  it("rejects binary nested inside a JSON body (APPS-2739)", () => {
+    expect(() =>
+      encodeRequestBody({
+        body: { attributes: "{}", file: Uint8Array.from(PNG_BYTES) },
+      }),
+    ).toThrow(
+      /contains binary data at "file"; send file parts with bodyType: "multipartForm"/,
+    );
+    expect(() =>
+      encodeRequestBody({
+        body: {
+          attachments: [{ name: "a" }, { bytes: arrayBufferFrom(PNG_BYTES) }],
+        },
+      }),
+    ).toThrow(/contains binary data at "attachments\.1\.bytes"/);
+  });
+
+  it("rejects binary nested inside a Map or Set value in a JSON body", () => {
+    expect(() =>
+      encodeRequestBody({
+        body: { file: new Map([["bytes", Uint8Array.from(PNG_BYTES)]]) },
+      }),
+    ).toThrow(/contains binary data/);
+    expect(() =>
+      encodeRequestBody({
+        body: { file: new Set([Uint8Array.from(PNG_BYTES)]) },
+      }),
+    ).toThrow(/contains binary data/);
+  });
+
+  it("fails closed instead of silently serializing binary past the scan depth cap", () => {
+    let body: unknown = Uint8Array.from(PNG_BYTES);
+    for (let depth = 0; depth < 105; depth++) {
+      body = { child: body };
+    }
+    expect(() => encodeRequestBody({ body })).toThrow(/contains binary data/);
+  });
+
+  it("bounds the message when a nested getter throws during JSON serialization", () => {
+    const throwingGetter = {
+      get secret(): string {
+        throw new Error("getter boom");
+      },
+    };
+    expect(() => encodeRequestBody({ body: throwingGetter })).toThrow(
+      /not JSON-serializable: a nested value's toJSON, toString, or getter threw/,
+    );
+    let message = "";
+    try {
+      encodeRequestBody({ body: throwingGetter });
+    } catch (error) {
+      message = error instanceof Error ? error.message : "";
+    }
+    expect(message).not.toContain("getter boom");
+  });
+
+  it("keeps caller keys in validation messages bounded and escaped", () => {
+    const longKey = "k".repeat(500);
+    const surrogateKey = "bad\uD800key";
+    const cases: {
+      body: Record<string, unknown>;
+      bodyType: string;
+      expected: RegExp;
+    }[] = [
+      {
+        body: { [longKey]: { nested: true } },
+        bodyType: "formUrlencoded",
+        expected: /is nested/,
+      },
+      {
+        body: { [surrogateKey]: "v" },
+        bodyType: "formUrlencoded",
+        expected: /lone surrogate/,
+      },
+      {
+        body: { [longKey]: Uint8Array.from(PNG_BYTES) },
+        bodyType: "multipartForm",
+        expected: /wrapped as/,
+      },
+      {
+        body: { [surrogateKey]: { value: "x", filename: "f", [longKey]: 1 } },
+        bodyType: "multipartForm",
+        expected: /unexpected key/,
+      },
+    ];
+    for (const { body, bodyType, expected } of cases) {
+      let message = "";
+      try {
+        encodeRequestBody({ body, bodyType });
+      } catch (error) {
+        expect(error).toBeInstanceOf(RestApiValidationError);
+        message = error instanceof Error ? error.message : "";
+      }
+      expect(message).toMatch(expected);
+      expect(message).not.toContain("k".repeat(65));
+      expect(message).not.toContain("\uD800");
+      expect(message.length).toBeLessThan(400);
+    }
+  });
+
+  it("keeps unsupported bodyType messages bounded and free of caller data", () => {
+    expect(() =>
+      encodeRequestBody({ body: {}, bodyType: "x".repeat(500) }),
+    ).toThrow(`"${"x".repeat(64)}..."`);
+    for (const bodyType of [
+      new Uint8Array(50_000),
+      { secret: "s".repeat(1000) },
+    ]) {
+      let caught: unknown;
+      try {
+        encodeRequestBody({ body: {}, bodyType });
+      } catch (error) {
+        caught = error;
+      }
+      if (!(caught instanceof RestApiValidationError)) throw caught;
+      const message = caught.message;
+      expect(message).toMatch(
+        /^Unsupported bodyType (binary data \(50000 bytes\)|object with keys \[secret\])/,
+      );
+      expect(message).not.toContain("s".repeat(10));
+      expect(message.length).toBeLessThan(200);
+      // The mismatch branch must not bypass the module's bounded-error
+      // convention: details.data stays undefined and details.zodError
+      // carries only the already-bounded message, never the raw caller value.
+      expect(caught.details.data).toBeUndefined();
+      const detailMessage = caught.details.zodError.issues[0].message;
+      expect(detailMessage).toBe(message);
+      expect(JSON.stringify(caught.details)).not.toContain("s".repeat(10));
+    }
+  });
+
+  it("bounds caller keys embedded in the zod issue path, not just the message", () => {
+    const longKey = "k".repeat(500);
+    let caught: unknown;
+    try {
+      encodeRequestBody({
+        body: { [longKey]: { nested: true } },
+        bodyType: "formUrlencoded",
+      });
+    } catch (error) {
+      caught = error;
+    }
+    if (!(caught instanceof RestApiValidationError)) throw caught;
+    const path = caught.details.zodError.issues[0].path;
+    expect(JSON.stringify(path)).not.toContain("k".repeat(65));
+    expect(path).toEqual(["body", `${"k".repeat(64)}...`]);
+  });
+
+  it("bounds long keys inside describeOptionValue's object description", () => {
+    const longKey = "k".repeat(10_000);
+    let message = "";
+    try {
+      encodeRequestBody({ body: {}, bodyType: { [longKey]: 1 } });
+    } catch (error) {
+      expect(error).toBeInstanceOf(RestApiValidationError);
+      message = error instanceof Error ? error.message : "";
+    }
+    expect(message).toMatch(/^Unsupported bodyType object with keys/);
+    expect(message).not.toContain("k".repeat(65));
+    expect(message.length).toBeLessThan(200);
+  });
+
+  it("bounds the unexpected-keys list in multipart file-part errors", () => {
+    const extraKeys = Object.fromEntries(
+      Array.from({ length: 50 }, (_, i) => [`extra${i}`, i]),
+    );
+    let message = "";
+    try {
+      encodeRequestBody({
+        body: { file: { value: "hello", filename: "f.txt", ...extraKeys } },
+        bodyType: "multipartForm",
+      });
+    } catch (error) {
+      expect(error).toBeInstanceOf(RestApiValidationError);
+      message = error instanceof Error ? error.message : "";
+    }
+    expect(message).toMatch(/unexpected keys/);
+    expect(message).toContain(", ...");
+    expect(message.length).toBeLessThan(400);
   });
 
   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: [],
+      wire: { body: "<note>hello</note>", bodyType: "rawBody" },
     });
     expect(() => encodeRequestBody({ body: "", bodyType: "raw" })).toThrow(
       RestApiValidationError,
@@ -132,11 +300,11 @@ describe("encodeRequestBody", () => {
         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" },
-      ],
+      wire: {
+        body: "amount=2000&currency=usd&enabled=true&metadata%5Border_id%5D=6735&tag=vip&tag=repeat",
+        bodyType: "rawBody",
+      },
+      contentType: "application/x-www-form-urlencoded",
     });
     expect(
       encodeRequestBody({
@@ -145,12 +313,50 @@ describe("encodeRequestBody", () => {
         headers: { "content-type": "application/custom-form" },
       }),
     ).toEqual({
-      body: "amount=2000",
-      bodyType: "rawBody",
-      injectedHeaders: [],
+      wire: { body: "amount=2000", bodyType: "rawBody" },
     });
   });
 
+  it("drops undefined items from form-urlencoded array values, matching multipart semantics", () => {
+    expect(
+      encodeRequestBody({
+        body: { tags: ["a", undefined, "b"] },
+        bodyType: "formUrlencoded",
+      }).wire.body,
+    ).toBe("tags=a&tags=b");
+    // An array of only undefined items leaves no pairs, same as an empty array.
+    expect(() =>
+      encodeRequestBody({
+        body: { tags: [undefined, undefined] },
+        bodyType: "formUrlencoded",
+      }),
+    ).toThrow(/must encode at least one field/);
+  });
+
+  it("percent-encodes form-urlencoded keys and values with + for spaces", () => {
+    expect(
+      encodeRequestBody({
+        body: {
+          "odd key": "a+b=c&d",
+          scope: "read:orders write:orders",
+          unicode: "caf\u00e9 \u{1F600}",
+        },
+        bodyType: "formUrlencoded",
+      }).wire.body,
+    ).toBe(
+      "odd+key=a%2Bb%3Dc%26d&scope=read%3Aorders+write%3Aorders&unicode=caf%C3%A9+%F0%9F%98%80",
+    );
+  });
+
+  it("percent-encodes characters encodeURIComponent leaves literal but URLSearchParams escapes", () => {
+    expect(
+      encodeRequestBody({
+        body: { "a!b'c(d)e~f*g": "h!i'j(k)l~m*n" },
+        bodyType: "formUrlencoded",
+      }).wire.body,
+    ).toBe("a%21b%27c%28d%29e%7Ef*g=h%21i%27j%28k%29l%7Em*n");
+  });
+
   it("rejects invalid form-urlencoded bodies", () => {
     const invalidBodies = [
       undefined,
@@ -159,6 +365,8 @@ describe("encodeRequestBody", () => {
       { amount: Number.NaN },
       { metadata: { orderId: "6735" } },
       { empty: [] },
+      { message: "truncated mid-emoji \uD83D" },
+      { "\uDC00": "lone low surrogate key" },
     ];
     for (const body of invalidBodies) {
       expect(() =>
@@ -171,6 +379,12 @@ describe("encodeRequestBody", () => {
         bodyType: "formUrlencoded",
       }),
     ).toThrow(/metadata\[order_id\]/);
+    expect(() =>
+      encodeRequestBody({
+        body: { message: "truncated mid-emoji \uD83D" },
+        bodyType: "formUrlencoded",
+      }),
+    ).toThrow(/field "message" contains a lone surrogate/);
   });
 
   it.each([
@@ -181,11 +395,8 @@ describe("encodeRequestBody", () => {
     ["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" },
-      ],
+      wire: { body: PNG_BASE64, bodyType: "binaryBody" },
+      contentType: "application/octet-stream",
     });
   });
 
@@ -197,83 +408,31 @@ describe("encodeRequestBody", () => {
         headers: { "CONTENT-TYPE": "image/png" },
       }),
     ).toEqual({
-      body: PNG_BASE64,
-      bodyType: "binaryBody",
-      injectedHeaders: [],
+      wire: { body: PNG_BASE64, bodyType: "binaryBody" },
     });
-    for (const body of [
-      new ArrayBuffer(0),
-      "not bytes",
-      new Uint8Array(MAX_BINARY_BODY_BYTES + 1),
-    ]) {
+    for (const body of [new ArrayBuffer(0), "not bytes"]) {
       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 parts as formDataBase64 with base64 file parts", () => {
+    const primitives = encodeRequestBody({
+      body: { active: true, amount: 42, note: "hello" },
+      bodyType: "multipartForm",
     });
-  });
-
-  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(primitives).toEqual({
+      wire: {
+        bodyType: "formDataBase64",
+        formData: [
+          { key: "active", value: "true" },
+          { key: "amount", value: "42" },
+          { key: "note", value: "hello" },
+        ],
+      },
     });
+    expect(primitives.wire).not.toHaveProperty("body");
     expect(
       encodeRequestBody({
         body: {
@@ -287,12 +446,17 @@ describe("encodeRequestBody", () => {
         bodyType: "multipartForm",
       }),
     ).toEqual({
-      bodyType: "formData",
-      formData: [
-        { key: "empty", value: "", file: { filename: "empty.txt" } },
-        { key: "file", value: "hello", file: { filename: "hello.txt" } },
-      ],
-      injectedHeaders: [],
+      wire: {
+        bodyType: "formDataBase64",
+        formData: [
+          { key: "empty", value: "", file: { filename: "empty.txt" } },
+          {
+            key: "file",
+            value: Buffer.from("hello", "utf8").toString("base64"),
+            file: { filename: "hello.txt" },
+          },
+        ],
+      },
     });
     expect(
       encodeRequestBody({
@@ -304,18 +468,52 @@ describe("encodeRequestBody", () => {
         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" },
+      wire: {
+        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" },
+          },
+        ],
+      },
+    });
+  });
+
+  it("repeats the key for multipart array values", () => {
+    expect(
+      encodeRequestBody({
+        body: {
+          files: [
+            { value: Uint8Array.from(PNG_BYTES), filename: "a.png" },
+            undefined,
+            { value: "hello", filename: "b.txt" },
+          ],
+          tags: ["x", 2],
         },
-      ],
-      injectedHeaders: [],
+        bodyType: "multipartForm",
+      }),
+    ).toEqual({
+      wire: {
+        bodyType: "formDataBase64",
+        formData: [
+          { key: "files", value: PNG_BASE64, file: { filename: "a.png" } },
+          {
+            key: "files",
+            value: Buffer.from("hello", "utf8").toString("base64"),
+            file: { filename: "b.txt" },
+          },
+          { key: "tags", value: "x" },
+          { key: "tags", value: "2" },
+        ],
+      },
     });
+    expect(() =>
+      encodeRequestBody({ body: { files: [] }, bodyType: "multipartForm" }),
+    ).toThrow(/at least one field/);
   });
 
   it("rejects malformed multipart bodies", () => {
@@ -329,6 +527,7 @@ describe("encodeRequestBody", () => {
     const invalidBodies = [
       {},
       { "": "missing" },
+      { n: Number.NaN },
       { file: Uint8Array.from(PNG_BYTES) },
       {
         file: {
@@ -338,12 +537,6 @@ describe("encodeRequestBody", () => {
         },
       },
       { file: { value: "hello", filename: "" } },
-      {
-        file: {
-          value: new Uint8Array(MAX_BINARY_BODY_BYTES + 1),
-          filename: "too-large.bin",
-        },
-      },
     ];
     for (const body of invalidBodies) {
       expect(() =>
@@ -367,36 +560,6 @@ describe("encodeRequestBody", () => {
         },
         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/);
+    ).toThrow(/unexpected key: "contentType"/);
   });
 });