Ghost/core/test/unit/errorHandling_spec.js

398 lines
13 KiB
JavaScript
Raw Normal View History

2014-06-05 01:26:03 +04:00
/*globals describe, after, before, beforeEach, afterEach, it*/
/*jshint expr:true*/
var should = require('should'),
when = require('when'),
sinon = require('sinon'),
express = require('express'),
2014-06-05 01:26:03 +04:00
rewire = require('rewire'),
// Stuff we are testing
2014-06-05 01:26:03 +04:00
colors = require('colors'),
errors = rewire('../../server/errors'),
// storing current environment
currentEnv = process.env.NODE_ENV;
2014-06-05 01:26:03 +04:00
// This is not useful but required for jshint
colors.setTheme({silly: 'rainbow'});
describe('Error handling', function () {
2013-05-26 22:51:58 +04:00
// Just getting rid of jslint unused error
should.exist(errors);
2013-05-26 22:51:58 +04:00
describe('Throwing', function () {
2014-06-05 01:26:03 +04:00
it('throws error objects', function () {
var toThrow = new Error('test1'),
runThrowError = function () {
errors.throwError(toThrow);
};
2013-05-26 22:51:58 +04:00
2014-06-05 01:26:03 +04:00
runThrowError.should['throw']('test1');
});
2013-05-26 22:51:58 +04:00
2014-06-05 01:26:03 +04:00
it('throws error strings', function () {
var toThrow = 'test2',
runThrowError = function () {
errors.throwError(toThrow);
};
2013-05-26 22:51:58 +04:00
2014-06-05 01:26:03 +04:00
runThrowError.should['throw']('test2');
});
2013-05-26 22:51:58 +04:00
2014-06-05 01:26:03 +04:00
it('throws error even if nothing passed', function () {
var runThrowError = function () {
errors.throwError();
};
2013-05-26 22:51:58 +04:00
2014-06-05 01:26:03 +04:00
runThrowError.should['throw']('An error occurred');
});
});
2013-05-26 22:51:58 +04:00
describe('Logging', function () {
var logStub;
beforeEach(function () {
logStub = sinon.stub(console, 'error');
// give environment a value that will console log
2014-06-05 01:26:03 +04:00
process.env.NODE_ENV = 'development';
});
afterEach(function () {
logStub.restore();
// reset the environment
process.env.NODE_ENV = currentEnv;
});
it('logs errors from error objects', function () {
var err = new Error('test1');
errors.logError(err);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
logStub.calledWith('\nERROR:'.red, err.message.red, '\n', '\n', err.stack, '\n').should.be.true;
});
it('logs errors from strings', function () {
var err = 'test2';
errors.logError(err);
// Calls log with string on strings
logStub.calledOnce.should.be.true;
logStub.calledWith('\nERROR:'.red, err.red, '\n').should.be.true;
});
2013-05-26 22:51:58 +04:00
it('logs errors from an error object and two string arguments', function () {
var err = new Error('test1'),
message = 'Testing';
2013-05-26 22:51:58 +04:00
errors.logError(err, message, message);
2013-05-26 22:51:58 +04:00
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
2014-06-05 01:26:03 +04:00
logStub.calledWith(
'\nERROR:'.red, err.message.red, '\n', message.white, '\n', message.green, '\n', err.stack, '\n'
);
});
2013-05-26 22:51:58 +04:00
it('logs errors from three string arguments', function () {
var message = 'Testing';
errors.logError(message, message, message);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
2014-06-05 01:26:03 +04:00
logStub.calledWith(
'\nERROR:'.red, message.red, '\n', message.white, '\n', message.green, '\n'
).should.be.true;
});
2013-05-26 22:51:58 +04:00
it('logs errors from an undefined error argument', function () {
var message = 'Testing';
errors.logError(undefined, message, message);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
2014-06-05 01:26:03 +04:00
logStub.calledWith(
'\nERROR:'.red, 'An unknown error occurred.'.red, '\n', message.white, '\n', message.green , '\n'
).should.be.true;
});
it('logs errors from an undefined context argument', function () {
var message = 'Testing';
errors.logError(message, undefined, message);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
logStub.calledWith('\nERROR:'.red, message.red, '\n', message.green, '\n').should.be.true;
});
it('logs errors from an undefined help argument', function () {
var message = 'Testing';
errors.logError(message, message, undefined);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
logStub.calledWith('\nERROR:'.red, message.red, '\n', message.white, '\n').should.be.true;
});
it('logs errors from a null error argument', function () {
var message = 'Testing';
errors.logError(null, message, message);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
2014-06-05 01:26:03 +04:00
logStub.calledWith(
'\nERROR:'.red, 'An unknown error occurred.'.red, '\n', message.white, '\n', message.green, '\n'
).should.be.true;
});
it('logs errors from a null context argument', function () {
var message = 'Testing';
errors.logError(message, null, message);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
logStub.firstCall.calledWith('\nERROR:'.red, message.red, '\n', message.green, '\n').should.be.true;
});
it('logs errors from a null help argument', function () {
var message = 'Testing';
errors.logError(message, message, null);
// Calls log with message on Error objects
logStub.calledOnce.should.be.true;
logStub.firstCall.calledWith('\nERROR:'.red, message.red, '\n', message.white, '\n').should.be.true;
});
it('logs promise errors and redirects', function (done) {
var def = when.defer(),
prom = def.promise,
req = null,
res = {
redirect: function () {
return;
}
},
redirectStub = sinon.stub(res, 'redirect');
// give environment a value that will console log
prom.then(function () {
throw new Error('Ran success handler');
}, errors.logErrorWithRedirect('test1', null, null, '/testurl', req, res));
prom.otherwise(function () {
logStub.calledWith('\nERROR:'.red, 'test1'.red).should.equal(true);
logStub.restore();
redirectStub.calledWith('/testurl').should.equal(true);
redirectStub.restore();
done();
});
def.reject();
});
});
2013-05-26 22:51:58 +04:00
describe('Rendering', function () {
var sandbox,
originalConfig;
2013-05-26 22:51:58 +04:00
before(function () {
originalConfig = errors.__get__('config');
errors.__set__('config', function () {
return {
'paths': {
'themePath': '/content/themes',
'availableThemes': {
'casper': {
'assets': null,
'default.hbs': '/content/themes/casper/default.hbs',
'index.hbs': '/content/themes/casper/index.hbs',
'page.hbs': '/content/themes/casper/page.hbs',
'tag.hbs': '/content/themes/casper/tag.hbs'
},
'theme-with-error': {
'error.hbs':''
}
}
}
2014-06-05 01:26:03 +04:00
};
});
errors.updateActiveTheme('casper');
});
2013-05-26 22:51:58 +04:00
beforeEach(function () {
sandbox = sinon.sandbox.create();
2013-05-26 22:51:58 +04:00
});
afterEach(function () {
sandbox.restore();
});
after(function () {
errors.__set__('config', originalConfig);
});
it('Renders end-of-middleware 404 errors correctly', function (done) {
var req = {method: 'GET'},
res = express.response;
sandbox.stub(express.response, 'render', function (view, options, fn) {
2014-06-05 01:26:03 +04:00
/*jshint unused:false */
view.should.match(/user-error\.hbs/);
// Test that the message is correct
options.message.should.equal('Page Not Found');
options.code.should.equal(404);
this.statusCode.should.equal(404);
// Test that the headers are correct
2014-06-05 01:26:03 +04:00
this._headers['cache-control'].should.equal(
'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0'
);
done();
});
sandbox.stub(express.response, 'status', function (status) {
res.statusCode = status;
return res;
});
errors.error404(req, res, done);
});
it('Renders thrown 404 errors correctly', function (done) {
var err = new Error('A thing was not found'),
req = {method: 'GET'},
res = express.response;
sandbox.stub(express.response, 'render', function (view, options, fn) {
2014-06-05 01:26:03 +04:00
/*jshint unused:false */
view.should.match(/user-error\.hbs/);
// Test that the message is correct
options.message.should.equal('Page Not Found');
options.code.should.equal(404);
this.statusCode.should.equal(404);
// Test that the headers are correct
2014-06-05 01:26:03 +04:00
this._headers['cache-control'].should.equal(
'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0'
);
done();
});
sandbox.stub(express.response, 'status', function (status) {
res.statusCode = status;
return res;
});
err.status = 404;
errors.error500(err, req, res, null);
});
it('Renders thrown errors correctly', function (done) {
var err = new Error('I am a big bad error'),
req = {method: 'GET'},
res = express.response;
sandbox.stub(express.response, 'render', function (view, options, fn) {
2014-06-05 01:26:03 +04:00
/*jshint unused:false */
view.should.match(/user-error\.hbs/);
// Test that the message is correct
options.message.should.equal('I am a big bad error');
options.code.should.equal(500);
this.statusCode.should.equal(500);
// Test that the headers are correct
2014-06-05 01:26:03 +04:00
this._headers['cache-control'].should.equal(
'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0'
);
done();
});
sandbox.stub(express.response, 'status', function (status) {
res.statusCode = status;
return res;
});
errors.error500(err, req, res, null);
});
it('Renders 500 errors correctly', function (done) {
var err = new Error('I am a big bad error'),
req = {method: 'GET'},
res = express.response;
sandbox.stub(express.response, 'render', function (view, options, fn) {
2014-06-05 01:26:03 +04:00
/*jshint unused:false */
view.should.match(/user-error\.hbs/);
// Test that the message is correct
options.message.should.equal('I am a big bad error');
options.code.should.equal(500);
this.statusCode.should.equal(500);
// Test that the headers are correct
2014-06-05 01:26:03 +04:00
this._headers['cache-control'].should.equal(
'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0'
);
done();
});
sandbox.stub(express.response, 'status', function (status) {
res.statusCode = status;
return res;
});
err.code = 500;
errors.error500(err, req, res, null);
});
2014-06-05 01:26:03 +04:00
it('Renders custom error template if one exists', function(done){
var code = 404,
error = {message:'Custom view test'},
req = {
session: null
},
res = {
status: function(code) {
2014-06-05 01:26:03 +04:00
/*jshint unused:false*/
return this;
},
render: function(view, model, fn){
2014-06-05 01:26:03 +04:00
/*jshint unused:false*/
view.should.eql('error');
errors.updateActiveTheme('casper');
done();
}
},
next = null;
errors.updateActiveTheme('theme-with-error');
errors.renderErrorPage(code, error, req, res, next);
});
2013-05-26 22:51:58 +04:00
});
});