@specific.dev/spectest 0.107.1 → 0.107.2

package/dist/harness/ingress-server.js

@@ -113,9 +113,15 @@ export async function startIngressServer(options) {
                 headers.append(incoming.rawHeaders[i], incoming.rawHeaders[i + 1]);
             }
             const method = incoming.method ?? "GET";
+            // An HTTP/1 request without framing has no body. Giving it even an
+            // empty stream makes fetch invent chunked framing upstream (e.g. a
+            // bodyless DELETE then fails Fastify's content-type validation).
+            // Keep explicitly chunked bodies streaming, including empty ones.
+            const hasBody = method !== "GET" && method !== "HEAD"
+                && (headers.has("transfer-encoding") || Number(headers.get("content-length")) > 0);
             const req = new Request(new URL(incoming.url ?? "/", `http://${headers.get("host") ?? "localhost"}`), {
                 method, headers, signal: abort.signal,
-                body: method === "GET" || method === "HEAD" ? undefined : Readable.toWeb(incoming),
+                body: hasBody ? Readable.toWeb(incoming) : undefined,
                 duplex: "half",
             });
             peers.set(req, incoming.socket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.107.1",
+  "version": "0.107.2",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/harness/ingress-server.test.ts

@@ -8,7 +8,7 @@ import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execFileSync } from "node:child_process";
-import { forwardableHeaders, withIngressCors } from "./http-proxy";
+import { forwardableHeaders, upstreamRequestHeaders, withIngressCors } from "./http-proxy";
 import { startIngressServer, type IngressServer } from "./ingress-server";
 import { startTlsTerminator, type TlsTerminator } from "./tls-terminator";
 
@@ -24,8 +24,14 @@ let release: (() => void) | undefined;
 let upstreamClosed: Promise<unknown>;
 
 beforeAll(async () => {
-  upstream = http.createServer((req, res) => {
+  upstream = http.createServer(async (req, res) => {
     const path = req.url!;
+    if (path === "/request") {
+      const body = await bytes(req);
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ method: req.method, headers: req.headers, body: body.toString() }));
+      return;
+    }
     let body = path === "/8960" ? object.subarray(0, 8960) : path === "/gzip" ? compressed : object;
     res.setHeader("content-type", "application/octet-stream");
     res.setHeader("etag", '"original"');
@@ -59,7 +65,8 @@ beforeAll(async () => {
     port: 0, hostname: "127.0.0.1",
     fetch: req => withIngressCors(req, "permissive", async current => {
       const res = await fetch(`http://127.0.0.1:${upstreamPort}${new URL(current.url).pathname}`, {
-        method: current.method, headers: current.headers, signal: current.signal,
+        method: current.method, headers: upstreamRequestHeaders(current.headers, { proto: "http" }),
+        body: current.body, signal: current.signal,
         decompress: false, keepalive: false,
       });
       return new Response(res.body, {
@@ -83,7 +90,7 @@ afterAll(() => {
   if (dir) rmSync(dir, { recursive: true, force: true });
 });
 
-function request(path: string, options: { boundary?: "storage" | "http" | "https"; method?: string; headers?: Record<string, string> } = {}) {
+function request(path: string, options: { boundary?: "storage" | "http" | "https"; method?: string; headers?: Record<string, string>; body?: string } = {}) {
   const boundary = options.boundary ?? "https";
   return new Promise<http.IncomingMessage>((resolve, reject) => {
     const req = (boundary === "https" ? https : http).request({
@@ -93,7 +100,7 @@ function request(path: string, options: { boundary?: "storage" | "http" | "https
     }, resolve);
     req.once("error", reject);
     req.setTimeout(2000, () => req.destroy(new Error("ingress request timed out")));
-    req.end();
+    req.end(options.body);
   });
 }
 
@@ -180,6 +187,51 @@ describe("ingress response framing", () => {
   }
 });
 
+describe("ingress request framing", () => {
+  for (const boundary of ["storage", "http", "https"] as const) {
+    test(`${boundary}: unframed requests do not acquire a chunked body`, async () => {
+      // fetch may send Content-Length: 0 and conceal this regression. Use
+      // node:http methods that send neither length nor transfer encoding.
+      for (const method of ["DELETE", "OPTIONS"]) {
+        const res = await request("/request", { boundary, method });
+        const received = JSON.parse((await bytes(res)).toString());
+        expect(res.statusCode).toBe(200);
+        expect(received.method).toBe(method);
+        // Bun fetch can normalize an absent body to Content-Length: 0.
+        // The direct boundary proves the client itself sent no framing.
+        if (boundary === "storage") expect(received.headers["content-length"]).toBeUndefined();
+        else expect(received.headers["content-length"] ?? "0").toBe("0");
+        expect(received.headers["transfer-encoding"]).toBeUndefined();
+        expect(received.body).toBe("");
+      }
+    });
+
+    test(`${boundary}: explicit zero length stays empty`, async () => {
+      for (const method of ["DELETE", "OPTIONS", "POST", "PUT", "PATCH"]) {
+        const res = await request("/request", { boundary, method, headers: { "content-length": "0" } });
+        const received = JSON.parse((await bytes(res)).toString());
+        expect(received.headers["content-length"]).toBe("0");
+        expect(received.headers["transfer-encoding"]).toBeUndefined();
+        expect(received.body).toBe("");
+      }
+    });
+
+    test(`${boundary}: framed bodies survive, including empty chunked requests`, async () => {
+      for (const body of ["", "request payload"]) {
+        for (const chunked of [false, true]) {
+          const res = await request("/request", { boundary, method: "DELETE", body,
+            headers: chunked ? { "transfer-encoding": "chunked" } : { "content-length": String(Buffer.byteLength(body)) },
+          });
+          const received = JSON.parse((await bytes(res)).toString());
+          expect(received.headers["content-length"]).toBe(chunked ? undefined : String(Buffer.byteLength(body)));
+          expect(received.headers["transfer-encoding"]).toBe(chunked ? "chunked" : undefined);
+          expect(received.body).toBe(body);
+        }
+      }
+    });
+  }
+});
+
 describe("ingress request lifecycle", () => {
   test("streams uploads and preserves the request URL, headers and peer", async () => {
     const server = await startIngressServer({

package/src/harness/ingress-server.ts

@@ -131,9 +131,15 @@ export async function startIngressServer(options: {
         headers.append(incoming.rawHeaders[i], incoming.rawHeaders[i + 1]);
       }
       const method = incoming.method ?? "GET";
+      // An HTTP/1 request without framing has no body. Giving it even an
+      // empty stream makes fetch invent chunked framing upstream (e.g. a
+      // bodyless DELETE then fails Fastify's content-type validation).
+      // Keep explicitly chunked bodies streaming, including empty ones.
+      const hasBody = method !== "GET" && method !== "HEAD"
+        && (headers.has("transfer-encoding") || Number(headers.get("content-length")) > 0);
       const req = new Request(new URL(incoming.url ?? "/", `http://${headers.get("host") ?? "localhost"}`), {
         method, headers, signal: abort.signal,
-        body: method === "GET" || method === "HEAD" ? undefined : Readable.toWeb(incoming) as unknown as ReadableStream<Uint8Array>,
+        body: hasBody ? Readable.toWeb(incoming) as unknown as ReadableStream<Uint8Array> : undefined,
         duplex: "half",
       } as RequestInit);
       peers.set(req, incoming.socket);