feat(configuration): Added configuration, and a few helper utils

BREAKING CHANGE: init renamed to configure

Author: nutgaard

src/response-utils.ts

@@ -1,16 +1,31 @@
-import { FetchMethod, MockHandlerFunction } from './types';
+import { HandlerArgument, MockHandler, MockHandlerFunction } from './types';
+
+function execHandler(
+  handler: MockHandler,
+  args: HandlerArgument
+): Promise<Response> {
+  if (typeof handler === 'function') {
+    return handler(args);
+  } else {
+    return ResponseUtils.jsonPromise(handler);
+  }
+}
 
 export default class ResponseUtils {
   static json(json: object): MockHandlerFunction {
     return () => ResponseUtils.jsonPromise(json);
   }
 
-  static jsonPromise(json: object): Promise<Response> {
+  static jsonPromise(json: MockHandler): Promise<Response> {
     const response: Response = new Response(JSON.stringify(json));
     return Promise.resolve(response);
   }
 
-  static use(fn: FetchMethod): MockHandlerFunction {
-    return ({ input, init }) => fn(input, init);
+  static delayed(delay: number, handler: MockHandler): MockHandler {
+    return (args: HandlerArgument) => {
+      return new Promise<Response>(resolve => {
+        setTimeout(() => resolve(execHandler(handler, args)), delay);
+      });
+    };
   }
 }

src/types.ts

@@ -20,10 +20,6 @@ export interface HandlerArgument {
   method: HttpMethod;
 }
 
-export type FetchMethod = (
-  input: RequestInfo,
-  init?: RequestInit
-) => Promise<Response>;
 export interface RouteMatcher {
   test: (input: RequestInfo, init?: RequestInit) => boolean;
   matcherUrl?: MatcherUrl;
@@ -40,3 +36,7 @@ export interface Route {
   matcher: RouteMatcher;
   handler: MockHandlerFunction;
 }
+export interface Configuration {
+  enableFallback: boolean;
+  middleware: (request: HandlerArgument, response: Response) => Response;
+}

src/yet-another-fetch-mock.ts

@@ -1,9 +1,8 @@
 import {
-  FetchMethod,
+  Configuration,
   HttpMethod,
   MatcherUrl,
   MockHandler,
-  MockHandlerFunction,
   RequestUrl,
   Route,
   RouteMatcher
@@ -18,20 +17,32 @@ import {
 import MatcherUtils from './matcher-utils';
 import ResponseUtils from './response-utils';
 
+const defaultConfiguration: Configuration = {
+  enableFallback: true,
+  middleware: (request, response) => response
+};
+
 class FetchMock {
-  public realFetch: FetchMethod;
+  private realFetch: (
+    input: RequestInfo,
+    init?: RequestInit
+  ) => Promise<Response>;
+  private configuration: Configuration;
   private routes: Route[];
   private scope: GlobalFetch;
 
-  constructor(scope: GlobalFetch) {
+  constructor(scope: GlobalFetch, configuration: Partial<Configuration>) {
     this.scope = scope;
+    this.configuration = Object.assign({}, defaultConfiguration, configuration);
     this.realFetch = scope.fetch;
     this.routes = [];
     this.scope.fetch = this.fetchproxy.bind(this);
   }
 
-  static init(): FetchMock {
-    return new FetchMock(window);
+  static configure(
+    configuration: Partial<Configuration> = defaultConfiguration
+  ): FetchMock {
+    return new FetchMock(window, configuration);
   }
 
   restore() {
@@ -55,9 +66,7 @@ class FetchMock {
   }
 
   mock(matcher: RouteMatcher, handler: MockHandler) {
-    if (handler === this.realFetch) {
-      this.routes.push({ matcher, handler: ResponseUtils.use(this.realFetch) });
-    } else if (typeof handler === 'function') {
+    if (typeof handler === 'function') {
       this.routes.push({ matcher, handler });
     } else {
       this.routes.push({ matcher, handler: ResponseUtils.json(handler) });
@@ -72,18 +81,38 @@ class FetchMock {
       input,
       init
     );
-    if (typeof matchingRoute === 'undefined') {
-      throw new Error('Matching route not found...');
-    }
-
-    const handler: MockHandlerFunction = matchingRoute.handler;
     const url: RequestUrl = findRequestUrl(input, init);
     const method: HttpMethod = findRequestMethod(input, init);
-    const pathParams = findPathParams(url, matchingRoute.matcher.matcherUrl);
     const queryParams = findQueryParams(url);
     const body = findBody(input, init);
+    let pathParams: object = {};
+    let response: Promise<Response>;
 
-    return handler({ input, init, url, method, pathParams, queryParams, body });
+    if (typeof matchingRoute === 'undefined') {
+      if (this.configuration.enableFallback) {
+        response = this.realFetch(input, init);
+      } else {
+        throw new Error(`Did not find any matching route for url: ${url}`);
+      }
+    } else {
+      pathParams = findPathParams(url, matchingRoute.matcher.matcherUrl);
+      response = matchingRoute.handler({
+        input,
+        init,
+        url,
+        method,
+        pathParams,
+        queryParams,
+        body
+      });
+    }
+
+    return response.then(resp =>
+      this.configuration.middleware(
+        { input, init, url, method, queryParams, pathParams, body },
+        resp
+      )
+    );
   }
 
   private findMatchingRoute(

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

@@ -22,7 +22,7 @@ describe('utils', () => {
 describe('FetchMock', () => {
   let mock: FetchMock;
   beforeEach(() => {
-    mock = FetchMock.init();
+    mock = FetchMock.configure();
   });
 
   afterEach(() => {
@@ -128,6 +128,9 @@ describe('FetchMock', () => {
   });
 
   it('should throw error if no route matches', () => {
+    mock.restore();
+    FetchMock.configure({ enableFallback: false });
+
     expect(() => {
       fetchToJson('/test');
     }).toThrow();
@@ -139,7 +142,6 @@ describe('FetchMock', () => {
 
   it('should support fallback to realFetch', done => {
     mock.get('/testurl', { key: 'testurl' });
-    mock.get('*', mock.realFetch);
 
     const mocked = fetchToJson('/testurl').then(json =>
       expect(json.key).toBe('testurl')
@@ -150,4 +152,21 @@ describe('FetchMock', () => {
 
     Promise.all([mocked, fallback]).then(() => done());
   });
+
+  it('should support delayed responses', done => {
+    mock.get('/test', ResponseUtils.delayed(200, { key: 'delayed' }));
+    mock.get(
+      '/test2',
+      ResponseUtils.delayed(200, ResponseUtils.json({ key: 'delayed2' }))
+    );
+    const startTime = new Date().getTime();
+
+    Promise.all([fetchToJson('/test'), fetchToJson('/test2')]).then(json => {
+      const endTime = new Date().getTime();
+      expect(json[0].key).toBe('delayed');
+      expect(json[1].key).toBe('delayed2');
+      expect(endTime - startTime).toBeGreaterThan(200);
+      done();
+    });
+  });
 });