Fix wallaby and add some more tests

hirsch88 · hirsch88 · commit fafd68020484 · 2017-05-21T18:29:14.000+02:00
diff --git a/.env.example b/.env.example
@@ -5,6 +5,7 @@ APP_NAME=express-typescript-boilerplate
 APP_ENV=local
 APP_HOST=http://localhost
 APP_PORT=3000
+APP_URL_PREFIX=/api
 
 #
 # LOGGING
diff --git a/src/api/controllers/UserController.ts b/src/api/controllers/UserController.ts
@@ -4,8 +4,7 @@ import { my } from 'my-express';
 import { Log } from '../../core/log';
 import { UserService } from '../services/UsersService';
 import { Types } from '../../constants/Types';
-import { authenticate } from '../middlewares/authenticate';
-import { populateUser } from '../middlewares/populateUser';
+import { authenticate, populateUser } from '../middlewares';
 
 const log = new Log('api:ctrl.UserController');
 
diff --git a/src/api/middlewares/authenticate.ts b/src/api/middlewares/authenticate.ts
@@ -1,8 +1,8 @@
-import * as request from 'request';
+import { RequestAPI, RequiredUriUrl, Options, Request, RequestResponse } from 'request';
 import { my } from 'my-express';
 import { Log } from '../../core/log';
 
-const log = new Log('api:middleware.authenticate');
+// const log = new Log('api:middleware.authenticate');
 
 /**
  * authenticate middleware
@@ -13,38 +13,39 @@ const log = new Log('api:middleware.authenticate');
  * @param res
  * @param next
  */
