node mongoose mocha : how to handle a Promise.reject in my test - node.js

Question

Currently I handle my authentication as following :
function login(req, res, next) {
// fetch user from the db
User.findOne(req.body)
.exec() // make query a Promise
.then((user) => {
const token = jwt.sign({ username: user.username }, config.jwtSecret);
return res.json({ token, username: user.username });
})
.catch(() => {
const err = new APIError('Authentication error', httpStatus.UNAUTHORIZED, true);
return Promise.reject(err);
});
}
I am trying to standardize my errors with a common APIError class
import httpStatus from 'http-status';
/**
* #extends Error
*/
class ExtendableError extends Error {
constructor(message, status, isPublic) {
super(message);
this.name = this.constructor.name;
this.message = message;
this.status = status;
this.isPublic = isPublic;
this.isOperational = true; // This is required since bluebird 4 doesn't append it anymore.
Error.captureStackTrace(this, this.constructor.name);
}
}
/**
* Class representing an API error.
* #extends ExtendableError
*/
class APIError extends ExtendableError {
/**
* Creates an API error.
* #param {string} message - Error message.
* #param {number} status - HTTP status code of error.
* #param {boolean} isPublic - Whether the message should be visible to user or not.
*/
constructor(message, status = httpStatus.INTERNAL_SERVER_ERROR, isPublic = false) {
super(message, status, isPublic);
}
}
export default APIError;
How can I test the Promise.reject in my test ?
describe('# POST /api/v1/auth/login', () => {
it('should return Authentication error', () => {
return request(app)
.post('/api/v1/auth/login')
.send(invalidUserCredentials)
// following lines are not valid anymore with Promise.reject ..
.expect(httpStatus.UNAUTHORIZED)
.then((res) => {
expect(res.body.message).to.equal('Authentication error');
});
});

Answer 1

You aren't handling the error/rejection at all. You need to send the error Back. I would recommend to add a error handling middleware at the end of your routes in express and then use next(err) to pass to it.
// at the end of your routes
app.use(function(err, req, res, next) {
// do whatever you want, but at least send status and message:
res.status(err.status).json({
message: err.message,
});
});
now handle the error in your routes through:
.catch(() => {
const err = new APIError('Authentication error', httpStatus.UNAUTHORIZED, true);
return next(err);
});

Answer 2

It's running fine now , I had an issue in my express.js error handling.. as the APIError type checking was always false... extending the es6-error package rather than the Error solve this Babel issue...
APIError.js
import ExtendableError from 'es6-error'; // solve Babel issue w isInstanceOf()
import httpStatus from 'http-status'
class MyExtendableError extends ExtendableError {
constructor(message, status, isPublic) {
super(message);
this.name = this.constructor.name;
this.message = message;
this.status = status;
this.isPublic = isPublic;
this.isOperational = true; // This is required since bluebird 4 doesn't append it anymore.
Error.captureStackTrace(this, this.constructor.name);
}
}
/**
* Class representing an API error.
* #extends MyExtendableError
*/
class APIError extends MyExtendableError {
constructor(message, status = httpStatus.INTERNAL_SERVER_ERROR, isPublic = false) {
super(message, status, isPublic);
}
}
export default APIError;
Express.js
// catch 404 and forward to error handler
/* istanbul ignore next */
app.use((req, res, next) => {
const err = new APIError('API not found', httpStatus.NOT_FOUND);
return next(err);
});
// if error is not an instance Of APIError, convert it.
app.use((err, req, res, next) => {
if (err instanceof expressValidation.ValidationError) {
// validation error contains errors which is an array of error each containing message[]
const unifiedErrorMessage = err.errors.map((error) => {
return error.messages.join('. ');
}).join(' and ');
const error = new APIError(unifiedErrorMessage, err.status, true);
res.status(error.status).json({
message: err.isPublic ? err.message : httpStatus[err.status],
stack: (config.env === 'test' || config.env === 'development' ) ? err.stack : {}
});
} else if (!(err instanceof APIError)) {
const apiError = new APIError(err.message, err.status, err.isPublic);
res.status(apiError.status).json({
message: err.isPublic ? err.message : httpStatus[err.status],
stack: (config.env === 'test' || config.env === 'development' ) ? err.stack : {}
});
}else {
res.status(err.status).json({
message: err.isPublic ? err.message : httpStatus[err.status],
stack: (config.env === 'test' || config.env === 'development' ) ? err.stack : {}
});
}
});
auth.route.js
import express from 'express';
import validate from 'express-validation';
import expressJwt from 'express-jwt';
import paramValidation from '../../../config/param-validation';
import authCtrl from '../controllers/auth.controller';
import config from '../../../config/config';
const router = express.Router();
/** POST /api/auth/login - Returns token if correct username and password is provided */
router.route('/login')
.post(validate(paramValidation.login), authCtrl.login);
auth.controller.js
function login(req, res, next) {
// fetch user from the db
User.findOne(req.body)
.exec() // make query a Promise
.then((user) => {
const token = jwt.sign({ username: user.username }, config.jwtSecret);
return res.json({ token, username: user.username });
})
.catch(() => {
const err = new APIError('Authentication error', httpStatus.UNAUTHORIZED, true);
return next(err);
});
}
auth.test.js
..
it('should return Authentication error', () => {
return request(app)
.post('/api/v1/auth/login')
.send(invalidUserCredentials)
.expect(httpStatus.UNAUTHORIZED)
.then((res) => {
expect(res.body.message).to.equal('Authentication error');
});
});
...