Fix unit test for the error handler middleware

Author: hirsch88

src/api/middlewares/ErrorHandlerMiddleware.ts

@@ -3,10 +3,6 @@ import { Middleware, ExpressErrorMiddlewareInterface, HttpError } from 'routing-
 import { env } from '../../core/env';
 import { Logger, LoggerInterface } from '../../decorators/Logger';
 
-interface ErrorInterface extends HttpError {
-    errors: any[];
-}
-
 
 @Middleware({ type: 'after' })
 export class ErrorHandlerMiddleware implements ExpressErrorMiddlewareInterface {
@@ -17,12 +13,12 @@ export class ErrorHandlerMiddleware implements ExpressErrorMiddlewareInterface {
         @Logger(__filename) private log: LoggerInterface
     ) { }
 
-    public error(error: ErrorInterface, req: express.Request, res: express.Response, next: express.NextFunction): void {
+    public error(error: HttpError, req: express.Request, res: express.Response, next: express.NextFunction): void {
         res.status(error.httpCode || 500);
         res.json({
             name: error.name,
             message: error.message,
-            errors: error.errors || [],
+            errors: error['errors'] || [],
         });
 
         if (this.isProduction) {

test/unit/auth/AuthService.test.ts

@@ -35,14 +35,14 @@ describe('AuthService', () => {
             });
             const token = authService.parseTokenFromRequest(req);
             expect(token).toBeUndefined();
-            expect(log.infoMock).toBeCalledWith('info', 'No Token provided by the client', []);
+            expect(log.infoMock).toBeCalledWith('No Token provided by the client', []);
         });
 
         test('Should return undefined if there is no "Authorization" header', () => {
             const req: Request = new MockExpressRequest();
             const token = authService.parseTokenFromRequest(req);
             expect(token).toBeUndefined();
-            expect(log.infoMock).toBeCalledWith('info', 'No Token provided by the client', []);
+            expect(log.infoMock).toBeCalledWith('No Token provided by the client', []);
         });
     });
 

test/unit/lib/LogMock.ts

@@ -9,19 +9,19 @@ export class LogMock extends Logger {
     public errorMock = jest.fn();
 
     public debug(message: string, ...args: any[]): void {
-        this.debugMock('debug', message, args);
+        this.debugMock(message, args);
     }
 
     public info(message: string, ...args: any[]): void {
-        this.infoMock('info', message, args);
+        this.infoMock(message, args);
     }
 
     public warn(message: string, ...args: any[]): void {
-        this.warnMock('warn', message, args);
+        this.warnMock(message, args);
     }
 
     public error(message: string, ...args: any[]): void {
-        this.errorMock('error', message, args);
+        this.errorMock(message, args);
     }
 
 }

test/unit/middlewares/ErrorHandlerMiddleware.test.ts

@@ -6,30 +6,33 @@ import { LogMock } from '../lib/LogMock';
 
 describe('ErrorHandlerMiddleware', () => {
 
+    let log;
+    let middleware;
+    let err;
+    let res;
+    beforeEach(() => {
+        log = new LogMock();
+        middleware = new ErrorHandlerMiddleware(log);
+        res = new MockExpressResponse();
+        err = new HttpError(400, 'Test Error');
+    });
+
     test('Should not print stack out in production', () => {
-        const middleware = new ErrorHandlerMiddleware(new LogMock());
         middleware.isProduction = true;
-
-        const res = new MockExpressResponse();
-        const err = new HttpError(400, 'Test Error');
         middleware.error(err, undefined, res, undefined);
         const json = res._getJSON();
         expect(json.name).toBe(err.name);
         expect(json.message).toBe(err.message);
-        expect(json.stack).toBeUndefined();
+        expect(log.errorMock).toHaveBeenCalledWith(err.name, [err.message]);
     });
 
-    test('Should print stack out in production', () => {
-        const middleware = new ErrorHandlerMiddleware(new LogMock());
+    test('Should print stack out in development', () => {
         middleware.isProduction = false;
-
-        const res = new MockExpressResponse();
-        const err = new HttpError(400, 'Test Error');
         middleware.error(err, undefined, res, undefined);
         const json = res._getJSON();
         expect(json.name).toBe(err.name);
         expect(json.message).toBe(err.message);
-        expect(json.stack).toBeDefined();
+        expect(log.errorMock).toHaveBeenCalled();
     });
 
 });