Add support for trailers in thenReply simple handlers

Author: pimterry

src/rules/requests/request-handler-definitions.ts

@@ -271,18 +271,29 @@ export class SimpleHandlerDefinition extends Serializable implements RequestHand
         public status: number,
         public statusMessage?: string,
         public data?: string | Uint8Array | Buffer | SerializedBuffer,
-        public headers?: Headers
+        public headers?: Headers,
+        public trailers?: Trailers
     ) {
         super();
 
         validateCustomHeaders({}, headers);
+        validateCustomHeaders({}, trailers);
+
+        if (!_.isEmpty(trailers) && !_.isEmpty(headers)) {
+            if (!Object.entries(headers!).some(([key, value]) =>
+                key.toLowerCase() === 'transfer-encoding' && value === 'chunked'
+            )) {
+                throw new Error("Trailers can only be set when using chunked transfer encoding");
+            }
+        }
     }
 
     explain() {
         return `respond with status ${this.status}` +
             (this.statusMessage ? ` (${this.statusMessage})`: "") +
             (this.headers ? `, headers ${JSON.stringify(this.headers)}` : "") +
-            (this.data ? ` and body "${this.data}"` : "");
+            (this.data ? ` and body "${this.data}"` : "") +
+            (this.trailers ? `then trailers ${JSON.stringify(this.trailers)}` : "");
     }
 }
 

src/rules/requests/request-handlers.ts

@@ -162,6 +162,10 @@ export class SimpleHandler extends SimpleHandlerDefinition {
             this.data = Buffer.from(<any> this.data);
         }
 
+        if (this.trailers) {
+            response.addTrailers(this.trailers);
+        }
+
         response.end(this.data || "");
     }
 }

src/rules/requests/request-rule-builder.ts

@@ -1,7 +1,7 @@
 import { merge, isString, isBuffer } from "lodash";
 import { Readable } from "stream";
 
-import { Headers, CompletedRequest, Method, MockedEndpoint } from "../../types";
+import { Headers, CompletedRequest, Method, MockedEndpoint, Trailers } from "../../types";
 import type { RequestRuleData } from "./request-rule";
 
 import {
@@ -87,10 +87,10 @@ export class RequestRuleBuilder extends BaseRuleBuilder {
 
     /**
      * Reply to matched requests with a given status code and (optionally) status message,
-     * body and headers.
+     * body, headers & trailers.
      *
      * If one string argument is provided, it's used as the body. If two are
-     * provided (even if one is empty), then 1st is the status message, and
+     * provided (even if one is empty) then the 1st is the status message, and
      * the 2nd the body. If no headers are provided, only the standard required
      * headers are set, e.g. Date and Transfer-Encoding.
      *
@@ -104,32 +104,49 @@ export class RequestRuleBuilder extends BaseRuleBuilder {
      *
      * @category Responses
      */
-    thenReply(status: number, data?: string | Buffer, headers?: Headers): Promise<MockedEndpoint>;
+    thenReply(
+        status: number,
+        data?: string | Buffer,
+        headers?: Headers,
+        trailers?: Trailers
+    ): Promise<MockedEndpoint>;
     thenReply(
         status: number,
         statusMessage: string,
         data: string | Buffer,
-        headers?: Headers
+        headers?: Headers,
+        trailers?: Trailers
     ): Promise<MockedEndpoint>
     thenReply(
         status: number,
         dataOrMessage?: string | Buffer,
         dataOrHeaders?: string | Buffer | Headers,
-        headers?: Headers
+        headersOrTrailers?: Headers | Trailers,
+        trailers?: Trailers
     ): Promise<MockedEndpoint> {
         let data: string | Buffer | undefined;
         let statusMessage: string | undefined;
+        let headers: Headers | undefined;
+
         if (isBuffer(dataOrHeaders) || isString(dataOrHeaders)) {
             data = dataOrHeaders as (Buffer | string);
             statusMessage = dataOrMessage as string;
+            headers = headersOrTrailers as Headers;
         } else {
             data = dataOrMessage as string | Buffer | undefined;
             headers = dataOrHeaders as Headers | undefined;
+            trailers = headersOrTrailers as Trailers | undefined;
         }
 
         const rule: RequestRuleData = {
             ...this.buildBaseRuleData(),
-            handler: new SimpleHandlerDefinition(status, statusMessage, data, headers)
+            handler: new SimpleHandlerDefinition(
+                status,
+                statusMessage,
+                data,
+                headers,
+                trailers
+            )
         };
 
         return this.addRule(rule);

test/integration/handlers/fixed-response.spec.ts

@@ -1,5 +1,7 @@
+import * as http from 'http';
+
 import { getLocal } from "../../..";
-import { expect, fetch, isNode } from "../../test-utils";
+import { expect, fetch, isNode, nodeOnly } from "../../test-utils";
 
 describe("Simple fixed response handler", function () {
 
@@ -74,6 +76,37 @@ describe("Simple fixed response handler", function () {
         expect(response.headers.get('Transfer-Encoding')).to.equal(null);
     });
 
+    nodeOnly(() => { // Browsers can't read trailers
+        it("should allow mocking everything with trailers too", async () => {
+            await server.forGet("/mocked-endpoint").thenReply(200, "status message", "body", {
+                "header": "hello",
+                "Transfer-Encoding": "chunked" // Required to send trailers
+            }, {
+                "trailer": "goodbye"
+            });
+
+            const response = await new Promise<http.IncomingMessage>((resolve, reject) => {
+                const req = http.request(server.urlFor("/mocked-endpoint")).end();
+                req.on('response', (res) => {
+                    // Wait until everything is 100% done, so we definitely have trailers
+                    res.resume();
+                    res.on('end', () => resolve(res));
+                });
+                req.on('error', reject);
+            });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.statusMessage).to.equal('status message');
+            expect(response.headers).to.deep.equal({
+                'header': 'hello',
+                'transfer-encoding': 'chunked'
+            });
+            expect(response.trailers).to.deep.equal({
+                'trailer': 'goodbye'
+            });
+        });
+    });
+
     it("should not allow mocking HTTP/2 pseudoheaders", async function () {
         await expect(() =>
             server.forGet("/mocked-endpoint")