-export const authenticate = (req: my.Request, res: my.Response, next: my.NextFunction) => {
-    const token = getToken(req);
+export const authenticate = (request: RequestAPI<Request, Options, RequiredUriUrl>, log: Log) =>
+    (req: my.Request, res: my.Response, next: my.NextFunction) => {
+        const token = getToken(req);
 
-    if (token === null) {
-        log.warn('No token given');
-        return res.failed(403, 'You are not allowed to request this resource!');
-    }
-    log.debug('Token is provided');
-
-    // Request user info at auth0 with the provided token
-    request.post({
-        url: `${process.env.AUTH0_HOST}/tokeninfo`,
-        form: {
-            id_token: token
+        if (token === null) {
+            log.warn('No token given');
+            return res.failed(403, 'You are not allowed to request this resource!');
         }
-    }, (error: any, response: request.RequestResponse, body: any) => {
-
-        // Verify if the requests was successful and append user
-        // information to our extended express request object
-        if (!error && response.statusCode === 200) {
-            req.tokeninfo = JSON.parse(body);
-            log.info(`Retrieved user ${req.tokeninfo.email}`);
-            return next();
-        }
-
-        // Catch auth0 exception and return it as it is
-        log.warn(`Could not retrieve the user, because of`, body);
-        res.failed(response.statusCode || 401, body);
-
-    });
-
-};
+        log.debug('Token is provided');
+
+        // Request user info at auth0 with the provided token
+        request.post({
+            url: `${process.env.AUTH0_HOST}/tokeninfo`,
+            form: {
+                id_token: token
+            }
+        }, (error: any, response: RequestResponse, body: any) => {
+
+            // Verify if the requests was successful and append user
+            // information to our extended express request object
+            if (!error && response.statusCode === 200) {
+                req.tokeninfo = JSON.parse(body);
+                log.info(`Retrieved user ${req.tokeninfo.email}`);
+                return next();
+            }
+
+            // Catch auth0 exception and return it as it is
+            log.warn(`Could not retrieve the user, because of`, body);
+            res.failed(response.statusCode || 401, body);
+
+        });
+
+    };
 
 /**
  * Returns the access token of the given request header
diff --git a/src/api/middlewares/index.ts b/src/api/middlewares/index.ts
@@ -0,0 +1,19 @@
+import * as request from 'request';
+import container from '../../container';
+import { Log } from '../../core/log';
+import { Types } from '../../constants/Types';
+import { UserService } from '../services/UsersService';
+
+import { authenticate as Authenticate } from './authenticate';
+import { populateUser as PopulateUser } from './populateUser';
+
+
+/**
+ * Middlewares
+ * ------------------------------------
+ * We build them up here so we can easily use them in the controllers and
+ * also be able to test the middlewares without any big effort.
+ */
+export const authenticate = Authenticate(request, new Log('api:middleware.authenticate'));
+export const populateUser = PopulateUser(() => container.get<UserService>(Types.UserService), new Log('api:middleware.populateUser'));
+
diff --git a/src/api/middlewares/populateUser.ts b/src/api/middlewares/populateUser.ts
@@ -1,11 +1,10 @@
 import * as request from 'request';
+import { Container } from 'inversify';
 import { my } from 'my-express';
 import { Log } from '../../core/log';
 import { UserService } from '../services/UsersService';
-import { Types } from '../../constants/Types';
-import container from '../../container';
 
-const log = new Log('api:middleware.populateUser');
+// const log = new Log('api:middleware.populateUser');
 
 /**
  * populateUser middleware
@@ -17,21 +16,22 @@ const log = new Log('api:middleware.populateUser');
  * @param res
  * @param next
  */
-export const populateUser = (req: my.Request, res: my.Response, next: my.NextFunction) => {
+export const populateUser = (lazyUserService: () => UserService, log: Log) =>
+    (req: my.Request, res: my.Response, next: my.NextFunction) => {
 
-    if (!req.tokeninfo || !req.tokeninfo.user_id) {
-        return res.failed(400, 'Missing token information!');
-    }
+        if (!req.tokeninfo || !req.tokeninfo.user_id) {
+            return res.failed(400, 'Missing token information!');
+        }
 
-    const userService = container.get<UserService>(Types.UserService);
-    userService.findByUserId(req.tokeninfo.user_id)
-        .then((user) => {
-            req.user = user.toJSON();
-            log.debug(`populated user with the id=${req.user.id} to the request object`);
-            next();
-        })
-        .catch((error) => {
-            log.warn(`could not populate user to the request object`);
-            next(error);
-        });
-};
+        const userService = lazyUserService();
+        userService.findByUserId(req.tokeninfo.user_id)
+            .then((user) => {
+                req.user = user.toJSON();
+                log.debug(`populated user with the id=${req.user.id} to the request object`);
+                next();
+            })
+            .catch((error) => {
+                log.warn(`could not populate user to the request object`);
+                next(error);
+            });
+    };
diff --git a/src/api/services/UsersService.ts b/src/api/services/UsersService.ts
@@ -18,7 +18,7 @@ const log = new Log('api:services:UserService');
  * database actions. Furthermore you should throw events here if
  * necessary.
  *
- * @export
+ * @export0'
  * @class UserService
  */
 @injectable()
diff --git a/src/core/Bootstrap.ts b/src/core/Bootstrap.ts
@@ -48,7 +48,7 @@ export class Bootstrap {
      * @memberof Bootstrap
      */
     static build(app: express.Application, container: Container): express.Application {
-        let server = new InversifyExpressServer(container, undefined, { rootPath: '/api' }, app);
+        let server = new InversifyExpressServer(container, undefined, { rootPath: Environment.get<string>('APP_URL_PREFIX') }, app);
         log.debug('ioc is bonded');
         server.setConfig((a) => a.use(extendExpressResponse));
         server.setErrorConfig((a) => a.use(exceptionHandler));
diff --git a/src/core/api/Exception.ts b/src/core/api/Exception.ts
@@ -20,8 +20,8 @@ export class Exception extends Error {
         super(args[0]);
         this.code = code;
         this.name = this.constructor.name;
-        this.message = args[0];
-        this.body = args[1];
+        this.message = args[0] || 'Unknown error' ;
+        this.body = args[1] || null;
         this[isException] = true;
         Error.captureStackTrace(this);
     }
diff --git a/src/core/api/extendExpressResponse.ts b/src/core/api/extendExpressResponse.ts
@@ -14,15 +14,17 @@ export const extendExpressResponse = (req: my.Request, res: my.Response, next: e
      * This is used for successful responses and a json body
      */
     res.ok = <T>(data: T, options: my.ResponseOptions = {}) => {
-        return res.status(200).json(bodySuccessful(data, options));
+        res.status(200);
+        return res.json(bodySuccessful(data, options));
     };
 
     /**
      * 201 - Created
      * This is used for created resources
      */
     res.created = <T>(data: T, options: my.ResponseOptions = {}) => {
-        return res.status(201).json(bodySuccessful(data, options));
+        res.status(201);
+        return res.json(bodySuccessful(data, options));
     };
 
     /**
@@ -46,15 +48,17 @@ export const extendExpressResponse = (req: my.Request, res: my.Response, next: e
      * This is the response after a resource has been removed
      */
     res.destroyed = (options: my.ResponseOptions = {}) => {
-        return res.status(204).json(bodySuccessful(null));
+        res.status(204);
+        return res.json(bodySuccessful(null));
     };
 
     /**
      * 400-500 - Failed
      * This is used when a request has failed
      */
     res.failed = (status: number, message: string, error?: any) => {
-        return res.status(status).json(bodyFailed(message, error));
+        res.status(status);
+        return res.json(bodyFailed(message, error));
     };
 
     next();
diff --git a/src/core/log/Log.ts b/src/core/log/Log.ts
@@ -64,6 +64,10 @@ export class Log {
         this.scope = (scope) ? scope : Log.DEFAULT_SCOPE;
     }
 
+    public getAdapter(): ILogAdapter {
+        return this.adapter;
+    }
+
     public debug(message: string, ...args: any[]): void {
         this.log('debug', message, args);
     }
diff --git a/test/unit/core/api/Exception.test.ts b/test/unit/core/api/Exception.test.ts
@@ -0,0 +1,23 @@
+import { Exception, isException } from '../../../../src/core/api/Exception';
+
+
+describe('Exception', () => {
+    test('Should have the correct properties', () => {
+        const exception = new Exception(400, 'message', { success: false });
+        expect(exception.code).toBe(400);
+        expect(exception.message).toBe('message');
+        expect(exception.body.success).toBe(false);
+        expect(exception[isException]).toBeTruthy();
+    });
+    test('Should have the correct properties', () => {
+        const exception = new Exception(400, 'message', { success: false });
+        expect(exception.code).toBe(400);
+        expect(exception.message).toBe('message');
+        expect(exception.body.success).toBe(false);
+        expect(exception[isException]).toBeTruthy();
+    });
+    test('Should return a string with the code, name and message of the exception', () => {
+        const exception = new Exception(400, 'message', { success: false });
+        expect(exception.toString()).toBe(`400 - Exception:message`);
+    });
+});
diff --git a/test/unit/core/api/RequestBody.test.ts b/test/unit/core/api/RequestBody.test.ts
@@ -0,0 +1,75 @@
+import { RequestBody } from '../../../../src/core/api/RequestBody';
+import { IsNotEmpty } from 'class-validator';
+
+
+describe('RequestBody', () => {
+    describe('constructor', () => {
+        test('Should construct with the given input and set all values', () => {
+            const r = new RequestBody({ a: 1 });
+            expect(r['a']).toBe(1);
+        });
+        test('Should construct with the given input and set all values', () => {
+            const r = new RequestBody({ a: 1 });
+            expect(r['a']).toBe(1);
+        });
+    });
+    describe('validate', () => {
+        test('Should pass if no validators are defined', async () => {
+            const r = new RequestBody();
+            const e = await r.validate();
+            expect(e).toBe(undefined);
+        });
+        test('Should pass if no validators are defined', async () => {
+            class TestBody extends RequestBody {
+                @IsNotEmpty() value: string;
+            }
+            const r = new TestBody();
+            try {
+                await r.validate();
+            } catch (error) {
+                expect(error.name).toBe('ValidationException');
+            }
+        });
+    });
+    describe('toJSON', () => {
+        test('Should return the set values as new json object', () => {
+            const r = new RequestBody({ a: 1 });
+            const o = r.toJSON();
+            expect(o.a).toBe(1);
+        });
+    });
+    describe('set', () => {
+        test('Should set value the key property', () => {
+            class TestBody extends RequestBody {
+                @IsNotEmpty() value: string;
+
+                setValue(value: string): void {
+                    this.set('value', value);
+                }
+            }
+            const tb = new TestBody();
+            tb.setValue('yes');
+            expect(tb.value).toBe('yes');
+        });
+    });
+    describe('update', () => {
+        test('Should set value the key property', () => {
+            class TestBody extends RequestBody {
+                @IsNotEmpty() valueA: string;
+                @IsNotEmpty() valueB: string;
+
+                updateValue(key: string, value: any): void {
+                    this.update(key, value);
+                }
+            }
+            const tb = new TestBody({
+                valueA: 'no',
+                valueB: 'no'
+            });
+            tb.updateValue('valueA', 'yes');
+            tb.updateValue('valueB', undefined);
+            expect(tb.valueA).toBe('yes');
+            expect(tb.valueB).toBe('no');
+        });
+    });
+});
diff --git a/test/unit/core/api/exceptionHandler.test.ts b/test/unit/core/api/exceptionHandler.test.ts
@@ -0,0 +1,33 @@
+import { exceptionHandler } from '../../../../src/core/api/exceptionHandler';
+import { Exception } from '../../../../src/core/api/Exception';
+
+
+describe('exceptionHandler', () => {
+
+    let req, res, next;
+    beforeEach(() => {
+        req = {};
+        res = {
+            failed: jest.fn()
+        };
+        next = jest.fn();
+    });
+
+    test('Should fail, because it is a exception with the given error code and body', () => {
+        const e = new Exception(400, 'message', { success: false });
+        exceptionHandler(e, req, res, next);
+        expect(res.failed).toHaveBeenCalledWith(400, 'message', { success: false });
+    });
+
+    test('Should fail, because it is a exception with the given error code', () => {
+        const e = new Exception(400, 'message');
+        exceptionHandler(e, req, res, next);
+        expect(res.failed).toHaveBeenCalledWith(400, 'message', null);
+    });
+
+    test('Should fail, because it is a system error with 500', () => {
+        const e = new Error('message');
+        exceptionHandler(e, req, res, next);
+        expect(res.failed).toHaveBeenCalledWith(500, 'Something broke!', null);
+    });
+});
diff --git a/test/unit/core/api/extendExpressResponse.test.ts b/test/unit/core/api/extendExpressResponse.test.ts
diff --git a/test/unit/core/log/DebugAdapter.test.ts b/test/unit/core/log/DebugAdapter.test.ts
diff --git a/test/unit/core/log/Log.test.ts b/test/unit/core/log/Log.test.ts
diff --git a/test/unit/core/log/WinstonAdapter.test.ts b/test/unit/core/log/WinstonAdapter.test.ts
diff --git a/wallaby.js b/wallaby.js

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@ APP_NAME=express-typescript-boilerplate`
`5`	`5`	`APP_ENV=local`
`6`	`6`	`APP_HOST=http://localhost`
`7`	`7`	`APP_PORT=3000`
	`8`	`+APP_URL_PREFIX=/api`
`8`	`9`
`9`	`10`	`#`
`10`	`11`	`# LOGGING`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ const log = new Log('api:services:UserService');`
`18`	`18`	`* database actions. Furthermore you should throw events here if`
`19`	`19`	`* necessary.`
`20`	`20`	`*`
`21`		`- * @export`
	`21`	`+ * @export0'`
`22`	`22`	`* @class UserService`
`23`	`23`	`*/`
`24`	`24`	`@injectable()`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,10 @@ export class Log {`
`64`	`64`	`this.scope = (scope) ? scope : Log.DEFAULT_SCOPE;`
`65`	`65`	`}`
`66`	`66`
	`67`	`+ public getAdapter(): ILogAdapter {`
	`68`	`+ return this.adapter;`
	`69`	`+ }`
	`70`	`+`
`67`	`71`	`public debug(message: string, ...args: any[]): void {`
`68`	`72`	`this.log('debug', message, args);`
`69`	`73`	`}`