refactor(types): changed type-names from HandlerXXX to MockXXX

BREAKING CHANGE: type-names changed

Author: nutgaard

src/handler-context.ts

@@ -1,4 +1,4 @@
-import { HandlerRequest, HandlerResponseElement, ResponseData } from './types';
+import { MockRequest, HandlerResponseElement, ResponseData } from './types';
 
 async function delay(ms: number): Promise<any> {
   return new Promise<ResponseData>(resolve => {
@@ -7,11 +7,11 @@ async function delay(ms: number): Promise<any> {
 }
 
 class HandlerContext {
-  private req: HandlerRequest;
+  private req: MockRequest;
   private realFetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 
   constructor(
-    req: HandlerRequest,
+    req: MockRequest,
     realFetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>
   ) {
     this.req = req;

src/middleware-utils.ts

@@ -1,4 +1,4 @@
-import { HandlerRequest, Middleware, ResponseData } from './types';
+import { MockRequest, Middleware, ResponseData } from './types';
 
 const defaultFailure: ResponseData = {
   status: 500,
@@ -7,7 +7,7 @@ const defaultFailure: ResponseData = {
 
 export default class MiddlewareUtils {
   static combine(...middlewares: Middleware[]): Middleware {
-    return (request: HandlerRequest, response: ResponseData) => {
+    return (request: MockRequest, response: ResponseData) => {
       return middlewares.reduce(
         (currentResponse, middleware) => currentResponse.then(resp => middleware(request, resp)),
         Promise.resolve(response)
@@ -16,7 +16,7 @@ export default class MiddlewareUtils {
   }
 
   static delayMiddleware(delayMs: number): Middleware {
-    return (request: HandlerRequest, response: ResponseData) => {
+    return (request: MockRequest, response: ResponseData) => {
       return new Promise<ResponseData>(resolve => {
         setTimeout(() => resolve(response), delayMs);
       });
@@ -27,7 +27,7 @@ export default class MiddlewareUtils {
     probabilityOfFailure: number,
     failure: ResponseData = defaultFailure
   ): Middleware {
-    return (request: HandlerRequest, response: ResponseData) => {
+    return (request: MockRequest, response: ResponseData) => {
       return new Promise<ResponseData>(resolve => {
         const rnd = Math.random();
 

src/spy-middleware.ts

@@ -1,4 +1,4 @@
-import { HandlerRequest, ResponseData, RouteMatcher } from './types';
+import { MockRequest, ResponseData, RouteMatcher } from './types';
 
 const allMatcher: RouteMatcher = {
   test(input: RequestInfo, init?: RequestInit) {
@@ -7,7 +7,7 @@ const allMatcher: RouteMatcher = {
 };
 
 export interface Entry {
-  request: HandlerRequest;
+  request: MockRequest;
   response: ResponseData;
 }
 
@@ -19,10 +19,7 @@ export default class SpyMiddleware {
     this.entries = [];
   }
 
-  middleware(
-    request: HandlerRequest,
-    response: ResponseData
-  ): ResponseData | Promise<ResponseData> {
+  middleware(request: MockRequest, response: ResponseData): ResponseData | Promise<ResponseData> {
     const entry = { request, response };
     this.entries.unshift(entry);
     return response;

src/types.ts

@@ -1,4 +1,4 @@
-import HandlerContext from './handler-context';
+import MockContext from './handler-context';
 
 export type Opaque<K, T> = T & { __TYPE__: K };
 
@@ -24,7 +24,7 @@ export interface ResponseData {
   statusText?: string;
 }
 
-export interface HandlerRequest {
+export interface MockRequest {
   input: RequestInfo;
   init?: RequestInit;
   body?: any;
@@ -34,23 +34,23 @@ export interface HandlerRequest {
   method: HttpMethod;
 }
 export type HandlerResponseElement = (data: ResponseData) => Promise<ResponseData>;
-export type HandlerResponse = (...elements: Array<HandlerResponseElement>) => Promise<ResponseData>;
-export type Handler = (
-  req: HandlerRequest,
-  res: HandlerResponse,
-  ctx: HandlerContext
+export type MockResponse = (...elements: Array<HandlerResponseElement>) => Promise<ResponseData>;
+export type MockHandler = (
+  req: MockRequest,
+  res: MockResponse,
+  ctx: MockContext
 ) => Promise<ResponseData>;
 
 export type RequestUrl = Opaque<'RequestUrl', string>;
 export type MatcherUrl = Opaque<'MatcherUrl', string>;
 
 export interface Route {
   matcher: RouteMatcher;
-  handler: Handler;
+  handler: MockHandler;
 }
 
 export type Middleware = (
-  request: HandlerRequest,
+  request: MockRequest,
   response: ResponseData
 ) => ResponseData | Promise<ResponseData>;
 

src/yet-another-fetch-mock.ts

@@ -1,8 +1,8 @@
 import {
   Configuration,
-  Handler,
-  HandlerRequest,
-  HandlerResponse,
+  MockHandler,
+  MockRequest,
+  MockResponse,
   HandlerResponseElement,
   HttpMethod,
   MatcherUrl,
@@ -49,39 +49,39 @@ class FetchMock {
     this.scope.fetch = this.realFetch;
   }
 
-  get(url: string, handler: Handler): void {
+  get(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.get(url as MatcherUrl), handler);
   }
 
-  head(url: string, handler: Handler): void {
+  head(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.head(url as MatcherUrl), handler);
   }
 
-  post(url: string, handler: Handler): void {
+  post(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.post(url as MatcherUrl), handler);
   }
 
-  put(url: string, handler: Handler): void {
+  put(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.put(url as MatcherUrl), handler);
   }
 
-  delete(url: string, handler: Handler): void {
+  delete(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.del(url as MatcherUrl), handler);
   }
 
-  connect(url: string, handler: Handler): void {
+  connect(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.connect(url as MatcherUrl), handler);
   }
 
-  options(url: string, handler: Handler): void {
+  options(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.options(url as MatcherUrl), handler);
   }
 
-  patch(url: string, handler: Handler): void {
+  patch(url: string, handler: MockHandler): void {
     this.mock(MatcherUtils.patch(url as MatcherUrl), handler);
   }
 
-  mock(matcher: RouteMatcher, handler: Handler) {
+  mock(matcher: RouteMatcher, handler: MockHandler) {
     this.routes.push({ matcher, handler });
   }
 
@@ -112,8 +112,8 @@ class FetchMock {
       }
     } else {
       pathParams = findPathParams(url, matchingRoute.matcher.matcherUrl);
-      const req: HandlerRequest = { input, init, url, method, pathParams, queryParams, body };
-      const res: HandlerResponse = async (...args: Array<HandlerResponseElement>) => {
+      const req: MockRequest = { input, init, url, method, pathParams, queryParams, body };
+      const res: MockResponse = async (...args: Array<HandlerResponseElement>) => {
         let responseData: ResponseData = {};
         for (const responseElement of args) {
           responseData = await responseElement(responseData);

test/middleware-utils.test.ts

@@ -1,4 +1,4 @@
-import { HandlerRequest, ResponseData } from '../src/types';
+import { MockRequest, ResponseData } from '../src/types';
 import MathMock from './math-mock';
 import MiddlewareUtils from '../src/middleware-utils';
 import ConsoleMock from './console-mock';
@@ -21,7 +21,7 @@ describe('middleware-utils', () => {
     const startTime = new Date().getTime();
 
     const combined = MiddlewareUtils.combine(delay, failure);
-    const result = combined({} as HandlerRequest, 'data' as ResponseData);
+    const result = combined({} as MockRequest, 'data' as ResponseData);
 
     (result as Promise<ResponseData>).then(res => {
       const endTime = new Date().getTime();
@@ -36,7 +36,7 @@ describe('middleware-utils', () => {
 
   it('should delay the response', done => {
     const delay = MiddlewareUtils.delayMiddleware(100);
-    const result = delay({} as HandlerRequest, 'delayed' as ResponseData);
+    const result = delay({} as MockRequest, 'delayed' as ResponseData);
     const startTime = new Date().getTime();
 
     (result as Promise<String>).then(res => {
@@ -51,7 +51,7 @@ describe('middleware-utils', () => {
   it('should have a random failure rate', done => {
     MathMock.fixRandom(0.2);
     const delay = MiddlewareUtils.failurerateMiddleware(0.3);
-    const result = delay({} as HandlerRequest, 'normal-response' as ResponseData);
+    const result = delay({} as MockRequest, 'normal-response' as ResponseData);
 
     (result as Promise<ResponseData>).then(res => {
       expect(res.status).toBe(500);
@@ -62,7 +62,7 @@ describe('middleware-utils', () => {
   it('should have a random failure rate2', done => {
     MathMock.fixRandom(0.4);
     const delay = MiddlewareUtils.failurerateMiddleware(0.3);
-    const result = delay({} as HandlerRequest, 'normal-response' as ResponseData);
+    const result = delay({} as MockRequest, 'normal-response' as ResponseData);
 
     (result as Promise<String>).then(res => {
       expect(res).toBe('normal-response');
@@ -73,7 +73,7 @@ describe('middleware-utils', () => {
   it('should support custom error response', done => {
     MathMock.fixRandom(0.2);
     const delay = MiddlewareUtils.failurerateMiddleware(0.3, { status: 1337 });
-    const result = delay({} as HandlerRequest, 'normal-response' as ResponseData);
+    const result = delay({} as MockRequest, 'normal-response' as ResponseData);
 
     (result as Promise<ResponseData>).then(res => {
       expect(res.status).toBe(1337);
@@ -83,7 +83,7 @@ describe('middleware-utils', () => {
 
   it('should should log the request', () => {
     const logging = MiddlewareUtils.loggingMiddleware();
-    logging({ init: { headers: {} } } as HandlerRequest, 'resp' as ResponseData);
+    logging({ init: { headers: {} } } as MockRequest, 'resp' as ResponseData);
 
     expect(console.log).toBeCalledTimes(5);
   });