| /*! |
| * chai |
| * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> |
| * MIT Licensed |
| */ |
| |
| module.exports = function (chai, util) { |
| var Assertion = chai.Assertion; |
| |
| function loadShould () { |
| // explicitly define this method as function as to have it's name to include as `ssfi` |
| function shouldGetter() { |
| if (this instanceof String |
| || this instanceof Number |
| || this instanceof Boolean |
| || typeof Symbol === 'function' && this instanceof Symbol) { |
| return new Assertion(this.valueOf(), null, shouldGetter); |
| } |
| return new Assertion(this, null, shouldGetter); |
| } |
| function shouldSetter(value) { |
| // See https://github.com/chaijs/chai/issues/86: this makes |
| // `whatever.should = someValue` actually set `someValue`, which is |
| // especially useful for `global.should = require('chai').should()`. |
| // |
| // Note that we have to use [[DefineProperty]] instead of [[Put]] |
| // since otherwise we would trigger this very setter! |
| Object.defineProperty(this, 'should', { |
| value: value, |
| enumerable: true, |
| configurable: true, |
| writable: true |
| }); |
| } |
| // modify Object.prototype to have `should` |
| Object.defineProperty(Object.prototype, 'should', { |
| set: shouldSetter |
| , get: shouldGetter |
| , configurable: true |
| }); |
| |
| var should = {}; |
| |
| /** |
| * ### .fail([message]) |
| * ### .fail(actual, expected, [message], [operator]) |
| * |
| * Throw a failure. |
| * |
| * should.fail(); |
| * should.fail("custom error message"); |
| * should.fail(1, 2); |
| * should.fail(1, 2, "custom error message"); |
| * should.fail(1, 2, "custom error message", ">"); |
| * should.fail(1, 2, undefined, ">"); |
| * |
| * |
| * @name fail |
| * @param {Mixed} actual |
| * @param {Mixed} expected |
| * @param {String} message |
| * @param {String} operator |
| * @namespace BDD |
| * @api public |
| */ |
| |
| should.fail = function (actual, expected, message, operator) { |
| if (arguments.length < 2) { |
| message = actual; |
| actual = undefined; |
| } |
| |
| message = message || 'should.fail()'; |
| throw new chai.AssertionError(message, { |
| actual: actual |
| , expected: expected |
| , operator: operator |
| }, should.fail); |
| }; |
| |
| /** |
| * ### .equal(actual, expected, [message]) |
| * |
| * Asserts non-strict equality (`==`) of `actual` and `expected`. |
| * |
| * should.equal(3, '3', '== coerces values to strings'); |
| * |
| * @name equal |
| * @param {Mixed} actual |
| * @param {Mixed} expected |
| * @param {String} message |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.equal = function (val1, val2, msg) { |
| new Assertion(val1, msg).to.equal(val2); |
| }; |
| |
| /** |
| * ### .throw(function, [constructor/string/regexp], [string/regexp], [message]) |
| * |
| * Asserts that `function` will throw an error that is an instance of |
| * `constructor`, or alternately that it will throw an error with message |
| * matching `regexp`. |
| * |
| * should.throw(fn, 'function throws a reference error'); |
| * should.throw(fn, /function throws a reference error/); |
| * should.throw(fn, ReferenceError); |
| * should.throw(fn, ReferenceError, 'function throws a reference error'); |
| * should.throw(fn, ReferenceError, /function throws a reference error/); |
| * |
| * @name throw |
| * @alias Throw |
| * @param {Function} function |
| * @param {ErrorConstructor} constructor |
| * @param {RegExp} regexp |
| * @param {String} message |
| * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.Throw = function (fn, errt, errs, msg) { |
| new Assertion(fn, msg).to.Throw(errt, errs); |
| }; |
| |
| /** |
| * ### .exist |
| * |
| * Asserts that the target is neither `null` nor `undefined`. |
| * |
| * var foo = 'hi'; |
| * |
| * should.exist(foo, 'foo exists'); |
| * |
| * @name exist |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.exist = function (val, msg) { |
| new Assertion(val, msg).to.exist; |
| } |
| |
| // negation |
| should.not = {} |
| |
| /** |
| * ### .not.equal(actual, expected, [message]) |
| * |
| * Asserts non-strict inequality (`!=`) of `actual` and `expected`. |
| * |
| * should.not.equal(3, 4, 'these numbers are not equal'); |
| * |
| * @name not.equal |
| * @param {Mixed} actual |
| * @param {Mixed} expected |
| * @param {String} message |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.not.equal = function (val1, val2, msg) { |
| new Assertion(val1, msg).to.not.equal(val2); |
| }; |
| |
| /** |
| * ### .throw(function, [constructor/regexp], [message]) |
| * |
| * Asserts that `function` will _not_ throw an error that is an instance of |
| * `constructor`, or alternately that it will not throw an error with message |
| * matching `regexp`. |
| * |
| * should.not.throw(fn, Error, 'function does not throw'); |
| * |
| * @name not.throw |
| * @alias not.Throw |
| * @param {Function} function |
| * @param {ErrorConstructor} constructor |
| * @param {RegExp} regexp |
| * @param {String} message |
| * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.not.Throw = function (fn, errt, errs, msg) { |
| new Assertion(fn, msg).to.not.Throw(errt, errs); |
| }; |
| |
| /** |
| * ### .not.exist |
| * |
| * Asserts that the target is neither `null` nor `undefined`. |
| * |
| * var bar = null; |
| * |
| * should.not.exist(bar, 'bar does not exist'); |
| * |
| * @name not.exist |
| * @namespace Should |
| * @api public |
| */ |
| |
| should.not.exist = function (val, msg) { |
| new Assertion(val, msg).to.not.exist; |
| } |
| |
| should['throw'] = should['Throw']; |
| should.not['throw'] = should.not['Throw']; |
| |
| return should; |
| }; |
| |
| chai.should = loadShould; |
| chai.Should = loadShould; |
| }; |