| var deepEqual = require('deep-equal'); |
| var defined = require('defined'); |
| var path = require('path'); |
| var inherits = require('inherits'); |
| var EventEmitter = require('events').EventEmitter; |
| |
| module.exports = Test; |
| |
| var nextTick = typeof setImmediate !== 'undefined' |
| ? setImmediate |
| : process.nextTick |
| ; |
| |
| inherits(Test, EventEmitter); |
| |
| var getTestArgs = function (name_, opts_, cb_) { |
| var name = '(anonymous)'; |
| var opts = {}; |
| var cb; |
| |
| for (var i = 0; i < arguments.length; i++) { |
| var arg = arguments[i]; |
| var t = typeof arg; |
| if (t === 'string') { |
| name = arg; |
| } |
| else if (t === 'object') { |
| opts = arg || opts; |
| } |
| else if (t === 'function') { |
| cb = arg; |
| } |
| } |
| return { name: name, opts: opts, cb: cb }; |
| }; |
| |
| function Test (name_, opts_, cb_) { |
| if (! (this instanceof Test)) { |
| return new Test(name_, opts_, cb_); |
| } |
| |
| var args = getTestArgs(name_, opts_, cb_); |
| |
| this.readable = true; |
| this.name = args.name || '(anonymous)'; |
| this.assertCount = 0; |
| this.pendingCount = 0; |
| this._skip = args.opts.skip || false; |
| this._plan = undefined; |
| this._cb = args.cb; |
| this._progeny = []; |
| this._ok = true; |
| |
| if (args.opts.timeout !== undefined) { |
| this.timeoutAfter(args.opts.timeout); |
| } |
| |
| for (var prop in this) { |
| this[prop] = (function bind(self, val) { |
| if (typeof val === 'function') { |
| return function bound() { |
| return val.apply(self, arguments); |
| }; |
| } |
| else return val; |
| })(this, this[prop]); |
| } |
| } |
| |
| Test.prototype.run = function () { |
| if (!this._cb || this._skip) { |
| return this._end(); |
| } |
| this.emit('prerun'); |
| this._cb(this); |
| this.emit('run'); |
| }; |
| |
| Test.prototype.test = function (name, opts, cb) { |
| var self = this; |
| var t = new Test(name, opts, cb); |
| this._progeny.push(t); |
| this.pendingCount++; |
| this.emit('test', t); |
| t.on('prerun', function () { |
| self.assertCount++; |
| }) |
| |
| if (!self._pendingAsserts()) { |
| nextTick(function () { |
| self._end(); |
| }); |
| } |
| |
| nextTick(function() { |
| if (!self._plan && self.pendingCount == self._progeny.length) { |
| self._end(); |
| } |
| }); |
| }; |
| |
| Test.prototype.comment = function (msg) { |
| this.emit('result', msg.trim().replace(/^#\s*/, '')); |
| }; |
| |
| Test.prototype.plan = function (n) { |
| this._plan = n; |
| this.emit('plan', n); |
| }; |
| |
| Test.prototype.timeoutAfter = function(ms) { |
| if (!ms) throw new Error('timeoutAfter requires a timespan'); |
| var self = this; |
| var timeout = setTimeout(function() { |
| self.fail('test timed out after ' + ms + 'ms'); |
| self.end(); |
| }, ms); |
| this.once('end', function() { |
| clearTimeout(timeout); |
| }); |
| } |
| |
| Test.prototype.end = function (err) { |
| var self = this; |
| if (arguments.length >= 1) { |
| this.ifError(err); |
| } |
| |
| if (this.calledEnd) { |
| this.fail('.end() called twice'); |
| } |
| this.calledEnd = true; |
| this._end(); |
| }; |
| |
| Test.prototype._end = function (err) { |
| var self = this; |
| if (this._progeny.length) { |
| var t = this._progeny.shift(); |
| t.on('end', function () { self._end() }); |
| t.run(); |
| return; |
| } |
| |
| if (!this.ended) this.emit('end'); |
| var pendingAsserts = this._pendingAsserts(); |
| if (!this._planError && this._plan !== undefined && pendingAsserts) { |
| this._planError = true; |
| this.fail('plan != count', { |
| expected : this._plan, |
| actual : this.assertCount |
| }); |
| } |
| this.ended = true; |
| }; |
| |
| Test.prototype._exit = function () { |
| if (this._plan !== undefined && |
| !this._planError && this.assertCount !== this._plan) { |
| this._planError = true; |
| this.fail('plan != count', { |
| expected : this._plan, |
| actual : this.assertCount, |
| exiting : true |
| }); |
| } |
| else if (!this.ended) { |
| this.fail('test exited without ending', { |
| exiting: true |
| }); |
| } |
| }; |
| |
| Test.prototype._pendingAsserts = function () { |
| if (this._plan === undefined) { |
| return 1; |
| } |
| else { |
| return this._plan - (this._progeny.length + this.assertCount); |
| } |
| }; |
| |
| Test.prototype._assert = function assert (ok, opts) { |
| var self = this; |
| var extra = opts.extra || {}; |
| |
| var res = { |
| id : self.assertCount ++, |
| ok : Boolean(ok), |
| skip : defined(extra.skip, opts.skip), |
| name : defined(extra.message, opts.message, '(unnamed assert)'), |
| operator : defined(extra.operator, opts.operator) |
| }; |
| if (has(opts, 'actual') || has(extra, 'actual')) { |
| res.actual = defined(extra.actual, opts.actual); |
| } |
| if (has(opts, 'expected') || has(extra, 'expected')) { |
| res.expected = defined(extra.expected, opts.expected); |
| } |
| this._ok = Boolean(this._ok && ok); |
| |
| if (!ok) { |
| res.error = defined(extra.error, opts.error, new Error(res.name)); |
| } |
| |
| if (!ok) { |
| var e = new Error('exception'); |
| var err = (e.stack || '').split('\n'); |
| var dir = path.dirname(__dirname) + '/'; |
| |
| for (var i = 0; i < err.length; i++) { |
| var m = /^[^\s]*\s*\bat\s+(.+)/.exec(err[i]); |
| if (!m) { |
| continue; |
| } |
| |
| var s = m[1].split(/\s+/); |
| var filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[1]); |
| if (!filem) { |
| filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[2]); |
| |
| if (!filem) { |
| filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[3]); |
| |
| if (!filem) { |
| continue; |
| } |
| } |
| } |
| |
| if (filem[1].slice(0, dir.length) === dir) { |
| continue; |
| } |
| |
| res.functionName = s[0]; |
| res.file = filem[1]; |
| res.line = Number(filem[2]); |
| if (filem[3]) res.column = filem[3]; |
| |
| res.at = m[1]; |
| break; |
| } |
| } |
| |
| self.emit('result', res); |
| |
| var pendingAsserts = self._pendingAsserts(); |
| if (!pendingAsserts) { |
| if (extra.exiting) { |
| self._end(); |
| } else { |
| nextTick(function () { |
| self._end(); |
| }); |
| } |
| } |
| |
| if (!self._planError && pendingAsserts < 0) { |
| self._planError = true; |
| self.fail('plan != count', { |
| expected : self._plan, |
| actual : self._plan - pendingAsserts |
| }); |
| } |
| }; |
| |
| Test.prototype.fail = function (msg, extra) { |
| this._assert(false, { |
| message : msg, |
| operator : 'fail', |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.pass = function (msg, extra) { |
| this._assert(true, { |
| message : msg, |
| operator : 'pass', |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.skip = function (msg, extra) { |
| this._assert(true, { |
| message : msg, |
| operator : 'skip', |
| skip : true, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.ok |
| = Test.prototype['true'] |
| = Test.prototype.assert |
| = function (value, msg, extra) { |
| this._assert(value, { |
| message : msg, |
| operator : 'ok', |
| expected : true, |
| actual : value, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.notOk |
| = Test.prototype['false'] |
| = Test.prototype.notok |
| = function (value, msg, extra) { |
| this._assert(!value, { |
| message : msg, |
| operator : 'notOk', |
| expected : false, |
| actual : value, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.error |
| = Test.prototype.ifError |
| = Test.prototype.ifErr |
| = Test.prototype.iferror |
| = function (err, msg, extra) { |
| this._assert(!err, { |
| message : defined(msg, String(err)), |
| operator : 'error', |
| actual : err, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.equal |
| = Test.prototype.equals |
| = Test.prototype.isEqual |
| = Test.prototype.is |
| = Test.prototype.strictEqual |
| = Test.prototype.strictEquals |
| = function (a, b, msg, extra) { |
| this._assert(a === b, { |
| message : defined(msg, 'should be equal'), |
| operator : 'equal', |
| actual : a, |
| expected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.notEqual |
| = Test.prototype.notEquals |
| = Test.prototype.notStrictEqual |
| = Test.prototype.notStrictEquals |
| = Test.prototype.isNotEqual |
| = Test.prototype.isNot |
| = Test.prototype.not |
| = Test.prototype.doesNotEqual |
| = Test.prototype.isInequal |
| = function (a, b, msg, extra) { |
| this._assert(a !== b, { |
| message : defined(msg, 'should not be equal'), |
| operator : 'notEqual', |
| actual : a, |
| notExpected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.deepEqual |
| = Test.prototype.deepEquals |
| = Test.prototype.isEquivalent |
| = Test.prototype.same |
| = function (a, b, msg, extra) { |
| this._assert(deepEqual(a, b, { strict: true }), { |
| message : defined(msg, 'should be equivalent'), |
| operator : 'deepEqual', |
| actual : a, |
| expected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.deepLooseEqual |
| = Test.prototype.looseEqual |
| = Test.prototype.looseEquals |
| = function (a, b, msg, extra) { |
| this._assert(deepEqual(a, b), { |
| message : defined(msg, 'should be equivalent'), |
| operator : 'deepLooseEqual', |
| actual : a, |
| expected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.notDeepEqual |
| = Test.prototype.notEquivalent |
| = Test.prototype.notDeeply |
| = Test.prototype.notSame |
| = Test.prototype.isNotDeepEqual |
| = Test.prototype.isNotDeeply |
| = Test.prototype.isNotEquivalent |
| = Test.prototype.isInequivalent |
| = function (a, b, msg, extra) { |
| this._assert(!deepEqual(a, b, { strict: true }), { |
| message : defined(msg, 'should not be equivalent'), |
| operator : 'notDeepEqual', |
| actual : a, |
| notExpected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.notDeepLooseEqual |
| = Test.prototype.notLooseEqual |
| = Test.prototype.notLooseEquals |
| = function (a, b, msg, extra) { |
| this._assert(!deepEqual(a, b), { |
| message : defined(msg, 'should be equivalent'), |
| operator : 'notDeepLooseEqual', |
| actual : a, |
| expected : b, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype['throws'] = function (fn, expected, msg, extra) { |
| if (typeof expected === 'string') { |
| msg = expected; |
| expected = undefined; |
| } |
| |
| var caught = undefined; |
| |
| try { |
| fn(); |
| } catch (err) { |
| caught = { error : err }; |
| var message = err.message; |
| delete err.message; |
| err.message = message; |
| } |
| |
| var passed = caught; |
| |
| if (expected instanceof RegExp) { |
| passed = expected.test(caught && caught.error); |
| expected = String(expected); |
| } |
| |
| if (typeof expected === 'function') { |
| passed = caught.error instanceof expected; |
| caught.error = caught.error.constructor; |
| } |
| |
| this._assert(passed, { |
| message : defined(msg, 'should throw'), |
| operator : 'throws', |
| actual : caught && caught.error, |
| expected : expected, |
| error: !passed && caught && caught.error, |
| extra : extra |
| }); |
| }; |
| |
| Test.prototype.doesNotThrow = function (fn, expected, msg, extra) { |
| if (typeof expected === 'string') { |
| msg = expected; |
| expected = undefined; |
| } |
| var caught = undefined; |
| try { |
| fn(); |
| } |
| catch (err) { |
| caught = { error : err }; |
| } |
| this._assert(!caught, { |
| message : defined(msg, 'should not throw'), |
| operator : 'throws', |
| actual : caught && caught.error, |
| expected : expected, |
| error : caught && caught.error, |
| extra : extra |
| }); |
| }; |
| |
| function has (obj, prop) { |
| return Object.prototype.hasOwnProperty.call(obj, prop); |
| } |
| |
| Test.skip = function (name_, _opts, _cb) { |
| var args = getTestArgs.apply(null, arguments); |
| args.opts.skip = true; |
| return Test(args.name, args.opts, args.cb); |
| }; |
| |
| // vim: set softtabstop=4 shiftwidth=4: |
| |