Merge pull request #4 from Plnt9/fix/renameOnErrorMiddleware

Fix/rename on error middleware

__tests__/index.js

@@ -6,53 +6,53 @@ describe('🛵  Middy test suite', () => {
     expect(() => { handler.use(() => {}) }).toThrow('Middleware must be an object')
   })
 
-  test('Middleware attached with "use" must be an object exposing at least a key among "before", "after", "error"', () => {
+  test('Middleware attached with "use" must be an object exposing at least a key among "before", "after", "onError"', () => {
     const handler = middy(jest.fn())
-    expect(() => { handler.use({foo: 'bar'}) }).toThrow('Middleware must contain at least one key among "before", "after", "error"')
+    expect(() => { handler.use({foo: 'bar'}) }).toThrow('Middleware must contain at least one key among "before", "after", "onError"')
   })
 
   test('"use" can add before middlewares', () => {
     const before = jest.fn()
     const middleware = () => ({ before })
     const handler = middy(jest.fn())
     handler.use(middleware())
-    expect(handler._middlewares.before[0]).toBe(before)
+    expect(handler.__middlewares.before[0]).toBe(before)
   })
 
   test('"use" can add after middlewares', () => {
     const after = jest.fn()
     const middleware = () => ({ after })
     const handler = middy(jest.fn())
     handler.use(middleware())
-    expect(handler._middlewares.after[0]).toBe(after)
+    expect(handler.__middlewares.after[0]).toBe(after)
   })
 
   test('"use" can add error middlewares', () => {
-    const error = jest.fn()
-    const middleware = () => ({ error })
+    const onError = jest.fn()
+    const middleware = () => ({ onError })
     const handler = middy(jest.fn())
     handler.use(middleware())
-    expect(handler._middlewares.error[0]).toBe(error)
+    expect(handler.__middlewares.onError[0]).toBe(onError)
   })
 
   test('"use" can add all types of middlewares', () => {
     const before = jest.fn()
     const after = jest.fn()
-    const error = jest.fn()
+    const onError = jest.fn()
 
     const middleware = () => ({
       before,
       after,
-      error
+      onError
     })
 
     const handler = middy(jest.fn())
 
     handler.use(middleware())
 
-    expect(handler._middlewares.before[0]).toBe(before)
-    expect(handler._middlewares.after[0]).toBe(after)
-    expect(handler._middlewares.error[0]).toBe(error)
+    expect(handler.__middlewares.before[0]).toBe(before)
+    expect(handler.__middlewares.after[0]).toBe(after)
+    expect(handler.__middlewares.onError[0]).toBe(onError)
   })
 
   test('"before" should add a before middleware', () => {
@@ -61,7 +61,7 @@ describe('🛵  Middy test suite', () => {
     const handler = middy(jest.fn())
 
     handler.before(beforeMiddleware)
-    expect(handler._middlewares.before[0]).toBe(beforeMiddleware)
+    expect(handler.__middlewares.before[0]).toBe(beforeMiddleware)
   })
 
   test('"after" should add an after middleware', () => {
@@ -70,16 +70,16 @@ describe('🛵  Middy test suite', () => {
     const handler = middy(jest.fn())
 
     handler.after(afterMiddleware)
-    expect(handler._middlewares.after[0]).toBe(afterMiddleware)
+    expect(handler.__middlewares.after[0]).toBe(afterMiddleware)
   })
 
-  test('"error" should add an error middleware', () => {
+  test('"onError" should add an error middleware', () => {
     const errorMiddleware = jest.fn()
 
     const handler = middy(jest.fn())
 
-    handler.error(errorMiddleware)
-    expect(handler._middlewares.error[0]).toBe(errorMiddleware)
+    handler.onError(errorMiddleware)
+    expect(handler.__middlewares.onError[0]).toBe(errorMiddleware)
   })
 
   test('It should execute before and after middlewares in the right order', (endTest) => {
@@ -176,18 +176,18 @@ describe('🛵  Middy test suite', () => {
       next(error)
     }
 
-    const errorMiddleware = jest.fn((ctx, next) => {
+    const onErrorMiddleware = jest.fn((ctx, next) => {
       expect(ctx.error).toBe(error)
       next()
     })
 
     handler
       .before(failingMiddleware)
-      .error(errorMiddleware)
+      .onError(onErrorMiddleware)
 
     handler({}, {}, function () {
       expect(originalHandler).not.toBeCalled()
-      expect(errorMiddleware).toBeCalled()
+      expect(onErrorMiddleware).toBeCalled()
       endTest()
     })
   })
@@ -198,16 +198,16 @@ describe('🛵  Middy test suite', () => {
       return callback(error)
     })
 
-    const errorMiddleware = jest.fn((ctx, next) => {
+    const onErrorMiddleware = jest.fn((ctx, next) => {
       expect(ctx.error).toBe(error)
       next()
     })
 
     handler
-      .error(errorMiddleware)
+      .onError(onErrorMiddleware)
 
     handler({}, {}, function () {
-      expect(errorMiddleware).toBeCalled()
+      expect(onErrorMiddleware).toBeCalled()
       endTest()
     })
   })
@@ -223,44 +223,44 @@ describe('🛵  Middy test suite', () => {
       next(error)
     }
 
-    const errorMiddleware = jest.fn((ctx, next) => {
+    const onErrorMiddleware = jest.fn((ctx, next) => {
       expect(ctx.error).toBe(error)
       next()
     })
 
     handler
       .after(failingMiddleware)
-      .error(errorMiddleware)
+      .onError(onErrorMiddleware)
 
     handler({}, {}, function () {
       expect(originalHandler).toBeCalled()
-      expect(errorMiddleware).toBeCalled()
+      expect(onErrorMiddleware).toBeCalled()
       endTest()
     })
   })
 
   test('If theres an error and one error middleware handles the error, the next error middlewares is not executed', (endTest) => {
     const expectedResponse = { message: 'error handled' }
 
-    const errorMiddleware1 = jest.fn((ctx, next) => {
+    const onErrorMiddleware1 = jest.fn((ctx, next) => {
       ctx.response = expectedResponse
       next() // the error has been handled
     })
 
-    const errorMiddleware2 = jest.fn()
+    const onErrorMiddleware2 = jest.fn()
 
     const handler = middy((event, context, callback) => {
       return callback(new Error('some error'))
     })
 
     handler
-      .error(errorMiddleware1)
-      .error(errorMiddleware2)
+      .onError(onErrorMiddleware1)
+      .onError(onErrorMiddleware2)
 
     handler({}, {}, (err, response) => {
       expect(err).toBe(null)
-      expect(errorMiddleware1).toBeCalled()
-      expect(errorMiddleware2).not.toBeCalled()
+      expect(onErrorMiddleware1).toBeCalled()
+      expect(onErrorMiddleware2).not.toBeCalled()
       expect(response).toBe(expectedResponse)
 
       endTest()
@@ -270,11 +270,11 @@ describe('🛵  Middy test suite', () => {
   test('If theres an error and the first error middleware doesn\'t handle the error, the next error middlewares is executed', (endTest) => {
     const expectedResponse = { message: 'error handled' }
 
-    const errorMiddleware1 = jest.fn((ctx, next) => {
+    const onErrorMiddleware1 = jest.fn((ctx, next) => {
       next(ctx.error) // propagates the error
     })
 
-    const errorMiddleware2 = jest.fn((ctx, next) => {
+    const onErrorMiddleware2 = jest.fn((ctx, next) => {
       ctx.response = expectedResponse
       next() // the error has been handled
     })
@@ -284,13 +284,13 @@ describe('🛵  Middy test suite', () => {
     })
 
     handler
-      .error(errorMiddleware1)
-      .error(errorMiddleware2)
+      .onError(onErrorMiddleware1)
+      .onError(onErrorMiddleware2)
 
     handler({}, {}, (err, response) => {
       expect(err).toBe(null)
-      expect(errorMiddleware1).toBeCalled()
-      expect(errorMiddleware2).toBeCalled()
+      expect(onErrorMiddleware1).toBeCalled()
+      expect(onErrorMiddleware2).toBeCalled()
       expect(response).toBe(expectedResponse)
 
       endTest()
@@ -351,7 +351,7 @@ describe('🛵  Middy test suite', () => {
   test('It handler synchronous errors generated by throw statements in the error middleware', (endTest) => {
     const expectedError = new Error('successive error in error handler')
 
-    const errorMiddleware = (ctx, next) => {
+    const onErrorMiddleware = (ctx, next) => {
       throw expectedError
     }
 
@@ -360,7 +360,7 @@ describe('🛵  Middy test suite', () => {
     })
 
     handler
-      .error(errorMiddleware)
+      .onError(onErrorMiddleware)
 
     handler({}, {}, (err, response) => {
       expect(err).toBe(expectedError)

index.js

@@ -97,8 +97,8 @@ const middy = (handler) => {
       throw new Error('Middleware must be an object')
     }
 
-    if (!middleware.before && !middleware.after && !middleware.error) {
-      throw new Error('Middleware must contain at least one key among "before", "after", "error"')
+    if (!middleware.before && !middleware.after && !middleware.onError) {
+      throw new Error('Middleware must contain at least one key among "before", "after", "onError"')
     }
 
     if (middleware.before) {
@@ -109,8 +109,8 @@ const middy = (handler) => {
       instance.after(middleware.after)
     }
 
-    if (middleware.error) {
-      instance.error(middleware.error)
+    if (middleware.onError) {
+      instance.onError(middleware.onError)
     }
 
     return instance
@@ -128,16 +128,16 @@ const middy = (handler) => {
     return instance
   }
 
-  instance.error = (errorMiddleware) => {
+  instance.onError = (errorMiddleware) => {
     errorMiddlewares.push(errorMiddleware)
 
     return instance
   }
 
-  instance._middlewares = {
+  instance.__middlewares = {
     before: beforeMiddlewares,
     after: afterMiddlewares,
-    error: errorMiddlewares
+    onError: errorMiddlewares
   }
 
   return instance

middlewares/__tests__/jsonBodyParser.js

@@ -1 +1,2 @@
 // TODO
+test.skip('Json Body Parser')

package.json

@@ -6,6 +6,7 @@
   "scripts": {
     "test:lint": "eslint --ignore-pattern='node_modules' --ignore-pattern='coverage/' .",
     "test:unit": "jest --verbose --coverage",
+    "test:unit:watch": "jest --verbose --coverage --watch",
     "test": "npm run test:lint && npm run test:unit"
   },
   "repository": {
@@ -18,7 +19,7 @@
     "Serverless",
     "Framework"
   ],
-  "author": "Luciano Mammino, Peter Caulfield, Joe Minichino",
+  "author": "Luciano Mammino, Peter Caulfield, Joe Minichino, Domagoj Katavic",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/Plnt9/middy/issues"