Fix delay + echo endpoint chain

Author: pimterry

package-lock.json

@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/httptoolkit/testserver#readme",
   "dependencies": {
-    "@httptoolkit/util": "^0.1.2",
+    "@httptoolkit/util": "^0.1.9",
     "@peculiar/asn1-ocsp": "^2.6.0",
     "@peculiar/asn1-schema": "^2.6.0",
     "@peculiar/asn1-x509": "^2.6.0",

package.json

@@ -11,15 +11,14 @@ export type HttpHandler = (
     options: {
         path: string;
         query: URLSearchParams;
-        handleRequest: (req: HttpRequest, res: HttpResponse) => void;
     }
 ) => MaybePromise<void>;
 
 export interface HttpEndpoint {
     matchPath: (path: string, hostnamePrefix: string | undefined) => boolean;
     handle: HttpHandler;
-    /** If true, raw connection data will be captured for this endpoint (e.g. for echo) */
     needsRawData?: boolean;
+    getRemainingPath?: (path: string) => string | undefined;
 }
 
 export * from './http/echo.js';

src/endpoints/http-index.ts

@@ -1,36 +1,45 @@
 import { delay } from '@httptoolkit/util';
-import { HttpHandler } from '../http-index.js';
+import { HttpEndpoint, HttpHandler } from '../http-index.js';
 import { buildHttpBinAnythingEndpoint } from '../../httpbin-compat.js';
 
 const matchPath = (path: string) => path.startsWith('/delay/');
 
+const getRemainingPath = (path: string): string | undefined => {
+    const idx = path.indexOf('/', '/delay/'.length);
+    return idx !== -1 ? path.slice(idx) : undefined;
+};
+
+const parseDelaySeconds = (path: string): number => {
+    const idx = path.indexOf('/', '/delay/'.length);
+    const end = idx !== -1 ? idx : path.length;
+    return parseFloat(path.slice('/delay/'.length, end));
+};
+
 const defaultAnythingEndpoint = buildHttpBinAnythingEndpoint({
     fieldFilter: ["url", "args", "form", "data", "origin", "headers", "files"]
 });
 
-const handle: HttpHandler = async (req, res, { path, handleRequest }) => {
-    const followingSlashIndex = path.indexOf('/', '/delay/'.length);
-    const followingUrl = followingSlashIndex !== -1 ? path.slice(followingSlashIndex) : '';
-    const endOfDelay = followingSlashIndex === -1 ? path.length : followingSlashIndex;
-    const delayMs = parseFloat(path.slice('/delay/'.length, endOfDelay));
+const handle: HttpHandler = async (req, res, { path }) => {
+    const delaySeconds = parseDelaySeconds(path);
 
-    if (isNaN(delayMs)) {
+    if (isNaN(delaySeconds)) {
         res.writeHead(400);
         res.end('Invalid delay duration');
+        return;
     }
 
-    await delay(Math.min(delayMs, 10) * 1000); // 10s max
+    const cappedDelayMs = Math.min(delaySeconds, 10) * 1000;
+    await delay(cappedDelayMs);
 
-    if (followingUrl) {
-        req.url = followingUrl;
-        handleRequest(req, res);
-        return;
-    } else {
-        return defaultAnythingEndpoint(req, res);
+    if (getRemainingPath(path)) {
+        return; // Handler continues to next endpoint in chain
     }
-}
 
-export const delayEndpoint = {
+    return defaultAnythingEndpoint(req, res);
+};
+
+export const delayEndpoint: HttpEndpoint = {
     matchPath,
-    handle
-};
+    handle,
+    getRemainingPath
+};

src/endpoints/http/delay.ts

@@ -1,11 +1,48 @@
 import { TLSSocket } from 'tls';
 import * as http from 'http';
 import * as http2 from 'http2';
-import { MaybePromise } from '@httptoolkit/util';
+import { MaybePromise, StatusError } from '@httptoolkit/util';
 
 import { httpEndpoints } from './endpoints/endpoint-index.js';
 import { HttpRequest, HttpResponse } from './endpoints/http-index.js';
 
+const MAX_CHAIN_DEPTH = 10;
+
+function resolveEndpointChain(initialPath: string, hostnamePrefix: string | undefined) {
+    const entries: Array<{ endpoint: typeof httpEndpoints[number]; path: string }> = [];
+    let needsRawData = false;
+    let path: string | undefined = initialPath;
+
+    while (path && entries.length <= MAX_CHAIN_DEPTH) {
+        const endpoint = httpEndpoints.find(ep => ep.matchPath(path!, hostnamePrefix));
+        if (!endpoint) break;
+
+        entries.push({ endpoint, path });
+        needsRawData ||= !!endpoint.needsRawData;
+        path = endpoint.getRemainingPath?.(path);
+    }
+
+    if (path) {
+        throw new StatusError(400, `Endpoint chain exceeded maximum depth with path: ${initialPath}`);
+    }
+
+    return { entries, needsRawData };
+}
+
+function stopRawDataCapture(req: HttpRequest): void {
+    if (req.httpVersion === '2.0') {
+        const stream = (req as any).stream;
+        const session = stream?.session;
+        const capturingStream = session?.socket?.stream;
+        const streamId = stream?.id as number | undefined;
+        if (streamId !== undefined) {
+            capturingStream?.stopCapturingStream?.(streamId);
+        }
+    } else {
+        req.socket.receivedData = undefined;
+    }
+}
+
 const allowCORS = (req: HttpRequest, res: HttpResponse) => {
     const origin = req.headers['origin'];
     if (!origin) return;
@@ -90,49 +127,37 @@ function createHttpRequestHandler(options: {
         }
 
         // Now we begin the various test endpoints themselves:
+
         allowCORS(req, res);
 
         if (req.method === 'OPTIONS') {
             // Handle preflight CORS requests for everything
             res.writeHead(200);
             res.end();
+            return;
         }
 
-        const matchingEndpoint = httpEndpoints.find((endpoint) =>
-            endpoint.matchPath(path, hostnamePrefix)
-        );
-
-        // Stop data capturing unless the endpoint needs it
-        if (!matchingEndpoint || !matchingEndpoint.needsRawData) {
-            if (req.httpVersion === '2.0') {
-                const stream = (req as any).stream;
-                const session = stream?.session;
-                const capturingStream = session?.socket?.stream;
-                const streamId = stream?.id as number | undefined;
-                if (streamId !== undefined) {
-                    capturingStream?.stopCapturingStream?.(streamId);
-                }
-            } else {
-                // HTTP/1: stop capturing and clear buffer
-                req.socket.receivedData = undefined;
-            }
+        const { entries, needsRawData } = resolveEndpointChain(path, hostnamePrefix);
+
+        if (!needsRawData) {
+            stopRawDataCapture(req);
         }
 
-        if (matchingEndpoint) {
-            console.log(`Request to ${path}${
-                hostnamePrefix
-                    ? ` ('${hostnamePrefix}' prefix)`
-                    : ` (${options.rootDomain})`
-            } matched endpoint ${matchingEndpoint.name}`);
-            await matchingEndpoint.handle(req, res, {
-                path,
-                query: url.searchParams,
-                handleRequest
-            });
-        } else {
+        if (entries.length === 0) {
             console.log(`Request to ${path} matched no endpoints`);
             res.writeHead(404);
             res.end(`No handler for ${req.url}`);
+            return;
+        }
+
+        const endpointNames = entries.map(e => e.endpoint.name).join(' → ');
+        console.log(`Request to ${path}${
+            hostnamePrefix ? ` ('${hostnamePrefix}' prefix)` : ` (${options.rootDomain})`
+        } matched: ${endpointNames}`);
+
+        for (const { endpoint, path } of entries) {
+            if (res.writableEnded) return;
+            await endpoint.handle(req, res, { path, query: url.searchParams });
         }
     }
 }
@@ -159,6 +184,9 @@ export function createHttp1Handler(options: {
             if (res.closed) return;
             else if (res.headersSent) {
                 res.destroy();
+            } else if (e instanceof StatusError) {
+                res.writeHead(e.statusCode);
+                res.end(e.message);
             } else {
                 res.writeHead(500);
                 res.end('HTTP handler failed');

src/http-handler.ts

@@ -0,0 +1,118 @@
+import * as net from 'net';
+import * as http2 from 'http2';
+import { expect } from 'chai';
+import { DestroyableServer, makeDestroyable } from 'destroyable-server';
+
+import { createServer } from '../src/server.js';
+
+describe("Delay endpoint", () => {
+
+    let server: DestroyableServer;
+    let serverPort: number;
+
+    beforeEach(async () => {
+        server = makeDestroyable(await createServer({
+            domain: 'localhost'
+        }));
+        await new Promise<void>((resolve) => server.listen(resolve));
+        serverPort = (server.address() as net.AddressInfo).port;
+    });
+
+    afterEach(async () => {
+        await server.destroy();
+    });
+
+    it("delays then returns httpbin-style response", async () => {
+        const start = Date.now();
+        const response = await fetch(`http://localhost:${serverPort}/delay/0.1`);
+        const elapsed = Date.now() - start;
+
+        expect(response.status).to.equal(200);
+        expect(elapsed).to.be.greaterThan(90);
+
+        const body = await response.json();
+        expect(body).to.have.property('url');
+        expect(body).to.have.property('headers');
+    });
+
+    it("rejects invalid delay values", async () => {
+        const response = await fetch(`http://localhost:${serverPort}/delay/notanumber`);
+        expect(response.status).to.equal(400);
+    });
+
+    it("forwards to /status endpoint", async () => {
+        const response = await fetch(`http://localhost:${serverPort}/delay/0.05/status/201`);
+        expect(response.status).to.equal(201);
+    });
+
+    it("rejects excessively deep chains", async () => {
+            const deepPath = '/delay/0.001'.repeat(15) + '/status/200';
+            const response = await fetch(`http://localhost:${serverPort}${deepPath}`);
+            expect(response.status).to.equal(400);
+        });
+
+    describe("forwarding to /echo", () => {
+
+        it("echoes HTTP/1 request data after delay", async () => {
+            const response = await fetch(`http://localhost:${serverPort}/delay/0.05/echo`, {
+                headers: { 'test-header': 'test-value' }
+            });
+
+            expect(response.status).to.equal(200);
+
+            const rawBody = await response.text();
+            // Raw data reflects what was actually sent by the client
+            expect(rawBody).to.include('GET /delay/0.05/echo HTTP/1.1');
+            expect(rawBody).to.include('test-header: test-value');
+        });
+
+        it("echoes HTTP/2 request data after delay", async () => {
+            const client = http2.connect(`http://localhost:${serverPort}`);
+
+            const req = client.request({
+                ':path': '/delay/0.05/echo',
+                ':method': 'GET',
+                'test-header': 'test-value'
+            });
+
+            const [headers, body] = await new Promise<[http2.IncomingHttpHeaders, string]>((resolve, reject) => {
+                let headers: http2.IncomingHttpHeaders;
+                const chunks: Buffer[] = [];
+
+                req.on('response', (h) => { headers = h; });
+                req.on('data', (chunk) => chunks.push(chunk));
+                req.on('end', () => resolve([headers, Buffer.concat(chunks).toString()]));
+                req.on('error', reject);
+            });
+
+            client.close();
+
+            expect(headers[':status']).to.equal(200);
+
+            const lines = body.trim().split('\n');
+            const frames = lines.map(line => JSON.parse(line));
+
+            const headersFrames = frames.filter((f: any) => f.type === 'HEADERS' && f.decoded_headers);
+            expect(headersFrames.length).to.be.greaterThan(0);
+            expect(headersFrames[0].decoded_headers).to.have.property('test-header', 'test-value');
+        });
+
+        it("chains multiple delays before /echo with raw data preserved", async () => {
+            const start = Date.now();
+
+            const response = await fetch(`http://localhost:${serverPort}/delay/0.1/delay/0.1/echo`, {
+                headers: { 'chain-test': 'multi-delay' }
+            });
+
+            expect(response.status).to.equal(200);
+            expect(Date.now() - start).to.be.greaterThan(200);
+
+            const rawBody = await response.text();
+            // Raw data reflects what was actually sent by the client
+            expect(rawBody).to.include('GET /delay/0.1/delay/0.1/echo HTTP/1.1');
+            expect(rawBody).to.include('chain-test: multi-delay');
+        });
+
+    });
+
+});