add tests for our middlewares

Author: hirsch88

src/api/middlewares/authenticate.ts

@@ -24,13 +24,13 @@ export const authenticate = (request: RequestAPI<Request, Options, RequiredUriUr
         log.debug('Token is provided');
 
         // Request user info at auth0 with the provided token
-        request.post({
+        request({
+            method: '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) {

test/unit/api/middlewares/authenticate.test.ts

@@ -0,0 +1,69 @@
+import { authenticate as Authenticate } from '../../../../src/api/middlewares/authenticate';
+
+
+describe('authenticate', () => {
+
+    let authenticate, request, log, res, req, next;
+    beforeEach(() => {
+        process.env.AUTH0_HOST = 'test';
+        log = {
+            debug: jest.fn(),
+            info: jest.fn(),
+            warn: jest.fn()
+        };
+        request = jest.fn();
+        authenticate = Authenticate(request, log);
+        res = {
+            failed: jest.fn()
+        };
+        req = {
+            headers: { authorization: 'Bearer 1234' }
+        };
+        next = jest.fn();
+    });
+
+    test('Should fail because no token was given', () => {
+        req.headers.authorization = undefined;
+        authenticate(req, res, next);
+        expect(res.failed).toHaveBeenCalledWith(403, 'You are not allowed to request this resource!');
+
+        req.headers.authorization = '';
+        authenticate(req, res, next);
+        expect(res.failed).toHaveBeenCalledWith(403, 'You are not allowed to request this resource!');
+
+    });
+
+    test('Should set the correct request options', () => {
+        request = (options, done) => {
+            expect(options.method).toBe('POST');
+            expect(options.url).toBe('test/tokeninfo');
+            expect(options.form.id_token).toBe('1234');
+        };
+        const auth = Authenticate(request, log);
+        auth(req, res, next);
+        expect(log.debug).toHaveBeenCalledWith('Token is provided');
+
+    });
+
+    test('Should pass and add the token info to the request object', () => {
+        request = (options, done) => {
+            done(null, { statusCode: 200 }, '{ "user_id": 77, "email": "test@jest.org" }');
+            expect(req.tokeninfo.user_id).toBe(77);
+            expect(log.info).toHaveBeenCalled();
+            expect(next).toHaveBeenCalled();
+        };
+        const auth = Authenticate(request, log);
+        auth(req, res, next);
+    });
+
+    test('Should fail and respond with a 401 error', () => {
+        request = (options, done) => {
+            done(null, { statusCode: 401 }, 'Bad message :-)');
+            expect(log.warn).toHaveBeenCalled();
+            expect(res.failed).toHaveBeenCalledWith(401, 'Bad message :-)');
+        };
+        const auth = Authenticate(request, log);
+        auth(req, res, next);
+    });
+
+});

test/unit/api/middlewares/populateUser.test.ts

@@ -0,0 +1,66 @@
+import { populateUser as PopulateUser } from '../../../../src/api/middlewares/populateUser';
+
+
+describe('populateUser', () => {
+
+    let populateUser, userService, log, res, req, next;
+    beforeEach(() => {
+        process.env.AUTH0_HOST = 'test';
+        log = {
+            debug: jest.fn(),
+            warn: jest.fn()
+        };
+        populateUser = PopulateUser(() => userService, log);
+        res = {
+            failed: jest.fn()
+        };
+        req = {
+            tokeninfo: { user_id: 77 }
+        };
+        next = jest.fn();
+    });
+
+    test('Should fail because no tokeninfo or user_id is given', () => {
+        req.tokeninfo.user_id = undefined;
+        populateUser(req, res, next);
+        expect(res.failed).toBeCalledWith(400, 'Missing token information!');
+        req.tokeninfo = undefined;
+        populateUser(req, res, next);
+        expect(res.failed).toBeCalledWith(400, 'Missing token information!');
+    });
+
+    test('Should pass the database query and attache the user to the request object', () => {
+        userService = {
+            findByUserId: jest.fn().mockImplementation(() => {
+                return new Promise((resolve, reject) => {
+                    resolve({
+                        toJSON: () => ({
+                            id: 88
+                        })
+                    });
+                    expect(req.user.id).toBe(88);
+                    expect(log.debug).toHaveBeenCalledWith(`populated user with the id=88 to the request object`);
+                    expect(next).toBeCalled();
+                });
+            })
+        };
+        const pop = PopulateUser(() => userService, log);
+        pop(req, res, next);
+    });
+
+    test('Should behave...', () => {
+        userService = {
+            findByUserId: jest.fn().mockImplementation(() => {
+                return new Promise((resolve, reject) => {
+                    reject(new Error('test'));
+                    expect(req.user).toBeUndefined();
+                    expect(log.warn).toHaveBeenCalledWith(`could not populate user to the request object`);
+                    expect(next).toBeCalled();
+                });
+            })
+        };
+        const pop = PopulateUser(() => userService, log);
+        pop(req, res, next);
+    });
+
+});