356 lines
7.4 KiB
JavaScript
356 lines
7.4 KiB
JavaScript
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var EventEmitter = require('events').EventEmitter
|
|
, debug = require('debug')('mocha:suite')
|
|
, milliseconds = require('./ms')
|
|
, utils = require('./utils')
|
|
, Hook = require('./hook');
|
|
|
|
/**
|
|
* Expose `Suite`.
|
|
*/
|
|
|
|
exports = module.exports = Suite;
|
|
|
|
/**
|
|
* Create a new `Suite` with the given `title`
|
|
* and parent `Suite`. When a suite with the
|
|
* same title is already present, that suite
|
|
* is returned to provide nicer reporter
|
|
* and more flexible meta-testing.
|
|
*
|
|
* @param {Suite} parent
|
|
* @param {String} title
|
|
* @return {Suite}
|
|
* @api public
|
|
*/
|
|
|
|
exports.create = function(parent, title){
|
|
var suite = new Suite(title, parent.ctx);
|
|
suite.parent = parent;
|
|
if (parent.pending) suite.pending = true;
|
|
title = suite.fullTitle();
|
|
parent.addSuite(suite);
|
|
return suite;
|
|
};
|
|
|
|
/**
|
|
* Initialize a new `Suite` with the given
|
|
* `title` and `ctx`.
|
|
*
|
|
* @param {String} title
|
|
* @param {Context} ctx
|
|
* @api private
|
|
*/
|
|
|
|
function Suite(title, parentContext) {
|
|
this.title = title;
|
|
var context = function() {};
|
|
context.prototype = parentContext;
|
|
this.ctx = new context();
|
|
this.suites = [];
|
|
this.tests = [];
|
|
this.pending = false;
|
|
this._beforeEach = [];
|
|
this._beforeAll = [];
|
|
this._afterEach = [];
|
|
this._afterAll = [];
|
|
this.root = !title;
|
|
this._timeout = 2000;
|
|
this._enableTimeouts = true;
|
|
this._slow = 75;
|
|
this._bail = false;
|
|
this.delayed = false;
|
|
}
|
|
|
|
/**
|
|
* Inherit from `EventEmitter.prototype`.
|
|
*/
|
|
|
|
Suite.prototype.__proto__ = EventEmitter.prototype;
|
|
|
|
/**
|
|
* Return a clone of this `Suite`.
|
|
*
|
|
* @return {Suite}
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.clone = function(){
|
|
var suite = new Suite(this.title);
|
|
debug('clone');
|
|
suite.ctx = this.ctx;
|
|
suite.timeout(this.timeout());
|
|
suite.enableTimeouts(this.enableTimeouts());
|
|
suite.slow(this.slow());
|
|
suite.bail(this.bail());
|
|
return suite;
|
|
};
|
|
|
|
/**
|
|
* Set timeout `ms` or short-hand such as "2s".
|
|
*
|
|
* @param {Number|String} ms
|
|
* @return {Suite|Number} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.timeout = function(ms){
|
|
if (0 == arguments.length) return this._timeout;
|
|
if (ms.toString() === '0') this._enableTimeouts = false;
|
|
if ('string' == typeof ms) ms = milliseconds(ms);
|
|
debug('timeout %d', ms);
|
|
this._timeout = parseInt(ms, 10);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set timeout `enabled`.
|
|
*
|
|
* @param {Boolean} enabled
|
|
* @return {Suite|Boolean} self or enabled
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.enableTimeouts = function(enabled){
|
|
if (arguments.length === 0) return this._enableTimeouts;
|
|
debug('enableTimeouts %s', enabled);
|
|
this._enableTimeouts = enabled;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set slow `ms` or short-hand such as "2s".
|
|
*
|
|
* @param {Number|String} ms
|
|
* @return {Suite|Number} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.slow = function(ms){
|
|
if (0 === arguments.length) return this._slow;
|
|
if ('string' == typeof ms) ms = milliseconds(ms);
|
|
debug('slow %d', ms);
|
|
this._slow = ms;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Sets whether to bail after first error.
|
|
*
|
|
* @param {Boolean} bail
|
|
* @return {Suite|Number} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.bail = function(bail){
|
|
if (0 == arguments.length) return this._bail;
|
|
debug('bail %s', bail);
|
|
this._bail = bail;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Run `fn(test[, done])` before running tests.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.beforeAll = function(title, fn){
|
|
if (this.pending) return this;
|
|
if ('function' === typeof title) {
|
|
fn = title;
|
|
title = fn.name;
|
|
}
|
|
title = '"before all" hook' + (title ? ': ' + title : '');
|
|
|
|
var hook = new Hook(title, fn);
|
|
hook.parent = this;
|
|
hook.timeout(this.timeout());
|
|
hook.enableTimeouts(this.enableTimeouts());
|
|
hook.slow(this.slow());
|
|
hook.ctx = this.ctx;
|
|
this._beforeAll.push(hook);
|
|
this.emit('beforeAll', hook);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Run `fn(test[, done])` after running tests.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.afterAll = function(title, fn){
|
|
if (this.pending) return this;
|
|
if ('function' === typeof title) {
|
|
fn = title;
|
|
title = fn.name;
|
|
}
|
|
title = '"after all" hook' + (title ? ': ' + title : '');
|
|
|
|
var hook = new Hook(title, fn);
|
|
hook.parent = this;
|
|
hook.timeout(this.timeout());
|
|
hook.enableTimeouts(this.enableTimeouts());
|
|
hook.slow(this.slow());
|
|
hook.ctx = this.ctx;
|
|
this._afterAll.push(hook);
|
|
this.emit('afterAll', hook);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Run `fn(test[, done])` before each test case.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.beforeEach = function(title, fn){
|
|
if (this.pending) return this;
|
|
if ('function' === typeof title) {
|
|
fn = title;
|
|
title = fn.name;
|
|
}
|
|
title = '"before each" hook' + (title ? ': ' + title : '');
|
|
|
|
var hook = new Hook(title, fn);
|
|
hook.parent = this;
|
|
hook.timeout(this.timeout());
|
|
hook.enableTimeouts(this.enableTimeouts());
|
|
hook.slow(this.slow());
|
|
hook.ctx = this.ctx;
|
|
this._beforeEach.push(hook);
|
|
this.emit('beforeEach', hook);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Run `fn(test[, done])` after each test case.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.afterEach = function(title, fn){
|
|
if (this.pending) return this;
|
|
if ('function' === typeof title) {
|
|
fn = title;
|
|
title = fn.name;
|
|
}
|
|
title = '"after each" hook' + (title ? ': ' + title : '');
|
|
|
|
var hook = new Hook(title, fn);
|
|
hook.parent = this;
|
|
hook.timeout(this.timeout());
|
|
hook.enableTimeouts(this.enableTimeouts());
|
|
hook.slow(this.slow());
|
|
hook.ctx = this.ctx;
|
|
this._afterEach.push(hook);
|
|
this.emit('afterEach', hook);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add a test `suite`.
|
|
*
|
|
* @param {Suite} suite
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.addSuite = function(suite){
|
|
suite.parent = this;
|
|
suite.timeout(this.timeout());
|
|
suite.enableTimeouts(this.enableTimeouts());
|
|
suite.slow(this.slow());
|
|
suite.bail(this.bail());
|
|
this.suites.push(suite);
|
|
this.emit('suite', suite);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add a `test` to this suite.
|
|
*
|
|
* @param {Test} test
|
|
* @return {Suite} for chaining
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.addTest = function(test){
|
|
test.parent = this;
|
|
test.timeout(this.timeout());
|
|
test.enableTimeouts(this.enableTimeouts());
|
|
test.slow(this.slow());
|
|
test.ctx = this.ctx;
|
|
this.tests.push(test);
|
|
this.emit('test', test);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return the full title generated by recursively
|
|
* concatenating the parent's full title.
|
|
*
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
Suite.prototype.fullTitle = function(){
|
|
if (this.parent) {
|
|
var full = this.parent.fullTitle();
|
|
if (full) return full + ' ' + this.title;
|
|
}
|
|
return this.title;
|
|
};
|
|
|
|
/**
|
|
* Return the total number of tests.
|
|
*
|
|
* @return {Number}
|
|
* @api public
|
|
*/
|
|
|
|
Suite.prototype.total = function(){
|
|
return utils.reduce(this.suites, function(sum, suite){
|
|
return sum + suite.total();
|
|
}, 0) + this.tests.length;
|
|
};
|
|
|
|
/**
|
|
* Iterates through each suite recursively to find
|
|
* all tests. Applies a function in the format
|
|
* `fn(test)`.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Suite}
|
|
* @api private
|
|
*/
|
|
|
|
Suite.prototype.eachTest = function(fn){
|
|
utils.forEach(this.tests, fn);
|
|
utils.forEach(this.suites, function(suite){
|
|
suite.eachTest(fn);
|
|
});
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* This will run the root suite if we happen to be running in delayed mode.
|
|
*/
|
|
Suite.prototype.run = function run() {
|
|
if (this.root) {
|
|
this.emit('run');
|
|
}
|
|
};
|