feat(response): composable response building

Author: nutgaard

src/response-utils.ts

@@ -1,31 +1,79 @@
-import { HandlerArgument, MockHandler, MockHandlerFunction } from './types';
+import {
+  HandlerArgument,
+  MockHandler,
+  MockHandlerFunction,
+  ResponseData
+} from './types';
 
 function execHandler(
   handler: MockHandler,
   args: HandlerArgument
-): Promise<Response> {
+): Promise<ResponseData> {
   if (typeof handler === 'function') {
     return handler(args);
   } else {
     return ResponseUtils.jsonPromise(handler);
   }
 }
 
+function unwrap(
+  args: HandlerArgument
+): (handler: MockHandler) => Promise<ResponseData> {
+  return (handler: MockHandler) => {
+    if (typeof handler === 'function') {
+      return handler(args);
+    } else {
+      return ResponseUtils.jsonPromise(handler);
+    }
+  };
+}
+
+function merge(into: ResponseData, data: ResponseData): ResponseData {
+  return {
+    body: into.body || data.body,
+    status: into.status || data.status,
+    statusText: into.statusText || data.statusText,
+    headers: Object.assign({}, data.headers, into.headers)
+  };
+}
+
 export default class ResponseUtils {
   static json(json: object): MockHandlerFunction {
     return () => ResponseUtils.jsonPromise(json);
   }
 
-  static jsonPromise(json: MockHandler): Promise<Response> {
-    const response: Response = new Response(JSON.stringify(json));
+  static jsonPromise(json: MockHandler): Promise<ResponseData> {
+    const response: ResponseData = { body: JSON.stringify(json) };
     return Promise.resolve(response);
   }
 
   static delayed(delay: number, handler: MockHandler): MockHandler {
     return (args: HandlerArgument) => {
-      return new Promise<Response>(resolve => {
+      return new Promise<ResponseData>(resolve => {
         setTimeout(() => resolve(execHandler(handler, args)), delay);
       });
     };
   }
+
+  static statusCode(status: number): MockHandler {
+    return (args: HandlerArgument) => {
+      const response: ResponseData = { status };
+      return Promise.resolve(response);
+    };
+  }
+
+  static statusText(statusText: string): MockHandler {
+    return (args: HandlerArgument) => {
+      const response: ResponseData = { statusText };
+      return Promise.resolve(response);
+    };
+  }
+
+  static combine(...handlers: MockHandler[]): MockHandler {
+    return (args: HandlerArgument) => {
+      return Promise.all(
+        handlers.map(unwrap(args))
+      ).then((data: ResponseData[]) => data.reduce(merge, {}));
+    };
+  }
 }

src/types.ts

@@ -25,10 +25,19 @@ export interface RouteMatcher {
   matcherUrl?: MatcherUrl;
 }
 
+export interface ResponseData {
+  body?: any;
+  headers?: HeadersInit;
+  status?: number;
+  statusText?: string;
+}
+
 export type MockHandler =
-  | ((args: HandlerArgument) => Promise<Response>)
+  | ((args: HandlerArgument) => Promise<ResponseData>)
   | object;
-export type MockHandlerFunction = (args: HandlerArgument) => Promise<Response>;
+export type MockHandlerFunction = (
+  args: HandlerArgument
+) => Promise<ResponseData>;
 export type RequestUrl = Opaque<'RequestUrl', string>;
 export type MatcherUrl = Opaque<'MatcherUrl', string>;
 
@@ -38,5 +47,8 @@ export interface Route {
 }
 export interface Configuration {
   enableFallback: boolean;
-  middleware: (request: HandlerArgument, response: Response) => Response;
+  middleware: (
+    request: HandlerArgument,
+    response: ResponseData
+  ) => ResponseData;
 }

src/yet-another-fetch-mock.ts

@@ -4,6 +4,7 @@ import {
   MatcherUrl,
   MockHandler,
   RequestUrl,
+  ResponseData,
   Route,
   RouteMatcher
 } from './types';
@@ -86,7 +87,7 @@ class FetchMock {
     const queryParams = findQueryParams(url);
     const body = findBody(input, init);
     let pathParams: object = {};
-    let response: Promise<Response>;
+    let response: Promise<ResponseData>;
 
     if (typeof matchingRoute === 'undefined') {
       if (this.configuration.enableFallback) {
@@ -107,12 +108,21 @@ class FetchMock {
       });
     }
 
-    return response.then(resp =>
-      this.configuration.middleware(
-        { input, init, url, method, queryParams, pathParams, body },
-        resp
+    return response
+      .then(resp =>
+        this.configuration.middleware(
+          { input, init, url, method, queryParams, pathParams, body },
+          resp
+        )
       )
-    );
+      .then(
+        (data: ResponseData) =>
+          new Response(data.body, {
+            status: data.status,
+            statusText: data.statusText,
+            headers: data.headers
+          })
+      );
   }
 
   private findMatchingRoute(

test/yet-another-fetch-mock.test.ts

@@ -169,4 +169,54 @@ describe('FetchMock', () => {
       done();
     });
   });
+
+  it('should support responding with status codes', done => {
+    mock.get('/error', ResponseUtils.statusCode(404));
+
+    fetch('/error').then(resp => {
+      expect(resp.ok).toBe(false);
+      expect(resp.status).toBe(404);
+      done();
+    });
+  });
+
+  it('should be able to combine response utils', done => {
+    mock.get(
+      '/combine',
+      ResponseUtils.combine(
+        ResponseUtils.json({ key: 'value' }),
+        ResponseUtils.statusCode(201)
+      )
+    );
+
+    mock.get(
+      '/combine2',
+      ResponseUtils.combine(
+        ResponseUtils.statusCode(202),
+        { key: 'value2' },
+        ResponseUtils.statusText('Its ok')
+      )
+    );
+
+    const first = fetch('/combine')
+      .then(resp => {
+        expect(resp.status).toBe(201);
+        return resp.json();
+      })
+      .then(json => {
+        expect(json.key).toBe('value');
+      });
+
+    const second = fetch('/combine2')
+      .then(resp => {
+        expect(resp.status).toBe(202);
+        expect(resp.statusText).toBe('Its ok');
+        return resp.json();
+      })
+      .then(json => {
+        expect(json.key).toBe('value2');
+      });
+
+    Promise.all([first, second]).then(() => done());
+  });
 });