feat(MockHandler): Allows (HandlerArguments) => JSONValue as MockHandler

fix #1

Author: nutgaard

src/internal-utils.ts

@@ -1,45 +1,41 @@
 import * as queryString from 'query-string';
-import { HttpMethod, MatcherUrl, RequestUrl } from './types';
+import {
+  HandlerArgument,
+  HttpMethod,
+  MatcherUrl,
+  MockHandler,
+  MockHandlerFunction,
+  RequestUrl,
+  ResponseData
+} from './types';
 import pathToRegex, { Key } from 'path-to-regexp';
+import ResponseUtils from './response-utils';
 
-export function findRequestUrl(
-  input: RequestInfo,
-  init?: RequestInit
-): RequestUrl {
+export function findRequestUrl(input: RequestInfo, init?: RequestInit): RequestUrl {
   if (typeof input === 'string') {
     return input as RequestUrl;
   } else {
     return input.url as RequestUrl;
   }
 }
 
-export function findRequestMethod(
-  input: RequestInfo,
-  init?: RequestInit
-): HttpMethod {
+export function findRequestMethod(input: RequestInfo, init?: RequestInit): HttpMethod {
   if (typeof input === 'string') {
     return ((init && init.method) || 'GET') as HttpMethod;
   } else {
     return input.method as HttpMethod;
   }
 }
 
-export function findPathParams(
-  requestUrl: RequestUrl,
-  matcherUrl?: MatcherUrl
-): object {
+export function findPathParams(requestUrl: RequestUrl, matcherUrl?: MatcherUrl): object {
   if (!matcherUrl) {
     return {};
   }
 
-  const urlWithoutQueryParams: RequestUrl = requestUrl.split(
-    '?'
-  )[0] as RequestUrl;
+  const urlWithoutQueryParams: RequestUrl = requestUrl.split('?')[0] as RequestUrl;
   const keys: Key[] = [];
   const matcherRegex: RegExp = pathToRegex(matcherUrl, keys);
-  const match: RegExpExecArray | null = matcherRegex.exec(
-    urlWithoutQueryParams
-  );
+  const match: RegExpExecArray | null = matcherRegex.exec(urlWithoutQueryParams);
 
   const sources = keys.map((key, index) => ({
     [key.name]: match && match[index + 1]
@@ -62,3 +58,25 @@ export function findBody(input: RequestInfo, init?: RequestInit) {
     return init.body;
   }
 }
+
+export function testPromise(data: any): boolean {
+  return Promise.resolve(data) == data; // tslint:disable-line
+}
+
+export function toMockHandlerFunction(handler: MockHandler): MockHandlerFunction {
+  if (typeof handler === 'function') {
+    return (args: HandlerArgument) =>
+      new Promise<ResponseData>((resolve, reject) => {
+        const result = handler(args);
+        const isPromise = testPromise(result);
+        if (isPromise) {
+          resolve(result as Promise<ResponseData>);
+        } else {
+          const response: ResponseData = { body: JSON.stringify(result) } as ResponseData;
+          resolve(response);
+        }
+      });
+  } else {
+    return ResponseUtils.json(handler);
+  }
+}

src/response-utils.ts

@@ -1,27 +1,37 @@
 import {
   HandlerArgument,
+  JSONValue,
   MockHandler,
   MockHandlerFunction,
   ResponseData
 } from './types';
+import { testPromise } from './internal-utils';
 
-function execHandler(
-  handler: MockHandler,
-  args: HandlerArgument
-): Promise<ResponseData> {
+function execHandler(handler: MockHandler, args: HandlerArgument): Promise<ResponseData> {
   if (typeof handler === 'function') {
-    return handler(args);
+    let result = handler(args);
+    const isPromise = testPromise(result);
+    if (isPromise) {
+      return result as Promise<ResponseData>;
+    } else {
+      return Promise.resolve({ body: result } as ResponseData);
+    }
   } else {
     return ResponseUtils.jsonPromise(handler);
   }
 }
 
-function unwrap(
-  args: HandlerArgument
-): (handler: MockHandler) => Promise<ResponseData> {
+function unwrap(args: HandlerArgument): (handler: MockHandler) => Promise<ResponseData> {
   return (handler: MockHandler) => {
     if (typeof handler === 'function') {
-      return handler(args);
+      const result = handler(args);
+      const isPromise = testPromise(result);
+
+      if (isPromise) {
+        return result as Promise<ResponseData>;
+      }
+
+      return Promise.resolve({ body: result } as ResponseData);
     } else {
       return ResponseUtils.jsonPromise(handler);
     }
@@ -34,16 +44,16 @@ function merge(into: ResponseData, data: ResponseData): ResponseData {
     status: into.status || data.status,
     statusText: into.statusText || data.statusText,
     headers: Object.assign({}, data.headers, into.headers)
-  };
+  } as ResponseData;
 }
 
 export default class ResponseUtils {
-  static json(json: object): MockHandlerFunction {
+  static json(json: JSONValue): MockHandlerFunction {
     return () => ResponseUtils.jsonPromise(json);
   }
 
   static jsonPromise(json: MockHandler): Promise<ResponseData> {
-    const response: ResponseData = { body: JSON.stringify(json) };
+    const response: ResponseData = { body: JSON.stringify(json) } as ResponseData;
     return Promise.resolve(response);
   }
 
@@ -57,23 +67,23 @@ export default class ResponseUtils {
 
   static statusCode(status: number): MockHandler {
     return (args: HandlerArgument) => {
-      const response: ResponseData = { status };
+      const response: ResponseData = { status } as ResponseData;
       return Promise.resolve(response);
     };
   }
 
   static statusText(statusText: string): MockHandler {
     return (args: HandlerArgument) => {
-      const response: ResponseData = { statusText };
+      const response: ResponseData = { statusText } as ResponseData;
       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, {}));
+      return Promise.all(handlers.map(unwrap(args))).then((data: ResponseData[]) =>
+        data.reduce(merge, {} as ResponseData)
+      );
     };
   }
 }

src/types.ts

@@ -1,5 +1,9 @@
 export type Opaque<K, T> = T & { __TYPE__: K };
 
+export type JSONValue = string | number | boolean | JSONObject | JSONArray;
+export type JSONObject = { [member: string]: JSONValue };
+export interface JSONArray extends Array<JSONValue> {}
+
 export type HttpMethod =
   | 'GET'
   | 'HEAD'
@@ -34,10 +38,10 @@ export interface ResponseData {
 
 export type MockHandler =
   | ((args: HandlerArgument) => Promise<ResponseData>)
-  | object;
-export type MockHandlerFunction = (
-  args: HandlerArgument
-) => Promise<ResponseData>;
+  | ((args: HandlerArgument) => JSONValue)
+  | JSONValue;
+
+export type MockHandlerFunction = (args: HandlerArgument) => Promise<ResponseData>;
 export type RequestUrl = Opaque<'RequestUrl', string>;
 export type MatcherUrl = Opaque<'MatcherUrl', string>;
 

src/yet-another-fetch-mock.ts

@@ -13,21 +13,18 @@ import {
   findPathParams,
   findQueryParams,
   findRequestMethod,
-  findRequestUrl
+  findRequestUrl,
+  toMockHandlerFunction
 } from './internal-utils';
 import MatcherUtils from './matcher-utils';
-import ResponseUtils from './response-utils';
 
 const defaultConfiguration: Configuration = {
   enableFallback: true,
   middleware: (request, response) => response
 };
 
 class FetchMock {
-  private realFetch: (
-    input: RequestInfo,
-    init?: RequestInit
-  ) => Promise<Response>;
+  private realFetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
   private configuration: Configuration;
   private routes: Route[];
   private scope: GlobalFetch;
@@ -40,9 +37,7 @@ class FetchMock {
     this.scope.fetch = this.fetchproxy.bind(this);
   }
 
-  static configure(
-    configuration: Partial<Configuration> = defaultConfiguration
-  ): FetchMock {
+  static configure(configuration: Partial<Configuration> = defaultConfiguration): FetchMock {
     return new FetchMock(window, configuration);
   }
 
@@ -67,21 +62,11 @@ class FetchMock {
   }
 
   mock(matcher: RouteMatcher, handler: MockHandler) {
-    if (typeof handler === 'function') {
-      this.routes.push({ matcher, handler });
-    } else {
-      this.routes.push({ matcher, handler: ResponseUtils.json(handler) });
-    }
+    this.routes.push({ matcher, handler: toMockHandlerFunction(handler) });
   }
 
-  private fetchproxy(
-    input: RequestInfo,
-    init?: RequestInit
-  ): Promise<Response> {
-    const matchingRoute: Route | undefined = this.findMatchingRoute(
-      input,
-      init
-    );
+  private fetchproxy(input: RequestInfo, init?: RequestInit): Promise<Response> {
+    const matchingRoute: Route | undefined = this.findMatchingRoute(input, init);
     const url: RequestUrl = findRequestUrl(input, init);
     const method: HttpMethod = findRequestMethod(input, init);
     const queryParams = findQueryParams(url);
@@ -121,10 +106,7 @@ class FetchMock {
       );
   }
 
-  private findMatchingRoute(
-    input: RequestInfo,
-    init?: RequestInit
-  ): Route | undefined {
+  private findMatchingRoute(input: RequestInfo, init?: RequestInit): Route | undefined {
     return this.routes.find((route: Route) => {
       return route.matcher.test(input, init);
     });

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

@@ -85,15 +85,9 @@ describe('FetchMock', () => {
     mock.post('/post', { key: 'post' });
     mock.delete('/delete', { key: 'delete' });
     mock.put('/put', { key: 'put' });
-    mock.mock(
-      MatcherUtils.combine(
-        MatcherUtils.method('HEAD'),
-        MatcherUtils.url('/head')
-      ),
-      {
-        key: 'head'
-      }
-    );
+    mock.mock(MatcherUtils.combine(MatcherUtils.method('HEAD'), MatcherUtils.url('/head')), {
+      key: 'head'
+    });
 
     const postReq = fetchToJson('/post', { method: 'POST' }).then(json =>
       expect(json.key).toBe('post')
@@ -143,9 +137,7 @@ describe('FetchMock', () => {
   it('should support fallback to realFetch', done => {
     mock.get('/testurl', { key: 'testurl' });
 
-    const mocked = fetchToJson('/testurl').then(json =>
-      expect(json.key).toBe('testurl')
-    );
+    const mocked = fetchToJson('/testurl').then(json => expect(json.key).toBe('testurl'));
     const fallback = fetchToJson('https://xkcd.com/info.0.json').then(json =>
       expect(json.num).toBeDefined()
     );
@@ -155,10 +147,7 @@ describe('FetchMock', () => {
 
   it('should support delayed responses', done => {
     mock.get('/test', ResponseUtils.delayed(200, { key: 'delayed' }));
-    mock.get(
-      '/test2',
-      ResponseUtils.delayed(200, ResponseUtils.json({ key: 'delayed2' }))
-    );
+    mock.get('/test2', ResponseUtils.delayed(200, ResponseUtils.json({ key: 'delayed2' })));
     const startTime = new Date().getTime();
 
     Promise.all([fetchToJson('/test'), fetchToJson('/test2')]).then(json => {
@@ -197,10 +186,7 @@ describe('FetchMock', () => {
   it('should be able to combine response utils', done => {
     mock.get(
       '/combine',
-      ResponseUtils.combine(
-        ResponseUtils.json({ key: 'value' }),
-        ResponseUtils.statusCode(201)
-      )
+      ResponseUtils.combine(ResponseUtils.json({ key: 'value' }), ResponseUtils.statusCode(201))
     );
 
     mock.get(
@@ -242,4 +228,15 @@ describe('FetchMock', () => {
       done();
     });
   });
+
+  it('should jsonValue as response in MockHandler', done => {
+    const myResponse = ({ queryParams }: HandlerArgument) => ({ key: 'BIG-CASE' });
+
+    mock.post('/lowercase', myResponse);
+
+    fetchToJson('/lowercase', { method: 'post' }).then(json => {
+      expect(json.key).toBe('BIG-CASE');
+      done();
+    });
+  });
 });