Last active
April 18, 2016 20:48
-
-
Save rosskevin/940d06e084f71fc75981196cd93c5fb4 to your computer and use it in GitHub Desktop.
This is the failed output of rollup for the statement `import {expect} from 'chai'` - bad options for global?
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
Rollup messages: | |
[15:45:47] Treating 'buffer' as external dependency | |
[15:45:48] No name was provided for external module 'buffer' in options.globals – guessing 'require$$0' | |
index.js | |
import {expect} from 'chai' | |
chai - chai@3.5.0 | |
rollup options: | |
let options = { | |
entry: 'test/index.js', | |
sourceMap: true, | |
format: 'iife', | |
plugins: [ | |
commonjs({ | |
include: 'node_modules/**', | |
extensions: [ | |
'.js' | |
] | |
}), | |
nodeResolve({ | |
jsnext: true, | |
main: true, | |
builtins: false, | |
browser: true, | |
extensions: [ | |
'.js', | |
'.json' | |
] | |
}), | |
babel({ | |
babelrc: false, | |
presets: [ | |
'es2015-rollup' | |
] | |
}), | |
], | |
dest: 'dist/picker-tests.js.iife.js', | |
moduleName: 'pickerTests' | |
} | |
*/ | |
(function (require$$0) { | |
'use strict'; | |
require$$0 = 'default' in require$$0 ? require$$0['default'] : require$$0; | |
var __commonjs_global = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : this; | |
function __commonjs(fn, module) { return module = { exports: {} }, fn(module, module.exports, __commonjs_global), module.exports; } | |
var babelHelpers = {}; | |
babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { | |
return typeof obj; | |
} : function (obj) { | |
return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; | |
}; | |
babelHelpers.classCallCheck = function (instance, Constructor) { | |
if (!(instance instanceof Constructor)) { | |
throw new TypeError("Cannot call a class as a function"); | |
} | |
}; | |
babelHelpers.createClass = function () { | |
function defineProperties(target, props) { | |
for (var i = 0; i < props.length; i++) { | |
var descriptor = props[i]; | |
descriptor.enumerable = descriptor.enumerable || false; | |
descriptor.configurable = true; | |
if ("value" in descriptor) descriptor.writable = true; | |
Object.defineProperty(target, descriptor.key, descriptor); | |
} | |
} | |
return function (Constructor, protoProps, staticProps) { | |
if (protoProps) defineProperties(Constructor.prototype, protoProps); | |
if (staticProps) defineProperties(Constructor, staticProps); | |
return Constructor; | |
}; | |
}(); | |
babelHelpers.get = function get(object, property, receiver) { | |
if (object === null) object = Function.prototype; | |
var desc = Object.getOwnPropertyDescriptor(object, property); | |
if (desc === undefined) { | |
var parent = Object.getPrototypeOf(object); | |
if (parent === null) { | |
return undefined; | |
} else { | |
return get(parent, property, receiver); | |
} | |
} else if ("value" in desc) { | |
return desc.value; | |
} else { | |
var getter = desc.get; | |
if (getter === undefined) { | |
return undefined; | |
} | |
return getter.call(receiver); | |
} | |
}; | |
babelHelpers.inherits = function (subClass, superClass) { | |
if (typeof superClass !== "function" && superClass !== null) { | |
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); | |
} | |
subClass.prototype = Object.create(superClass && superClass.prototype, { | |
constructor: { | |
value: subClass, | |
enumerable: false, | |
writable: true, | |
configurable: true | |
} | |
}); | |
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; | |
}; | |
babelHelpers.possibleConstructorReturn = function (self, call) { | |
if (!self) { | |
throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); | |
} | |
return call && (typeof call === "object" || typeof call === "function") ? call : self; | |
}; | |
babelHelpers.toConsumableArray = function (arr) { | |
if (Array.isArray(arr)) { | |
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; | |
return arr2; | |
} else { | |
return Array.from(arr); | |
} | |
}; | |
babelHelpers; | |
var assert = __commonjs(function (module) { | |
/*! | |
* chai | |
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
module.exports = function (chai, util) { | |
/*! | |
* Chai dependencies. | |
*/ | |
var Assertion = chai.Assertion, | |
flag = util.flag; | |
/*! | |
* Module export. | |
*/ | |
/** | |
* ### assert(expression, message) | |
* | |
* Write your own test expressions. | |
* | |
* assert('foo' !== 'bar', 'foo is not bar'); | |
* assert(Array.isArray([]), 'empty arrays are arrays'); | |
* | |
* @param {Mixed} expression to test for truthiness | |
* @param {String} message to display on error | |
* @name assert | |
* @namespace Assert | |
* @api public | |
*/ | |
var assert = chai.assert = function (express, errmsg) { | |
var test = new Assertion(null, null, chai.assert); | |
test.assert(express, errmsg, '[ negation message unavailable ]'); | |
}; | |
/** | |
* ### .fail(actual, expected, [message], [operator]) | |
* | |
* Throw a failure. Node.js `assert` module-compatible. | |
* | |
* @name fail | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @param {String} operator | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.fail = function (actual, expected, message, operator) { | |
message = message || 'assert.fail()'; | |
throw new chai.AssertionError(message, { | |
actual: actual, | |
expected: expected, | |
operator: operator | |
}, assert.fail); | |
}; | |
/** | |
* ### .isOk(object, [message]) | |
* | |
* Asserts that `object` is truthy. | |
* | |
* assert.isOk('everything', 'everything is ok'); | |
* assert.isOk(false, 'this will fail'); | |
* | |
* @name isOk | |
* @alias ok | |
* @param {Mixed} object to test | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isOk = function (val, msg) { | |
new Assertion(val, msg).is.ok; | |
}; | |
/** | |
* ### .isNotOk(object, [message]) | |
* | |
* Asserts that `object` is falsy. | |
* | |
* assert.isNotOk('everything', 'this will fail'); | |
* assert.isNotOk(false, 'this will pass'); | |
* | |
* @name isNotOk | |
* @alias notOk | |
* @param {Mixed} object to test | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotOk = function (val, msg) { | |
new Assertion(val, msg).is.not.ok; | |
}; | |
/** | |
* ### .equal(actual, expected, [message]) | |
* | |
* Asserts non-strict equality (`==`) of `actual` and `expected`. | |
* | |
* assert.equal(3, '3', '== coerces values to strings'); | |
* | |
* @name equal | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.equal = function (act, exp, msg) { | |
var test = new Assertion(act, msg, assert.equal); | |
test.assert(exp == flag(test, 'object'), 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{act}', exp, act); | |
}; | |
/** | |
* ### .notEqual(actual, expected, [message]) | |
* | |
* Asserts non-strict inequality (`!=`) of `actual` and `expected`. | |
* | |
* assert.notEqual(3, 4, 'these numbers are not equal'); | |
* | |
* @name notEqual | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notEqual = function (act, exp, msg) { | |
var test = new Assertion(act, msg, assert.notEqual); | |
test.assert(exp != flag(test, 'object'), 'expected #{this} to not equal #{exp}', 'expected #{this} to equal #{act}', exp, act); | |
}; | |
/** | |
* ### .strictEqual(actual, expected, [message]) | |
* | |
* Asserts strict equality (`===`) of `actual` and `expected`. | |
* | |
* assert.strictEqual(true, true, 'these booleans are strictly equal'); | |
* | |
* @name strictEqual | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.strictEqual = function (act, exp, msg) { | |
new Assertion(act, msg).to.equal(exp); | |
}; | |
/** | |
* ### .notStrictEqual(actual, expected, [message]) | |
* | |
* Asserts strict inequality (`!==`) of `actual` and `expected`. | |
* | |
* assert.notStrictEqual(3, '3', 'no coercion for strict equality'); | |
* | |
* @name notStrictEqual | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notStrictEqual = function (act, exp, msg) { | |
new Assertion(act, msg).to.not.equal(exp); | |
}; | |
/** | |
* ### .deepEqual(actual, expected, [message]) | |
* | |
* Asserts that `actual` is deeply equal to `expected`. | |
* | |
* assert.deepEqual({ tea: 'green' }, { tea: 'green' }); | |
* | |
* @name deepEqual | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.deepEqual = function (act, exp, msg) { | |
new Assertion(act, msg).to.eql(exp); | |
}; | |
/** | |
* ### .notDeepEqual(actual, expected, [message]) | |
* | |
* Assert that `actual` is not deeply equal to `expected`. | |
* | |
* assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' }); | |
* | |
* @name notDeepEqual | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notDeepEqual = function (act, exp, msg) { | |
new Assertion(act, msg).to.not.eql(exp); | |
}; | |
/** | |
* ### .isAbove(valueToCheck, valueToBeAbove, [message]) | |
* | |
* Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove` | |
* | |
* assert.isAbove(5, 2, '5 is strictly greater than 2'); | |
* | |
* @name isAbove | |
* @param {Mixed} valueToCheck | |
* @param {Mixed} valueToBeAbove | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isAbove = function (val, abv, msg) { | |
new Assertion(val, msg).to.be.above(abv); | |
}; | |
/** | |
* ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message]) | |
* | |
* Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast` | |
* | |
* assert.isAtLeast(5, 2, '5 is greater or equal to 2'); | |
* assert.isAtLeast(3, 3, '3 is greater or equal to 3'); | |
* | |
* @name isAtLeast | |
* @param {Mixed} valueToCheck | |
* @param {Mixed} valueToBeAtLeast | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isAtLeast = function (val, atlst, msg) { | |
new Assertion(val, msg).to.be.least(atlst); | |
}; | |
/** | |
* ### .isBelow(valueToCheck, valueToBeBelow, [message]) | |
* | |
* Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow` | |
* | |
* assert.isBelow(3, 6, '3 is strictly less than 6'); | |
* | |
* @name isBelow | |
* @param {Mixed} valueToCheck | |
* @param {Mixed} valueToBeBelow | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isBelow = function (val, blw, msg) { | |
new Assertion(val, msg).to.be.below(blw); | |
}; | |
/** | |
* ### .isAtMost(valueToCheck, valueToBeAtMost, [message]) | |
* | |
* Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost` | |
* | |
* assert.isAtMost(3, 6, '3 is less than or equal to 6'); | |
* assert.isAtMost(4, 4, '4 is less than or equal to 4'); | |
* | |
* @name isAtMost | |
* @param {Mixed} valueToCheck | |
* @param {Mixed} valueToBeAtMost | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isAtMost = function (val, atmst, msg) { | |
new Assertion(val, msg).to.be.most(atmst); | |
}; | |
/** | |
* ### .isTrue(value, [message]) | |
* | |
* Asserts that `value` is true. | |
* | |
* var teaServed = true; | |
* assert.isTrue(teaServed, 'the tea has been served'); | |
* | |
* @name isTrue | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isTrue = function (val, msg) { | |
new Assertion(val, msg).is['true']; | |
}; | |
/** | |
* ### .isNotTrue(value, [message]) | |
* | |
* Asserts that `value` is not true. | |
* | |
* var tea = 'tasty chai'; | |
* assert.isNotTrue(tea, 'great, time for tea!'); | |
* | |
* @name isNotTrue | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotTrue = function (val, msg) { | |
new Assertion(val, msg).to.not.equal(true); | |
}; | |
/** | |
* ### .isFalse(value, [message]) | |
* | |
* Asserts that `value` is false. | |
* | |
* var teaServed = false; | |
* assert.isFalse(teaServed, 'no tea yet? hmm...'); | |
* | |
* @name isFalse | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isFalse = function (val, msg) { | |
new Assertion(val, msg).is['false']; | |
}; | |
/** | |
* ### .isNotFalse(value, [message]) | |
* | |
* Asserts that `value` is not false. | |
* | |
* var tea = 'tasty chai'; | |
* assert.isNotFalse(tea, 'great, time for tea!'); | |
* | |
* @name isNotFalse | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotFalse = function (val, msg) { | |
new Assertion(val, msg).to.not.equal(false); | |
}; | |
/** | |
* ### .isNull(value, [message]) | |
* | |
* Asserts that `value` is null. | |
* | |
* assert.isNull(err, 'there was no error'); | |
* | |
* @name isNull | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNull = function (val, msg) { | |
new Assertion(val, msg).to.equal(null); | |
}; | |
/** | |
* ### .isNotNull(value, [message]) | |
* | |
* Asserts that `value` is not null. | |
* | |
* var tea = 'tasty chai'; | |
* assert.isNotNull(tea, 'great, time for tea!'); | |
* | |
* @name isNotNull | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotNull = function (val, msg) { | |
new Assertion(val, msg).to.not.equal(null); | |
}; | |
/** | |
* ### .isNaN | |
* Asserts that value is NaN | |
* | |
* assert.isNaN('foo', 'foo is NaN'); | |
* | |
* @name isNaN | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNaN = function (val, msg) { | |
new Assertion(val, msg).to.be.NaN; | |
}; | |
/** | |
* ### .isNotNaN | |
* Asserts that value is not NaN | |
* | |
* assert.isNotNaN(4, '4 is not NaN'); | |
* | |
* @name isNotNaN | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotNaN = function (val, msg) { | |
new Assertion(val, msg).not.to.be.NaN; | |
}; | |
/** | |
* ### .isUndefined(value, [message]) | |
* | |
* Asserts that `value` is `undefined`. | |
* | |
* var tea; | |
* assert.isUndefined(tea, 'no tea defined'); | |
* | |
* @name isUndefined | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isUndefined = function (val, msg) { | |
new Assertion(val, msg).to.equal(undefined); | |
}; | |
/** | |
* ### .isDefined(value, [message]) | |
* | |
* Asserts that `value` is not `undefined`. | |
* | |
* var tea = 'cup of chai'; | |
* assert.isDefined(tea, 'tea has been defined'); | |
* | |
* @name isDefined | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isDefined = function (val, msg) { | |
new Assertion(val, msg).to.not.equal(undefined); | |
}; | |
/** | |
* ### .isFunction(value, [message]) | |
* | |
* Asserts that `value` is a function. | |
* | |
* function serveTea() { return 'cup of tea'; }; | |
* assert.isFunction(serveTea, 'great, we can have tea now'); | |
* | |
* @name isFunction | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isFunction = function (val, msg) { | |
new Assertion(val, msg).to.be.a('function'); | |
}; | |
/** | |
* ### .isNotFunction(value, [message]) | |
* | |
* Asserts that `value` is _not_ a function. | |
* | |
* var serveTea = [ 'heat', 'pour', 'sip' ]; | |
* assert.isNotFunction(serveTea, 'great, we have listed the steps'); | |
* | |
* @name isNotFunction | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotFunction = function (val, msg) { | |
new Assertion(val, msg).to.not.be.a('function'); | |
}; | |
/** | |
* ### .isObject(value, [message]) | |
* | |
* Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`). | |
* _The assertion does not match subclassed objects._ | |
* | |
* var selection = { name: 'Chai', serve: 'with spices' }; | |
* assert.isObject(selection, 'tea selection is an object'); | |
* | |
* @name isObject | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isObject = function (val, msg) { | |
new Assertion(val, msg).to.be.a('object'); | |
}; | |
/** | |
* ### .isNotObject(value, [message]) | |
* | |
* Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`). | |
* | |
* var selection = 'chai' | |
* assert.isNotObject(selection, 'tea selection is not an object'); | |
* assert.isNotObject(null, 'null is not an object'); | |
* | |
* @name isNotObject | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotObject = function (val, msg) { | |
new Assertion(val, msg).to.not.be.a('object'); | |
}; | |
/** | |
* ### .isArray(value, [message]) | |
* | |
* Asserts that `value` is an array. | |
* | |
* var menu = [ 'green', 'chai', 'oolong' ]; | |
* assert.isArray(menu, 'what kind of tea do we want?'); | |
* | |
* @name isArray | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isArray = function (val, msg) { | |
new Assertion(val, msg).to.be.an('array'); | |
}; | |
/** | |
* ### .isNotArray(value, [message]) | |
* | |
* Asserts that `value` is _not_ an array. | |
* | |
* var menu = 'green|chai|oolong'; | |
* assert.isNotArray(menu, 'what kind of tea do we want?'); | |
* | |
* @name isNotArray | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotArray = function (val, msg) { | |
new Assertion(val, msg).to.not.be.an('array'); | |
}; | |
/** | |
* ### .isString(value, [message]) | |
* | |
* Asserts that `value` is a string. | |
* | |
* var teaOrder = 'chai'; | |
* assert.isString(teaOrder, 'order placed'); | |
* | |
* @name isString | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isString = function (val, msg) { | |
new Assertion(val, msg).to.be.a('string'); | |
}; | |
/** | |
* ### .isNotString(value, [message]) | |
* | |
* Asserts that `value` is _not_ a string. | |
* | |
* var teaOrder = 4; | |
* assert.isNotString(teaOrder, 'order placed'); | |
* | |
* @name isNotString | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotString = function (val, msg) { | |
new Assertion(val, msg).to.not.be.a('string'); | |
}; | |
/** | |
* ### .isNumber(value, [message]) | |
* | |
* Asserts that `value` is a number. | |
* | |
* var cups = 2; | |
* assert.isNumber(cups, 'how many cups'); | |
* | |
* @name isNumber | |
* @param {Number} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNumber = function (val, msg) { | |
new Assertion(val, msg).to.be.a('number'); | |
}; | |
/** | |
* ### .isNotNumber(value, [message]) | |
* | |
* Asserts that `value` is _not_ a number. | |
* | |
* var cups = '2 cups please'; | |
* assert.isNotNumber(cups, 'how many cups'); | |
* | |
* @name isNotNumber | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotNumber = function (val, msg) { | |
new Assertion(val, msg).to.not.be.a('number'); | |
}; | |
/** | |
* ### .isBoolean(value, [message]) | |
* | |
* Asserts that `value` is a boolean. | |
* | |
* var teaReady = true | |
* , teaServed = false; | |
* | |
* assert.isBoolean(teaReady, 'is the tea ready'); | |
* assert.isBoolean(teaServed, 'has tea been served'); | |
* | |
* @name isBoolean | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isBoolean = function (val, msg) { | |
new Assertion(val, msg).to.be.a('boolean'); | |
}; | |
/** | |
* ### .isNotBoolean(value, [message]) | |
* | |
* Asserts that `value` is _not_ a boolean. | |
* | |
* var teaReady = 'yep' | |
* , teaServed = 'nope'; | |
* | |
* assert.isNotBoolean(teaReady, 'is the tea ready'); | |
* assert.isNotBoolean(teaServed, 'has tea been served'); | |
* | |
* @name isNotBoolean | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotBoolean = function (val, msg) { | |
new Assertion(val, msg).to.not.be.a('boolean'); | |
}; | |
/** | |
* ### .typeOf(value, name, [message]) | |
* | |
* Asserts that `value`'s type is `name`, as determined by | |
* `Object.prototype.toString`. | |
* | |
* assert.typeOf({ tea: 'chai' }, 'object', 'we have an object'); | |
* assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array'); | |
* assert.typeOf('tea', 'string', 'we have a string'); | |
* assert.typeOf(/tea/, 'regexp', 'we have a regular expression'); | |
* assert.typeOf(null, 'null', 'we have a null'); | |
* assert.typeOf(undefined, 'undefined', 'we have an undefined'); | |
* | |
* @name typeOf | |
* @param {Mixed} value | |
* @param {String} name | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.typeOf = function (val, type, msg) { | |
new Assertion(val, msg).to.be.a(type); | |
}; | |
/** | |
* ### .notTypeOf(value, name, [message]) | |
* | |
* Asserts that `value`'s type is _not_ `name`, as determined by | |
* `Object.prototype.toString`. | |
* | |
* assert.notTypeOf('tea', 'number', 'strings are not numbers'); | |
* | |
* @name notTypeOf | |
* @param {Mixed} value | |
* @param {String} typeof name | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notTypeOf = function (val, type, msg) { | |
new Assertion(val, msg).to.not.be.a(type); | |
}; | |
/** | |
* ### .instanceOf(object, constructor, [message]) | |
* | |
* Asserts that `value` is an instance of `constructor`. | |
* | |
* var Tea = function (name) { this.name = name; } | |
* , chai = new Tea('chai'); | |
* | |
* assert.instanceOf(chai, Tea, 'chai is an instance of tea'); | |
* | |
* @name instanceOf | |
* @param {Object} object | |
* @param {Constructor} constructor | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.instanceOf = function (val, type, msg) { | |
new Assertion(val, msg).to.be.instanceOf(type); | |
}; | |
/** | |
* ### .notInstanceOf(object, constructor, [message]) | |
* | |
* Asserts `value` is not an instance of `constructor`. | |
* | |
* var Tea = function (name) { this.name = name; } | |
* , chai = new String('chai'); | |
* | |
* assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea'); | |
* | |
* @name notInstanceOf | |
* @param {Object} object | |
* @param {Constructor} constructor | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notInstanceOf = function (val, type, msg) { | |
new Assertion(val, msg).to.not.be.instanceOf(type); | |
}; | |
/** | |
* ### .include(haystack, needle, [message]) | |
* | |
* Asserts that `haystack` includes `needle`. Works | |
* for strings and arrays. | |
* | |
* assert.include('foobar', 'bar', 'foobar contains string "bar"'); | |
* assert.include([ 1, 2, 3 ], 3, 'array contains value'); | |
* | |
* @name include | |
* @param {Array|String} haystack | |
* @param {Mixed} needle | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.include = function (exp, inc, msg) { | |
new Assertion(exp, msg, assert.include).include(inc); | |
}; | |
/** | |
* ### .notInclude(haystack, needle, [message]) | |
* | |
* Asserts that `haystack` does not include `needle`. Works | |
* for strings and arrays. | |
* | |
* assert.notInclude('foobar', 'baz', 'string not include substring'); | |
* assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value'); | |
* | |
* @name notInclude | |
* @param {Array|String} haystack | |
* @param {Mixed} needle | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notInclude = function (exp, inc, msg) { | |
new Assertion(exp, msg, assert.notInclude).not.include(inc); | |
}; | |
/** | |
* ### .match(value, regexp, [message]) | |
* | |
* Asserts that `value` matches the regular expression `regexp`. | |
* | |
* assert.match('foobar', /^foo/, 'regexp matches'); | |
* | |
* @name match | |
* @param {Mixed} value | |
* @param {RegExp} regexp | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.match = function (exp, re, msg) { | |
new Assertion(exp, msg).to.match(re); | |
}; | |
/** | |
* ### .notMatch(value, regexp, [message]) | |
* | |
* Asserts that `value` does not match the regular expression `regexp`. | |
* | |
* assert.notMatch('foobar', /^foo/, 'regexp does not match'); | |
* | |
* @name notMatch | |
* @param {Mixed} value | |
* @param {RegExp} regexp | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notMatch = function (exp, re, msg) { | |
new Assertion(exp, msg).to.not.match(re); | |
}; | |
/** | |
* ### .property(object, property, [message]) | |
* | |
* Asserts that `object` has a property named by `property`. | |
* | |
* assert.property({ tea: { green: 'matcha' }}, 'tea'); | |
* | |
* @name property | |
* @param {Object} object | |
* @param {String} property | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.property = function (obj, prop, msg) { | |
new Assertion(obj, msg).to.have.property(prop); | |
}; | |
/** | |
* ### .notProperty(object, property, [message]) | |
* | |
* Asserts that `object` does _not_ have a property named by `property`. | |
* | |
* assert.notProperty({ tea: { green: 'matcha' }}, 'coffee'); | |
* | |
* @name notProperty | |
* @param {Object} object | |
* @param {String} property | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notProperty = function (obj, prop, msg) { | |
new Assertion(obj, msg).to.not.have.property(prop); | |
}; | |
/** | |
* ### .deepProperty(object, property, [message]) | |
* | |
* Asserts that `object` has a property named by `property`, which can be a | |
* string using dot- and bracket-notation for deep reference. | |
* | |
* assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green'); | |
* | |
* @name deepProperty | |
* @param {Object} object | |
* @param {String} property | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.deepProperty = function (obj, prop, msg) { | |
new Assertion(obj, msg).to.have.deep.property(prop); | |
}; | |
/** | |
* ### .notDeepProperty(object, property, [message]) | |
* | |
* Asserts that `object` does _not_ have a property named by `property`, which | |
* can be a string using dot- and bracket-notation for deep reference. | |
* | |
* assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong'); | |
* | |
* @name notDeepProperty | |
* @param {Object} object | |
* @param {String} property | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.notDeepProperty = function (obj, prop, msg) { | |
new Assertion(obj, msg).to.not.have.deep.property(prop); | |
}; | |
/** | |
* ### .propertyVal(object, property, value, [message]) | |
* | |
* Asserts that `object` has a property named by `property` with value given | |
* by `value`. | |
* | |
* assert.propertyVal({ tea: 'is good' }, 'tea', 'is good'); | |
* | |
* @name propertyVal | |
* @param {Object} object | |
* @param {String} property | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.propertyVal = function (obj, prop, val, msg) { | |
new Assertion(obj, msg).to.have.property(prop, val); | |
}; | |
/** | |
* ### .propertyNotVal(object, property, value, [message]) | |
* | |
* Asserts that `object` has a property named by `property`, but with a value | |
* different from that given by `value`. | |
* | |
* assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad'); | |
* | |
* @name propertyNotVal | |
* @param {Object} object | |
* @param {String} property | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.propertyNotVal = function (obj, prop, val, msg) { | |
new Assertion(obj, msg).to.not.have.property(prop, val); | |
}; | |
/** | |
* ### .deepPropertyVal(object, property, value, [message]) | |
* | |
* Asserts that `object` has a property named by `property` with value given | |
* by `value`. `property` can use dot- and bracket-notation for deep | |
* reference. | |
* | |
* assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha'); | |
* | |
* @name deepPropertyVal | |
* @param {Object} object | |
* @param {String} property | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.deepPropertyVal = function (obj, prop, val, msg) { | |
new Assertion(obj, msg).to.have.deep.property(prop, val); | |
}; | |
/** | |
* ### .deepPropertyNotVal(object, property, value, [message]) | |
* | |
* Asserts that `object` has a property named by `property`, but with a value | |
* different from that given by `value`. `property` can use dot- and | |
* bracket-notation for deep reference. | |
* | |
* assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha'); | |
* | |
* @name deepPropertyNotVal | |
* @param {Object} object | |
* @param {String} property | |
* @param {Mixed} value | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.deepPropertyNotVal = function (obj, prop, val, msg) { | |
new Assertion(obj, msg).to.not.have.deep.property(prop, val); | |
}; | |
/** | |
* ### .lengthOf(object, length, [message]) | |
* | |
* Asserts that `object` has a `length` property with the expected value. | |
* | |
* assert.lengthOf([1,2,3], 3, 'array has length of 3'); | |
* assert.lengthOf('foobar', 6, 'string has length of 6'); | |
* | |
* @name lengthOf | |
* @param {Mixed} object | |
* @param {Number} length | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.lengthOf = function (exp, len, msg) { | |
new Assertion(exp, msg).to.have.length(len); | |
}; | |
/** | |
* ### .throws(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`. | |
* | |
* assert.throws(fn, 'function throws a reference error'); | |
* assert.throws(fn, /function throws a reference error/); | |
* assert.throws(fn, ReferenceError); | |
* assert.throws(fn, ReferenceError, 'function throws a reference error'); | |
* assert.throws(fn, ReferenceError, /function throws a reference error/); | |
* | |
* @name throws | |
* @alias 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 Assert | |
* @api public | |
*/ | |
assert.throws = function (fn, errt, errs, msg) { | |
if ('string' === typeof errt || errt instanceof RegExp) { | |
errs = errt; | |
errt = null; | |
} | |
var assertErr = new Assertion(fn, msg).to.throw(errt, errs); | |
return flag(assertErr, 'object'); | |
}; | |
/** | |
* ### .doesNotThrow(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`. | |
* | |
* assert.doesNotThrow(fn, Error, 'function does not throw'); | |
* | |
* @name doesNotThrow | |
* @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 Assert | |
* @api public | |
*/ | |
assert.doesNotThrow = function (fn, type, msg) { | |
if ('string' === typeof type) { | |
msg = type; | |
type = null; | |
} | |
new Assertion(fn, msg).to.not.Throw(type); | |
}; | |
/** | |
* ### .operator(val1, operator, val2, [message]) | |
* | |
* Compares two values using `operator`. | |
* | |
* assert.operator(1, '<', 2, 'everything is ok'); | |
* assert.operator(1, '>', 2, 'this will fail'); | |
* | |
* @name operator | |
* @param {Mixed} val1 | |
* @param {String} operator | |
* @param {Mixed} val2 | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.operator = function (val, operator, val2, msg) { | |
var ok; | |
switch (operator) { | |
case '==': | |
ok = val == val2; | |
break; | |
case '===': | |
ok = val === val2; | |
break; | |
case '>': | |
ok = val > val2; | |
break; | |
case '>=': | |
ok = val >= val2; | |
break; | |
case '<': | |
ok = val < val2; | |
break; | |
case '<=': | |
ok = val <= val2; | |
break; | |
case '!=': | |
ok = val != val2; | |
break; | |
case '!==': | |
ok = val !== val2; | |
break; | |
default: | |
throw new Error('Invalid operator "' + operator + '"'); | |
} | |
var test = new Assertion(ok, msg); | |
test.assert(true === flag(test, 'object'), 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2), 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2)); | |
}; | |
/** | |
* ### .closeTo(actual, expected, delta, [message]) | |
* | |
* Asserts that the target is equal `expected`, to within a +/- `delta` range. | |
* | |
* assert.closeTo(1.5, 1, 0.5, 'numbers are close'); | |
* | |
* @name closeTo | |
* @param {Number} actual | |
* @param {Number} expected | |
* @param {Number} delta | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.closeTo = function (act, exp, delta, msg) { | |
new Assertion(act, msg).to.be.closeTo(exp, delta); | |
}; | |
/** | |
* ### .approximately(actual, expected, delta, [message]) | |
* | |
* Asserts that the target is equal `expected`, to within a +/- `delta` range. | |
* | |
* assert.approximately(1.5, 1, 0.5, 'numbers are close'); | |
* | |
* @name approximately | |
* @param {Number} actual | |
* @param {Number} expected | |
* @param {Number} delta | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.approximately = function (act, exp, delta, msg) { | |
new Assertion(act, msg).to.be.approximately(exp, delta); | |
}; | |
/** | |
* ### .sameMembers(set1, set2, [message]) | |
* | |
* Asserts that `set1` and `set2` have the same members. | |
* Order is not taken into account. | |
* | |
* assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members'); | |
* | |
* @name sameMembers | |
* @param {Array} set1 | |
* @param {Array} set2 | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.sameMembers = function (set1, set2, msg) { | |
new Assertion(set1, msg).to.have.same.members(set2); | |
}; | |
/** | |
* ### .sameDeepMembers(set1, set2, [message]) | |
* | |
* Asserts that `set1` and `set2` have the same members - using a deep equality checking. | |
* Order is not taken into account. | |
* | |
* assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members'); | |
* | |
* @name sameDeepMembers | |
* @param {Array} set1 | |
* @param {Array} set2 | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.sameDeepMembers = function (set1, set2, msg) { | |
new Assertion(set1, msg).to.have.same.deep.members(set2); | |
}; | |
/** | |
* ### .includeMembers(superset, subset, [message]) | |
* | |
* Asserts that `subset` is included in `superset`. | |
* Order is not taken into account. | |
* | |
* assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members'); | |
* | |
* @name includeMembers | |
* @param {Array} superset | |
* @param {Array} subset | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.includeMembers = function (superset, subset, msg) { | |
new Assertion(superset, msg).to.include.members(subset); | |
}; | |
/** | |
* ### .includeDeepMembers(superset, subset, [message]) | |
* | |
* Asserts that `subset` is included in `superset` - using deep equality checking. | |
* Order is not taken into account. | |
* Duplicates are ignored. | |
* | |
* assert.includeDeepMembers([ {a: 1}, {b: 2}, {c: 3} ], [ {b: 2}, {a: 1}, {b: 2} ], 'include deep members'); | |
* | |
* @name includeDeepMembers | |
* @param {Array} superset | |
* @param {Array} subset | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.includeDeepMembers = function (superset, subset, msg) { | |
new Assertion(superset, msg).to.include.deep.members(subset); | |
}; | |
/** | |
* ### .oneOf(inList, list, [message]) | |
* | |
* Asserts that non-object, non-array value `inList` appears in the flat array `list`. | |
* | |
* assert.oneOf(1, [ 2, 1 ], 'Not found in list'); | |
* | |
* @name oneOf | |
* @param {*} inList | |
* @param {Array<*>} list | |
* @param {String} message | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.oneOf = function (inList, list, msg) { | |
new Assertion(inList, msg).to.be.oneOf(list); | |
}; | |
/** | |
* ### .changes(function, object, property) | |
* | |
* Asserts that a function changes the value of a property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 22 }; | |
* assert.changes(fn, obj, 'val'); | |
* | |
* @name changes | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.changes = function (fn, obj, prop) { | |
new Assertion(fn).to.change(obj, prop); | |
}; | |
/** | |
* ### .doesNotChange(function, object, property) | |
* | |
* Asserts that a function does not changes the value of a property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { console.log('foo'); }; | |
* assert.doesNotChange(fn, obj, 'val'); | |
* | |
* @name doesNotChange | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.doesNotChange = function (fn, obj, prop) { | |
new Assertion(fn).to.not.change(obj, prop); | |
}; | |
/** | |
* ### .increases(function, object, property) | |
* | |
* Asserts that a function increases an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 13 }; | |
* assert.increases(fn, obj, 'val'); | |
* | |
* @name increases | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.increases = function (fn, obj, prop) { | |
new Assertion(fn).to.increase(obj, prop); | |
}; | |
/** | |
* ### .doesNotIncrease(function, object, property) | |
* | |
* Asserts that a function does not increase object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 8 }; | |
* assert.doesNotIncrease(fn, obj, 'val'); | |
* | |
* @name doesNotIncrease | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.doesNotIncrease = function (fn, obj, prop) { | |
new Assertion(fn).to.not.increase(obj, prop); | |
}; | |
/** | |
* ### .decreases(function, object, property) | |
* | |
* Asserts that a function decreases an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 5 }; | |
* assert.decreases(fn, obj, 'val'); | |
* | |
* @name decreases | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.decreases = function (fn, obj, prop) { | |
new Assertion(fn).to.decrease(obj, prop); | |
}; | |
/** | |
* ### .doesNotDecrease(function, object, property) | |
* | |
* Asserts that a function does not decreases an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 15 }; | |
* assert.doesNotDecrease(fn, obj, 'val'); | |
* | |
* @name doesNotDecrease | |
* @param {Function} modifier function | |
* @param {Object} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.doesNotDecrease = function (fn, obj, prop) { | |
new Assertion(fn).to.not.decrease(obj, prop); | |
}; | |
/*! | |
* ### .ifError(object) | |
* | |
* Asserts if value is not a false value, and throws if it is a true value. | |
* This is added to allow for chai to be a drop-in replacement for Node's | |
* assert class. | |
* | |
* var err = new Error('I am a custom error'); | |
* assert.ifError(err); // Rethrows err! | |
* | |
* @name ifError | |
* @param {Object} object | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.ifError = function (val) { | |
if (val) { | |
throw val; | |
} | |
}; | |
/** | |
* ### .isExtensible(object) | |
* | |
* Asserts that `object` is extensible (can have new properties added to it). | |
* | |
* assert.isExtensible({}); | |
* | |
* @name isExtensible | |
* @alias extensible | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isExtensible = function (obj, msg) { | |
new Assertion(obj, msg).to.be.extensible; | |
}; | |
/** | |
* ### .isNotExtensible(object) | |
* | |
* Asserts that `object` is _not_ extensible. | |
* | |
* var nonExtensibleObject = Object.preventExtensions({}); | |
* var sealedObject = Object.seal({}); | |
* var frozenObject = Object.freese({}); | |
* | |
* assert.isNotExtensible(nonExtensibleObject); | |
* assert.isNotExtensible(sealedObject); | |
* assert.isNotExtensible(frozenObject); | |
* | |
* @name isNotExtensible | |
* @alias notExtensible | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotExtensible = function (obj, msg) { | |
new Assertion(obj, msg).to.not.be.extensible; | |
}; | |
/** | |
* ### .isSealed(object) | |
* | |
* Asserts that `object` is sealed (cannot have new properties added to it | |
* and its existing properties cannot be removed). | |
* | |
* var sealedObject = Object.seal({}); | |
* var frozenObject = Object.seal({}); | |
* | |
* assert.isSealed(sealedObject); | |
* assert.isSealed(frozenObject); | |
* | |
* @name isSealed | |
* @alias sealed | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isSealed = function (obj, msg) { | |
new Assertion(obj, msg).to.be.sealed; | |
}; | |
/** | |
* ### .isNotSealed(object) | |
* | |
* Asserts that `object` is _not_ sealed. | |
* | |
* assert.isNotSealed({}); | |
* | |
* @name isNotSealed | |
* @alias notSealed | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotSealed = function (obj, msg) { | |
new Assertion(obj, msg).to.not.be.sealed; | |
}; | |
/** | |
* ### .isFrozen(object) | |
* | |
* Asserts that `object` is frozen (cannot have new properties added to it | |
* and its existing properties cannot be modified). | |
* | |
* var frozenObject = Object.freeze({}); | |
* assert.frozen(frozenObject); | |
* | |
* @name isFrozen | |
* @alias frozen | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isFrozen = function (obj, msg) { | |
new Assertion(obj, msg).to.be.frozen; | |
}; | |
/** | |
* ### .isNotFrozen(object) | |
* | |
* Asserts that `object` is _not_ frozen. | |
* | |
* assert.isNotFrozen({}); | |
* | |
* @name isNotFrozen | |
* @alias notFrozen | |
* @param {Object} object | |
* @param {String} message _optional_ | |
* @namespace Assert | |
* @api public | |
*/ | |
assert.isNotFrozen = function (obj, msg) { | |
new Assertion(obj, msg).to.not.be.frozen; | |
}; | |
/*! | |
* Aliases. | |
*/ | |
(function alias(name, as) { | |
assert[as] = assert[name]; | |
return alias; | |
})('isOk', 'ok')('isNotOk', 'notOk')('throws', 'throw')('throws', 'Throw')('isExtensible', 'extensible')('isNotExtensible', 'notExtensible')('isSealed', 'sealed')('isNotSealed', 'notSealed')('isFrozen', 'frozen')('isNotFrozen', 'notFrozen'); | |
}; | |
}); | |
var require$$0$2 = assert && (typeof assert === 'undefined' ? 'undefined' : babelHelpers.typeof(assert)) === 'object' && 'default' in assert ? assert['default'] : assert; | |
var should = __commonjs(function (module) { | |
/*! | |
* 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) { | |
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(actual, expected, [message], [operator]) | |
* | |
* Throw a failure. | |
* | |
* @name fail | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @param {String} operator | |
* @namespace Should | |
* @api public | |
*/ | |
should.fail = function (actual, expected, message, operator) { | |
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; | |
}; | |
}); | |
var require$$1 = should && (typeof should === 'undefined' ? 'undefined' : babelHelpers.typeof(should)) === 'object' && 'default' in should ? should['default'] : should; | |
var expect = __commonjs(function (module) { | |
/*! | |
* chai | |
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
module.exports = function (chai, util) { | |
chai.expect = function (val, message) { | |
return new chai.Assertion(val, message); | |
}; | |
/** | |
* ### .fail(actual, expected, [message], [operator]) | |
* | |
* Throw a failure. | |
* | |
* @name fail | |
* @param {Mixed} actual | |
* @param {Mixed} expected | |
* @param {String} message | |
* @param {String} operator | |
* @namespace Expect | |
* @api public | |
*/ | |
chai.expect.fail = function (actual, expected, message, operator) { | |
message = message || 'expect.fail()'; | |
throw new chai.AssertionError(message, { | |
actual: actual, | |
expected: expected, | |
operator: operator | |
}, chai.expect.fail); | |
}; | |
}; | |
}); | |
var require$$2 = expect && (typeof expect === 'undefined' ? 'undefined' : babelHelpers.typeof(expect)) === 'object' && 'default' in expect ? expect['default'] : expect; | |
var assertions = __commonjs(function (module) { | |
/*! | |
* chai | |
* http://chaijs.com | |
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
module.exports = function (chai, _) { | |
var Assertion = chai.Assertion, | |
toString = Object.prototype.toString, | |
flag = _.flag; | |
/** | |
* ### Language Chains | |
* | |
* The following are provided as chainable getters to | |
* improve the readability of your assertions. They | |
* do not provide testing capabilities unless they | |
* have been overwritten by a plugin. | |
* | |
* **Chains** | |
* | |
* - to | |
* - be | |
* - been | |
* - is | |
* - that | |
* - which | |
* - and | |
* - has | |
* - have | |
* - with | |
* - at | |
* - of | |
* - same | |
* | |
* @name language chains | |
* @namespace BDD | |
* @api public | |
*/ | |
['to', 'be', 'been', 'is', 'and', 'has', 'have', 'with', 'that', 'which', 'at', 'of', 'same'].forEach(function (chain) { | |
Assertion.addProperty(chain, function () { | |
return this; | |
}); | |
}); | |
/** | |
* ### .not | |
* | |
* Negates any of assertions following in the chain. | |
* | |
* expect(foo).to.not.equal('bar'); | |
* expect(goodFn).to.not.throw(Error); | |
* expect({ foo: 'baz' }).to.have.property('foo') | |
* .and.not.equal('bar'); | |
* | |
* @name not | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('not', function () { | |
flag(this, 'negate', true); | |
}); | |
/** | |
* ### .deep | |
* | |
* Sets the `deep` flag, later used by the `equal` and | |
* `property` assertions. | |
* | |
* expect(foo).to.deep.equal({ bar: 'baz' }); | |
* expect({ foo: { bar: { baz: 'quux' } } }) | |
* .to.have.deep.property('foo.bar.baz', 'quux'); | |
* | |
* `.deep.property` special characters can be escaped | |
* by adding two slashes before the `.` or `[]`. | |
* | |
* var deepCss = { '.link': { '[target]': 42 }}; | |
* expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42); | |
* | |
* @name deep | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('deep', function () { | |
flag(this, 'deep', true); | |
}); | |
/** | |
* ### .any | |
* | |
* Sets the `any` flag, (opposite of the `all` flag) | |
* later used in the `keys` assertion. | |
* | |
* expect(foo).to.have.any.keys('bar', 'baz'); | |
* | |
* @name any | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('any', function () { | |
flag(this, 'any', true); | |
flag(this, 'all', false); | |
}); | |
/** | |
* ### .all | |
* | |
* Sets the `all` flag (opposite of the `any` flag) | |
* later used by the `keys` assertion. | |
* | |
* expect(foo).to.have.all.keys('bar', 'baz'); | |
* | |
* @name all | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('all', function () { | |
flag(this, 'all', true); | |
flag(this, 'any', false); | |
}); | |
/** | |
* ### .a(type) | |
* | |
* The `a` and `an` assertions are aliases that can be | |
* used either as language chains or to assert a value's | |
* type. | |
* | |
* // typeof | |
* expect('test').to.be.a('string'); | |
* expect({ foo: 'bar' }).to.be.an('object'); | |
* expect(null).to.be.a('null'); | |
* expect(undefined).to.be.an('undefined'); | |
* expect(new Error).to.be.an('error'); | |
* expect(new Promise).to.be.a('promise'); | |
* expect(new Float32Array()).to.be.a('float32array'); | |
* expect(Symbol()).to.be.a('symbol'); | |
* | |
* // es6 overrides | |
* expect({[Symbol.toStringTag]:()=>'foo'}).to.be.a('foo'); | |
* | |
* // language chain | |
* expect(foo).to.be.an.instanceof(Foo); | |
* | |
* @name a | |
* @alias an | |
* @param {String} type | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function an(type, msg) { | |
if (msg) flag(this, 'message', msg); | |
type = type.toLowerCase(); | |
var obj = flag(this, 'object'), | |
article = ~['a', 'e', 'i', 'o', 'u'].indexOf(type.charAt(0)) ? 'an ' : 'a '; | |
this.assert(type === _.type(obj), 'expected #{this} to be ' + article + type, 'expected #{this} not to be ' + article + type); | |
} | |
Assertion.addChainableMethod('an', an); | |
Assertion.addChainableMethod('a', an); | |
/** | |
* ### .include(value) | |
* | |
* The `include` and `contain` assertions can be used as either property | |
* based language chains or as methods to assert the inclusion of an object | |
* in an array or a substring in a string. When used as language chains, | |
* they toggle the `contains` flag for the `keys` assertion. | |
* | |
* expect([1,2,3]).to.include(2); | |
* expect('foobar').to.contain('foo'); | |
* expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo'); | |
* | |
* @name include | |
* @alias contain | |
* @alias includes | |
* @alias contains | |
* @param {Object|String|Number} obj | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function includeChainingBehavior() { | |
flag(this, 'contains', true); | |
} | |
function include(val, msg) { | |
_.expectTypes(this, ['array', 'object', 'string']); | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
var expected = false; | |
if (_.type(obj) === 'array' && _.type(val) === 'object') { | |
for (var i in obj) { | |
if (_.eql(obj[i], val)) { | |
expected = true; | |
break; | |
} | |
} | |
} else if (_.type(val) === 'object') { | |
if (!flag(this, 'negate')) { | |
for (var k in val) { | |
new Assertion(obj).property(k, val[k]); | |
}return; | |
} | |
var subset = {}; | |
for (var k in val) { | |
subset[k] = obj[k]; | |
}expected = _.eql(subset, val); | |
} else { | |
expected = obj != undefined && ~obj.indexOf(val); | |
} | |
this.assert(expected, 'expected #{this} to include ' + _.inspect(val), 'expected #{this} to not include ' + _.inspect(val)); | |
} | |
Assertion.addChainableMethod('include', include, includeChainingBehavior); | |
Assertion.addChainableMethod('contain', include, includeChainingBehavior); | |
Assertion.addChainableMethod('contains', include, includeChainingBehavior); | |
Assertion.addChainableMethod('includes', include, includeChainingBehavior); | |
/** | |
* ### .ok | |
* | |
* Asserts that the target is truthy. | |
* | |
* expect('everything').to.be.ok; | |
* expect(1).to.be.ok; | |
* expect(false).to.not.be.ok; | |
* expect(undefined).to.not.be.ok; | |
* expect(null).to.not.be.ok; | |
* | |
* @name ok | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('ok', function () { | |
this.assert(flag(this, 'object'), 'expected #{this} to be truthy', 'expected #{this} to be falsy'); | |
}); | |
/** | |
* ### .true | |
* | |
* Asserts that the target is `true`. | |
* | |
* expect(true).to.be.true; | |
* expect(1).to.not.be.true; | |
* | |
* @name true | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('true', function () { | |
this.assert(true === flag(this, 'object'), 'expected #{this} to be true', 'expected #{this} to be false', this.negate ? false : true); | |
}); | |
/** | |
* ### .false | |
* | |
* Asserts that the target is `false`. | |
* | |
* expect(false).to.be.false; | |
* expect(0).to.not.be.false; | |
* | |
* @name false | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('false', function () { | |
this.assert(false === flag(this, 'object'), 'expected #{this} to be false', 'expected #{this} to be true', this.negate ? true : false); | |
}); | |
/** | |
* ### .null | |
* | |
* Asserts that the target is `null`. | |
* | |
* expect(null).to.be.null; | |
* expect(undefined).to.not.be.null; | |
* | |
* @name null | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('null', function () { | |
this.assert(null === flag(this, 'object'), 'expected #{this} to be null', 'expected #{this} not to be null'); | |
}); | |
/** | |
* ### .undefined | |
* | |
* Asserts that the target is `undefined`. | |
* | |
* expect(undefined).to.be.undefined; | |
* expect(null).to.not.be.undefined; | |
* | |
* @name undefined | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('undefined', function () { | |
this.assert(undefined === flag(this, 'object'), 'expected #{this} to be undefined', 'expected #{this} not to be undefined'); | |
}); | |
/** | |
* ### .NaN | |
* Asserts that the target is `NaN`. | |
* | |
* expect('foo').to.be.NaN; | |
* expect(4).not.to.be.NaN; | |
* | |
* @name NaN | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('NaN', function () { | |
this.assert(isNaN(flag(this, 'object')), 'expected #{this} to be NaN', 'expected #{this} not to be NaN'); | |
}); | |
/** | |
* ### .exist | |
* | |
* Asserts that the target is neither `null` nor `undefined`. | |
* | |
* var foo = 'hi' | |
* , bar = null | |
* , baz; | |
* | |
* expect(foo).to.exist; | |
* expect(bar).to.not.exist; | |
* expect(baz).to.not.exist; | |
* | |
* @name exist | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('exist', function () { | |
this.assert(null != flag(this, 'object'), 'expected #{this} to exist', 'expected #{this} to not exist'); | |
}); | |
/** | |
* ### .empty | |
* | |
* Asserts that the target's length is `0`. For arrays and strings, it checks | |
* the `length` property. For objects, it gets the count of | |
* enumerable keys. | |
* | |
* expect([]).to.be.empty; | |
* expect('').to.be.empty; | |
* expect({}).to.be.empty; | |
* | |
* @name empty | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('empty', function () { | |
var obj = flag(this, 'object'), | |
expected = obj; | |
if (Array.isArray(obj) || 'string' === typeof object) { | |
expected = obj.length; | |
} else if ((typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) === 'object') { | |
expected = Object.keys(obj).length; | |
} | |
this.assert(!expected, 'expected #{this} to be empty', 'expected #{this} not to be empty'); | |
}); | |
/** | |
* ### .arguments | |
* | |
* Asserts that the target is an arguments object. | |
* | |
* function test () { | |
* expect(arguments).to.be.arguments; | |
* } | |
* | |
* @name arguments | |
* @alias Arguments | |
* @namespace BDD | |
* @api public | |
*/ | |
function checkArguments() { | |
var obj = flag(this, 'object'), | |
type = Object.prototype.toString.call(obj); | |
this.assert('[object Arguments]' === type, 'expected #{this} to be arguments but got ' + type, 'expected #{this} to not be arguments'); | |
} | |
Assertion.addProperty('arguments', checkArguments); | |
Assertion.addProperty('Arguments', checkArguments); | |
/** | |
* ### .equal(value) | |
* | |
* Asserts that the target is strictly equal (`===`) to `value`. | |
* Alternately, if the `deep` flag is set, asserts that | |
* the target is deeply equal to `value`. | |
* | |
* expect('hello').to.equal('hello'); | |
* expect(42).to.equal(42); | |
* expect(1).to.not.equal(true); | |
* expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' }); | |
* expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' }); | |
* | |
* @name equal | |
* @alias equals | |
* @alias eq | |
* @alias deep.equal | |
* @param {Mixed} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertEqual(val, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
if (flag(this, 'deep')) { | |
return this.eql(val); | |
} else { | |
this.assert(val === obj, 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{exp}', val, this._obj, true); | |
} | |
} | |
Assertion.addMethod('equal', assertEqual); | |
Assertion.addMethod('equals', assertEqual); | |
Assertion.addMethod('eq', assertEqual); | |
/** | |
* ### .eql(value) | |
* | |
* Asserts that the target is deeply equal to `value`. | |
* | |
* expect({ foo: 'bar' }).to.eql({ foo: 'bar' }); | |
* expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]); | |
* | |
* @name eql | |
* @alias eqls | |
* @param {Mixed} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertEql(obj, msg) { | |
if (msg) flag(this, 'message', msg); | |
this.assert(_.eql(obj, flag(this, 'object')), 'expected #{this} to deeply equal #{exp}', 'expected #{this} to not deeply equal #{exp}', obj, this._obj, true); | |
} | |
Assertion.addMethod('eql', assertEql); | |
Assertion.addMethod('eqls', assertEql); | |
/** | |
* ### .above(value) | |
* | |
* Asserts that the target is greater than `value`. | |
* | |
* expect(10).to.be.above(5); | |
* | |
* Can also be used in conjunction with `length` to | |
* assert a minimum length. The benefit being a | |
* more informative error message than if the length | |
* was supplied directly. | |
* | |
* expect('foo').to.have.length.above(2); | |
* expect([ 1, 2, 3 ]).to.have.length.above(2); | |
* | |
* @name above | |
* @alias gt | |
* @alias greaterThan | |
* @param {Number} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertAbove(n, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
if (flag(this, 'doLength')) { | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len > n, 'expected #{this} to have a length above #{exp} but got #{act}', 'expected #{this} to not have a length above #{exp}', n, len); | |
} else { | |
this.assert(obj > n, 'expected #{this} to be above ' + n, 'expected #{this} to be at most ' + n); | |
} | |
} | |
Assertion.addMethod('above', assertAbove); | |
Assertion.addMethod('gt', assertAbove); | |
Assertion.addMethod('greaterThan', assertAbove); | |
/** | |
* ### .least(value) | |
* | |
* Asserts that the target is greater than or equal to `value`. | |
* | |
* expect(10).to.be.at.least(10); | |
* | |
* Can also be used in conjunction with `length` to | |
* assert a minimum length. The benefit being a | |
* more informative error message than if the length | |
* was supplied directly. | |
* | |
* expect('foo').to.have.length.of.at.least(2); | |
* expect([ 1, 2, 3 ]).to.have.length.of.at.least(3); | |
* | |
* @name least | |
* @alias gte | |
* @param {Number} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertLeast(n, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
if (flag(this, 'doLength')) { | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len >= n, 'expected #{this} to have a length at least #{exp} but got #{act}', 'expected #{this} to have a length below #{exp}', n, len); | |
} else { | |
this.assert(obj >= n, 'expected #{this} to be at least ' + n, 'expected #{this} to be below ' + n); | |
} | |
} | |
Assertion.addMethod('least', assertLeast); | |
Assertion.addMethod('gte', assertLeast); | |
/** | |
* ### .below(value) | |
* | |
* Asserts that the target is less than `value`. | |
* | |
* expect(5).to.be.below(10); | |
* | |
* Can also be used in conjunction with `length` to | |
* assert a maximum length. The benefit being a | |
* more informative error message than if the length | |
* was supplied directly. | |
* | |
* expect('foo').to.have.length.below(4); | |
* expect([ 1, 2, 3 ]).to.have.length.below(4); | |
* | |
* @name below | |
* @alias lt | |
* @alias lessThan | |
* @param {Number} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertBelow(n, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
if (flag(this, 'doLength')) { | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len < n, 'expected #{this} to have a length below #{exp} but got #{act}', 'expected #{this} to not have a length below #{exp}', n, len); | |
} else { | |
this.assert(obj < n, 'expected #{this} to be below ' + n, 'expected #{this} to be at least ' + n); | |
} | |
} | |
Assertion.addMethod('below', assertBelow); | |
Assertion.addMethod('lt', assertBelow); | |
Assertion.addMethod('lessThan', assertBelow); | |
/** | |
* ### .most(value) | |
* | |
* Asserts that the target is less than or equal to `value`. | |
* | |
* expect(5).to.be.at.most(5); | |
* | |
* Can also be used in conjunction with `length` to | |
* assert a maximum length. The benefit being a | |
* more informative error message than if the length | |
* was supplied directly. | |
* | |
* expect('foo').to.have.length.of.at.most(4); | |
* expect([ 1, 2, 3 ]).to.have.length.of.at.most(3); | |
* | |
* @name most | |
* @alias lte | |
* @param {Number} value | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertMost(n, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
if (flag(this, 'doLength')) { | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len <= n, 'expected #{this} to have a length at most #{exp} but got #{act}', 'expected #{this} to have a length above #{exp}', n, len); | |
} else { | |
this.assert(obj <= n, 'expected #{this} to be at most ' + n, 'expected #{this} to be above ' + n); | |
} | |
} | |
Assertion.addMethod('most', assertMost); | |
Assertion.addMethod('lte', assertMost); | |
/** | |
* ### .within(start, finish) | |
* | |
* Asserts that the target is within a range. | |
* | |
* expect(7).to.be.within(5,10); | |
* | |
* Can also be used in conjunction with `length` to | |
* assert a length range. The benefit being a | |
* more informative error message than if the length | |
* was supplied directly. | |
* | |
* expect('foo').to.have.length.within(2,4); | |
* expect([ 1, 2, 3 ]).to.have.length.within(2,4); | |
* | |
* @name within | |
* @param {Number} start lowerbound inclusive | |
* @param {Number} finish upperbound inclusive | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addMethod('within', function (start, finish, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'), | |
range = start + '..' + finish; | |
if (flag(this, 'doLength')) { | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len >= start && len <= finish, 'expected #{this} to have a length within ' + range, 'expected #{this} to not have a length within ' + range); | |
} else { | |
this.assert(obj >= start && obj <= finish, 'expected #{this} to be within ' + range, 'expected #{this} to not be within ' + range); | |
} | |
}); | |
/** | |
* ### .instanceof(constructor) | |
* | |
* Asserts that the target is an instance of `constructor`. | |
* | |
* var Tea = function (name) { this.name = name; } | |
* , Chai = new Tea('chai'); | |
* | |
* expect(Chai).to.be.an.instanceof(Tea); | |
* expect([ 1, 2, 3 ]).to.be.instanceof(Array); | |
* | |
* @name instanceof | |
* @param {Constructor} constructor | |
* @param {String} message _optional_ | |
* @alias instanceOf | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertInstanceOf(constructor, msg) { | |
if (msg) flag(this, 'message', msg); | |
var name = _.getName(constructor); | |
this.assert(flag(this, 'object') instanceof constructor, 'expected #{this} to be an instance of ' + name, 'expected #{this} to not be an instance of ' + name); | |
}; | |
Assertion.addMethod('instanceof', assertInstanceOf); | |
Assertion.addMethod('instanceOf', assertInstanceOf); | |
/** | |
* ### .property(name, [value]) | |
* | |
* Asserts that the target has a property `name`, optionally asserting that | |
* the value of that property is strictly equal to `value`. | |
* If the `deep` flag is set, you can use dot- and bracket-notation for deep | |
* references into objects and arrays. | |
* | |
* // simple referencing | |
* var obj = { foo: 'bar' }; | |
* expect(obj).to.have.property('foo'); | |
* expect(obj).to.have.property('foo', 'bar'); | |
* | |
* // deep referencing | |
* var deepObj = { | |
* green: { tea: 'matcha' } | |
* , teas: [ 'chai', 'matcha', { tea: 'konacha' } ] | |
* }; | |
* | |
* expect(deepObj).to.have.deep.property('green.tea', 'matcha'); | |
* expect(deepObj).to.have.deep.property('teas[1]', 'matcha'); | |
* expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha'); | |
* | |
* You can also use an array as the starting point of a `deep.property` | |
* assertion, or traverse nested arrays. | |
* | |
* var arr = [ | |
* [ 'chai', 'matcha', 'konacha' ] | |
* , [ { tea: 'chai' } | |
* , { tea: 'matcha' } | |
* , { tea: 'konacha' } ] | |
* ]; | |
* | |
* expect(arr).to.have.deep.property('[0][1]', 'matcha'); | |
* expect(arr).to.have.deep.property('[1][2].tea', 'konacha'); | |
* | |
* Furthermore, `property` changes the subject of the assertion | |
* to be the value of that property from the original object. This | |
* permits for further chainable assertions on that property. | |
* | |
* expect(obj).to.have.property('foo') | |
* .that.is.a('string'); | |
* expect(deepObj).to.have.property('green') | |
* .that.is.an('object') | |
* .that.deep.equals({ tea: 'matcha' }); | |
* expect(deepObj).to.have.property('teas') | |
* .that.is.an('array') | |
* .with.deep.property('[2]') | |
* .that.deep.equals({ tea: 'konacha' }); | |
* | |
* Note that dots and bracket in `name` must be backslash-escaped when | |
* the `deep` flag is set, while they must NOT be escaped when the `deep` | |
* flag is not set. | |
* | |
* // simple referencing | |
* var css = { '.link[target]': 42 }; | |
* expect(css).to.have.property('.link[target]', 42); | |
* | |
* // deep referencing | |
* var deepCss = { '.link': { '[target]': 42 }}; | |
* expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42); | |
* | |
* @name property | |
* @alias deep.property | |
* @param {String} name | |
* @param {Mixed} value (optional) | |
* @param {String} message _optional_ | |
* @returns value of property for chaining | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addMethod('property', function (name, val, msg) { | |
if (msg) flag(this, 'message', msg); | |
var isDeep = !!flag(this, 'deep'), | |
descriptor = isDeep ? 'deep property ' : 'property ', | |
negate = flag(this, 'negate'), | |
obj = flag(this, 'object'), | |
pathInfo = isDeep ? _.getPathInfo(name, obj) : null, | |
hasProperty = isDeep ? pathInfo.exists : _.hasProperty(name, obj), | |
value = isDeep ? pathInfo.value : obj[name]; | |
if (negate && arguments.length > 1) { | |
if (undefined === value) { | |
msg = msg != null ? msg + ': ' : ''; | |
throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name)); | |
} | |
} else { | |
this.assert(hasProperty, 'expected #{this} to have a ' + descriptor + _.inspect(name), 'expected #{this} to not have ' + descriptor + _.inspect(name)); | |
} | |
if (arguments.length > 1) { | |
this.assert(val === value, 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}', 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}', val, value); | |
} | |
flag(this, 'object', value); | |
}); | |
/** | |
* ### .ownProperty(name) | |
* | |
* Asserts that the target has an own property `name`. | |
* | |
* expect('test').to.have.ownProperty('length'); | |
* | |
* @name ownProperty | |
* @alias haveOwnProperty | |
* @param {String} name | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertOwnProperty(name, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
this.assert(obj.hasOwnProperty(name), 'expected #{this} to have own property ' + _.inspect(name), 'expected #{this} to not have own property ' + _.inspect(name)); | |
} | |
Assertion.addMethod('ownProperty', assertOwnProperty); | |
Assertion.addMethod('haveOwnProperty', assertOwnProperty); | |
/** | |
* ### .ownPropertyDescriptor(name[, descriptor[, message]]) | |
* | |
* Asserts that the target has an own property descriptor `name`, that optionally matches `descriptor`. | |
* | |
* expect('test').to.have.ownPropertyDescriptor('length'); | |
* expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 }); | |
* expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 }); | |
* expect('test').ownPropertyDescriptor('length').to.have.property('enumerable', false); | |
* expect('test').ownPropertyDescriptor('length').to.have.keys('value'); | |
* | |
* @name ownPropertyDescriptor | |
* @alias haveOwnPropertyDescriptor | |
* @param {String} name | |
* @param {Object} descriptor _optional_ | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertOwnPropertyDescriptor(name, descriptor, msg) { | |
if (typeof descriptor === 'string') { | |
msg = descriptor; | |
descriptor = null; | |
} | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name); | |
if (actualDescriptor && descriptor) { | |
this.assert(_.eql(descriptor, actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor), descriptor, actualDescriptor, true); | |
} else { | |
this.assert(actualDescriptor, 'expected #{this} to have an own property descriptor for ' + _.inspect(name), 'expected #{this} to not have an own property descriptor for ' + _.inspect(name)); | |
} | |
flag(this, 'object', actualDescriptor); | |
} | |
Assertion.addMethod('ownPropertyDescriptor', assertOwnPropertyDescriptor); | |
Assertion.addMethod('haveOwnPropertyDescriptor', assertOwnPropertyDescriptor); | |
/** | |
* ### .length | |
* | |
* Sets the `doLength` flag later used as a chain precursor to a value | |
* comparison for the `length` property. | |
* | |
* expect('foo').to.have.length.above(2); | |
* expect([ 1, 2, 3 ]).to.have.length.above(2); | |
* expect('foo').to.have.length.below(4); | |
* expect([ 1, 2, 3 ]).to.have.length.below(4); | |
* expect('foo').to.have.length.within(2,4); | |
* expect([ 1, 2, 3 ]).to.have.length.within(2,4); | |
* | |
* *Deprecation notice:* Using `length` as an assertion will be deprecated | |
* in version 2.4.0 and removed in 3.0.0. Code using the old style of | |
* asserting for `length` property value using `length(value)` should be | |
* switched to use `lengthOf(value)` instead. | |
* | |
* @name length | |
* @namespace BDD | |
* @api public | |
*/ | |
/** | |
* ### .lengthOf(value[, message]) | |
* | |
* Asserts that the target's `length` property has | |
* the expected value. | |
* | |
* expect([ 1, 2, 3]).to.have.lengthOf(3); | |
* expect('foobar').to.have.lengthOf(6); | |
* | |
* @name lengthOf | |
* @param {Number} length | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertLengthChain() { | |
flag(this, 'doLength', true); | |
} | |
function assertLength(n, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
new Assertion(obj, msg).to.have.property('length'); | |
var len = obj.length; | |
this.assert(len == n, 'expected #{this} to have a length of #{exp} but got #{act}', 'expected #{this} to not have a length of #{act}', n, len); | |
} | |
Assertion.addChainableMethod('length', assertLength, assertLengthChain); | |
Assertion.addMethod('lengthOf', assertLength); | |
/** | |
* ### .match(regexp) | |
* | |
* Asserts that the target matches a regular expression. | |
* | |
* expect('foobar').to.match(/^foo/); | |
* | |
* @name match | |
* @alias matches | |
* @param {RegExp} RegularExpression | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertMatch(re, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
this.assert(re.exec(obj), 'expected #{this} to match ' + re, 'expected #{this} not to match ' + re); | |
} | |
Assertion.addMethod('match', assertMatch); | |
Assertion.addMethod('matches', assertMatch); | |
/** | |
* ### .string(string) | |
* | |
* Asserts that the string target contains another string. | |
* | |
* expect('foobar').to.have.string('bar'); | |
* | |
* @name string | |
* @param {String} string | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addMethod('string', function (str, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
new Assertion(obj, msg).is.a('string'); | |
this.assert(~obj.indexOf(str), 'expected #{this} to contain ' + _.inspect(str), 'expected #{this} to not contain ' + _.inspect(str)); | |
}); | |
/** | |
* ### .keys(key1, [key2], [...]) | |
* | |
* Asserts that the target contains any or all of the passed-in keys. | |
* Use in combination with `any`, `all`, `contains`, or `have` will affect | |
* what will pass. | |
* | |
* When used in conjunction with `any`, at least one key that is passed | |
* in must exist in the target object. This is regardless whether or not | |
* the `have` or `contain` qualifiers are used. Note, either `any` or `all` | |
* should be used in the assertion. If neither are used, the assertion is | |
* defaulted to `all`. | |
* | |
* When both `all` and `contain` are used, the target object must have at | |
* least all of the passed-in keys but may have more keys not listed. | |
* | |
* When both `all` and `have` are used, the target object must both contain | |
* all of the passed-in keys AND the number of keys in the target object must | |
* match the number of keys passed in (in other words, a target object must | |
* have all and only all of the passed-in keys). | |
* | |
* expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz'); | |
* expect({ foo: 1, bar: 2 }).to.have.any.keys('foo'); | |
* expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz'); | |
* expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']); | |
* expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6}); | |
* expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']); | |
* expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo': 7}); | |
* expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']); | |
* expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys({'bar': 6}); | |
* | |
* | |
* @name keys | |
* @alias key | |
* @param {...String|Array|Object} keys | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertKeys(keys) { | |
var obj = flag(this, 'object'), | |
str, | |
ok = true, | |
mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments'; | |
switch (_.type(keys)) { | |
case "array": | |
if (arguments.length > 1) throw new Error(mixedArgsMsg); | |
break; | |
case "object": | |
if (arguments.length > 1) throw new Error(mixedArgsMsg); | |
keys = Object.keys(keys); | |
break; | |
default: | |
keys = Array.prototype.slice.call(arguments); | |
} | |
if (!keys.length) throw new Error('keys required'); | |
var actual = Object.keys(obj), | |
expected = keys, | |
len = keys.length, | |
any = flag(this, 'any'), | |
all = flag(this, 'all'); | |
if (!any && !all) { | |
all = true; | |
} | |
// Has any | |
if (any) { | |
var intersection = expected.filter(function (key) { | |
return ~actual.indexOf(key); | |
}); | |
ok = intersection.length > 0; | |
} | |
// Has all | |
if (all) { | |
ok = keys.every(function (key) { | |
return ~actual.indexOf(key); | |
}); | |
if (!flag(this, 'negate') && !flag(this, 'contains')) { | |
ok = ok && keys.length == actual.length; | |
} | |
} | |
// Key string | |
if (len > 1) { | |
keys = keys.map(function (key) { | |
return _.inspect(key); | |
}); | |
var last = keys.pop(); | |
if (all) { | |
str = keys.join(', ') + ', and ' + last; | |
} | |
if (any) { | |
str = keys.join(', ') + ', or ' + last; | |
} | |
} else { | |
str = _.inspect(keys[0]); | |
} | |
// Form | |
str = (len > 1 ? 'keys ' : 'key ') + str; | |
// Have / include | |
str = (flag(this, 'contains') ? 'contain ' : 'have ') + str; | |
// Assertion | |
this.assert(ok, 'expected #{this} to ' + str, 'expected #{this} to not ' + str, expected.slice(0).sort(), actual.sort(), true); | |
} | |
Assertion.addMethod('keys', assertKeys); | |
Assertion.addMethod('key', assertKeys); | |
/** | |
* ### .throw(constructor) | |
* | |
* Asserts that the function target will throw a specific error, or specific type of error | |
* (as determined using `instanceof`), optionally with a RegExp or string inclusion test | |
* for the error's message. | |
* | |
* var err = new ReferenceError('This is a bad function.'); | |
* var fn = function () { throw err; } | |
* expect(fn).to.throw(ReferenceError); | |
* expect(fn).to.throw(Error); | |
* expect(fn).to.throw(/bad function/); | |
* expect(fn).to.not.throw('good function'); | |
* expect(fn).to.throw(ReferenceError, /bad function/); | |
* expect(fn).to.throw(err); | |
* | |
* Please note that when a throw expectation is negated, it will check each | |
* parameter independently, starting with error constructor type. The appropriate way | |
* to check for the existence of a type of error but for a message that does not match | |
* is to use `and`. | |
* | |
* expect(fn).to.throw(ReferenceError) | |
* .and.not.throw(/good function/); | |
* | |
* @name throw | |
* @alias throws | |
* @alias Throw | |
* @param {ErrorConstructor} constructor | |
* @param {String|RegExp} expected error message | |
* @param {String} message _optional_ | |
* @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types | |
* @returns error for chaining (null if no error) | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertThrows(constructor, errMsg, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
new Assertion(obj, msg).is.a('function'); | |
var thrown = false, | |
desiredError = null, | |
name = null, | |
thrownError = null; | |
if (arguments.length === 0) { | |
errMsg = null; | |
constructor = null; | |
} else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) { | |
errMsg = constructor; | |
constructor = null; | |
} else if (constructor && constructor instanceof Error) { | |
desiredError = constructor; | |
constructor = null; | |
errMsg = null; | |
} else if (typeof constructor === 'function') { | |
name = constructor.prototype.name; | |
if (!name || name === 'Error' && constructor !== Error) { | |
name = constructor.name || new constructor().name; | |
} | |
} else { | |
constructor = null; | |
} | |
try { | |
obj(); | |
} catch (err) { | |
// first, check desired error | |
if (desiredError) { | |
this.assert(err === desiredError, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp}', desiredError instanceof Error ? desiredError.toString() : desiredError, err instanceof Error ? err.toString() : err); | |
flag(this, 'object', err); | |
return this; | |
} | |
// next, check constructor | |
if (constructor) { | |
this.assert(err instanceof constructor, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp} but #{act} was thrown', name, err instanceof Error ? err.toString() : err); | |
if (!errMsg) { | |
flag(this, 'object', err); | |
return this; | |
} | |
} | |
// next, check message | |
var message = 'error' === _.type(err) && "message" in err ? err.message : '' + err; | |
if (message != null && errMsg && errMsg instanceof RegExp) { | |
this.assert(errMsg.exec(message), 'expected #{this} to throw error matching #{exp} but got #{act}', 'expected #{this} to throw error not matching #{exp}', errMsg, message); | |
flag(this, 'object', err); | |
return this; | |
} else if (message != null && errMsg && 'string' === typeof errMsg) { | |
this.assert(~message.indexOf(errMsg), 'expected #{this} to throw error including #{exp} but got #{act}', 'expected #{this} to throw error not including #{act}', errMsg, message); | |
flag(this, 'object', err); | |
return this; | |
} else { | |
thrown = true; | |
thrownError = err; | |
} | |
} | |
var actuallyGot = '', | |
expectedThrown = name !== null ? name : desiredError ? '#{exp}' //_.inspect(desiredError) | |
: 'an error'; | |
if (thrown) { | |
actuallyGot = ' but #{act} was thrown'; | |
} | |
this.assert(thrown === true, 'expected #{this} to throw ' + expectedThrown + actuallyGot, 'expected #{this} to not throw ' + expectedThrown + actuallyGot, desiredError instanceof Error ? desiredError.toString() : desiredError, thrownError instanceof Error ? thrownError.toString() : thrownError); | |
flag(this, 'object', thrownError); | |
}; | |
Assertion.addMethod('throw', assertThrows); | |
Assertion.addMethod('throws', assertThrows); | |
Assertion.addMethod('Throw', assertThrows); | |
/** | |
* ### .respondTo(method) | |
* | |
* Asserts that the object or class target will respond to a method. | |
* | |
* Klass.prototype.bar = function(){}; | |
* expect(Klass).to.respondTo('bar'); | |
* expect(obj).to.respondTo('bar'); | |
* | |
* To check if a constructor will respond to a static function, | |
* set the `itself` flag. | |
* | |
* Klass.baz = function(){}; | |
* expect(Klass).itself.to.respondTo('baz'); | |
* | |
* @name respondTo | |
* @alias respondsTo | |
* @param {String} method | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function respondTo(method, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'), | |
itself = flag(this, 'itself'), | |
context = 'function' === _.type(obj) && !itself ? obj.prototype[method] : obj[method]; | |
this.assert('function' === typeof context, 'expected #{this} to respond to ' + _.inspect(method), 'expected #{this} to not respond to ' + _.inspect(method)); | |
} | |
Assertion.addMethod('respondTo', respondTo); | |
Assertion.addMethod('respondsTo', respondTo); | |
/** | |
* ### .itself | |
* | |
* Sets the `itself` flag, later used by the `respondTo` assertion. | |
* | |
* function Foo() {} | |
* Foo.bar = function() {} | |
* Foo.prototype.baz = function() {} | |
* | |
* expect(Foo).itself.to.respondTo('bar'); | |
* expect(Foo).itself.not.to.respondTo('baz'); | |
* | |
* @name itself | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('itself', function () { | |
flag(this, 'itself', true); | |
}); | |
/** | |
* ### .satisfy(method) | |
* | |
* Asserts that the target passes a given truth test. | |
* | |
* expect(1).to.satisfy(function(num) { return num > 0; }); | |
* | |
* @name satisfy | |
* @alias satisfies | |
* @param {Function} matcher | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function satisfy(matcher, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
var result = matcher(obj); | |
this.assert(result, 'expected #{this} to satisfy ' + _.objDisplay(matcher), 'expected #{this} to not satisfy' + _.objDisplay(matcher), this.negate ? false : true, result); | |
} | |
Assertion.addMethod('satisfy', satisfy); | |
Assertion.addMethod('satisfies', satisfy); | |
/** | |
* ### .closeTo(expected, delta) | |
* | |
* Asserts that the target is equal `expected`, to within a +/- `delta` range. | |
* | |
* expect(1.5).to.be.closeTo(1, 0.5); | |
* | |
* @name closeTo | |
* @alias approximately | |
* @param {Number} expected | |
* @param {Number} delta | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function closeTo(expected, delta, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
new Assertion(obj, msg).is.a('number'); | |
if (_.type(expected) !== 'number' || _.type(delta) !== 'number') { | |
throw new Error('the arguments to closeTo or approximately must be numbers'); | |
} | |
this.assert(Math.abs(obj - expected) <= delta, 'expected #{this} to be close to ' + expected + ' +/- ' + delta, 'expected #{this} not to be close to ' + expected + ' +/- ' + delta); | |
} | |
Assertion.addMethod('closeTo', closeTo); | |
Assertion.addMethod('approximately', closeTo); | |
function isSubsetOf(subset, superset, cmp) { | |
return subset.every(function (elem) { | |
if (!cmp) return superset.indexOf(elem) !== -1; | |
return superset.some(function (elem2) { | |
return cmp(elem, elem2); | |
}); | |
}); | |
} | |
/** | |
* ### .members(set) | |
* | |
* Asserts that the target is a superset of `set`, | |
* or that the target and `set` have the same strictly-equal (===) members. | |
* Alternately, if the `deep` flag is set, set members are compared for deep | |
* equality. | |
* | |
* expect([1, 2, 3]).to.include.members([3, 2]); | |
* expect([1, 2, 3]).to.not.include.members([3, 2, 8]); | |
* | |
* expect([4, 2]).to.have.members([2, 4]); | |
* expect([5, 2]).to.not.have.members([5, 2, 1]); | |
* | |
* expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]); | |
* | |
* @name members | |
* @param {Array} set | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addMethod('members', function (subset, msg) { | |
if (msg) flag(this, 'message', msg); | |
var obj = flag(this, 'object'); | |
new Assertion(obj).to.be.an('array'); | |
new Assertion(subset).to.be.an('array'); | |
var cmp = flag(this, 'deep') ? _.eql : undefined; | |
if (flag(this, 'contains')) { | |
return this.assert(isSubsetOf(subset, obj, cmp), 'expected #{this} to be a superset of #{act}', 'expected #{this} to not be a superset of #{act}', obj, subset); | |
} | |
this.assert(isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp), 'expected #{this} to have the same members as #{act}', 'expected #{this} to not have the same members as #{act}', obj, subset); | |
}); | |
/** | |
* ### .oneOf(list) | |
* | |
* Assert that a value appears somewhere in the top level of array `list`. | |
* | |
* expect('a').to.be.oneOf(['a', 'b', 'c']); | |
* expect(9).to.not.be.oneOf(['z']); | |
* expect([3]).to.not.be.oneOf([1, 2, [3]]); | |
* | |
* var three = [3]; | |
* // for object-types, contents are not compared | |
* expect(three).to.not.be.oneOf([1, 2, [3]]); | |
* // comparing references works | |
* expect(three).to.be.oneOf([1, 2, three]); | |
* | |
* @name oneOf | |
* @param {Array<*>} list | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function oneOf(list, msg) { | |
if (msg) flag(this, 'message', msg); | |
var expected = flag(this, 'object'); | |
new Assertion(list).to.be.an('array'); | |
this.assert(list.indexOf(expected) > -1, 'expected #{this} to be one of #{exp}', 'expected #{this} to not be one of #{exp}', list, expected); | |
} | |
Assertion.addMethod('oneOf', oneOf); | |
/** | |
* ### .change(function) | |
* | |
* Asserts that a function changes an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val += 3 }; | |
* var noChangeFn = function() { return 'foo' + 'bar'; } | |
* expect(fn).to.change(obj, 'val'); | |
* expect(noChangeFn).to.not.change(obj, 'val') | |
* | |
* @name change | |
* @alias changes | |
* @alias Change | |
* @param {String} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertChanges(object, prop, msg) { | |
if (msg) flag(this, 'message', msg); | |
var fn = flag(this, 'object'); | |
new Assertion(object, msg).to.have.property(prop); | |
new Assertion(fn).is.a('function'); | |
var initial = object[prop]; | |
fn(); | |
this.assert(initial !== object[prop], 'expected .' + prop + ' to change', 'expected .' + prop + ' to not change'); | |
} | |
Assertion.addChainableMethod('change', assertChanges); | |
Assertion.addChainableMethod('changes', assertChanges); | |
/** | |
* ### .increase(function) | |
* | |
* Asserts that a function increases an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 15 }; | |
* expect(fn).to.increase(obj, 'val'); | |
* | |
* @name increase | |
* @alias increases | |
* @alias Increase | |
* @param {String} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertIncreases(object, prop, msg) { | |
if (msg) flag(this, 'message', msg); | |
var fn = flag(this, 'object'); | |
new Assertion(object, msg).to.have.property(prop); | |
new Assertion(fn).is.a('function'); | |
var initial = object[prop]; | |
fn(); | |
this.assert(object[prop] - initial > 0, 'expected .' + prop + ' to increase', 'expected .' + prop + ' to not increase'); | |
} | |
Assertion.addChainableMethod('increase', assertIncreases); | |
Assertion.addChainableMethod('increases', assertIncreases); | |
/** | |
* ### .decrease(function) | |
* | |
* Asserts that a function decreases an object property | |
* | |
* var obj = { val: 10 }; | |
* var fn = function() { obj.val = 5 }; | |
* expect(fn).to.decrease(obj, 'val'); | |
* | |
* @name decrease | |
* @alias decreases | |
* @alias Decrease | |
* @param {String} object | |
* @param {String} property name | |
* @param {String} message _optional_ | |
* @namespace BDD | |
* @api public | |
*/ | |
function assertDecreases(object, prop, msg) { | |
if (msg) flag(this, 'message', msg); | |
var fn = flag(this, 'object'); | |
new Assertion(object, msg).to.have.property(prop); | |
new Assertion(fn).is.a('function'); | |
var initial = object[prop]; | |
fn(); | |
this.assert(object[prop] - initial < 0, 'expected .' + prop + ' to decrease', 'expected .' + prop + ' to not decrease'); | |
} | |
Assertion.addChainableMethod('decrease', assertDecreases); | |
Assertion.addChainableMethod('decreases', assertDecreases); | |
/** | |
* ### .extensible | |
* | |
* Asserts that the target is extensible (can have new properties added to | |
* it). | |
* | |
* var nonExtensibleObject = Object.preventExtensions({}); | |
* var sealedObject = Object.seal({}); | |
* var frozenObject = Object.freeze({}); | |
* | |
* expect({}).to.be.extensible; | |
* expect(nonExtensibleObject).to.not.be.extensible; | |
* expect(sealedObject).to.not.be.extensible; | |
* expect(frozenObject).to.not.be.extensible; | |
* | |
* @name extensible | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('extensible', function () { | |
var obj = flag(this, 'object'); | |
// In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. | |
// In ES6, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false. | |
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible | |
// The following provides ES6 behavior when a TypeError is thrown under ES5. | |
var isExtensible; | |
try { | |
isExtensible = Object.isExtensible(obj); | |
} catch (err) { | |
if (err instanceof TypeError) isExtensible = false;else throw err; | |
} | |
this.assert(isExtensible, 'expected #{this} to be extensible', 'expected #{this} to not be extensible'); | |
}); | |
/** | |
* ### .sealed | |
* | |
* Asserts that the target is sealed (cannot have new properties added to it | |
* and its existing properties cannot be removed). | |
* | |
* var sealedObject = Object.seal({}); | |
* var frozenObject = Object.freeze({}); | |
* | |
* expect(sealedObject).to.be.sealed; | |
* expect(frozenObject).to.be.sealed; | |
* expect({}).to.not.be.sealed; | |
* | |
* @name sealed | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('sealed', function () { | |
var obj = flag(this, 'object'); | |
// In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. | |
// In ES6, a non-object argument will be treated as if it was a sealed ordinary object, simply return true. | |
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed | |
// The following provides ES6 behavior when a TypeError is thrown under ES5. | |
var isSealed; | |
try { | |
isSealed = Object.isSealed(obj); | |
} catch (err) { | |
if (err instanceof TypeError) isSealed = true;else throw err; | |
} | |
this.assert(isSealed, 'expected #{this} to be sealed', 'expected #{this} to not be sealed'); | |
}); | |
/** | |
* ### .frozen | |
* | |
* Asserts that the target is frozen (cannot have new properties added to it | |
* and its existing properties cannot be modified). | |
* | |
* var frozenObject = Object.freeze({}); | |
* | |
* expect(frozenObject).to.be.frozen; | |
* expect({}).to.not.be.frozen; | |
* | |
* @name frozen | |
* @namespace BDD | |
* @api public | |
*/ | |
Assertion.addProperty('frozen', function () { | |
var obj = flag(this, 'object'); | |
// In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. | |
// In ES6, a non-object argument will be treated as if it was a frozen ordinary object, simply return true. | |
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen | |
// The following provides ES6 behavior when a TypeError is thrown under ES5. | |
var isFrozen; | |
try { | |
isFrozen = Object.isFrozen(obj); | |
} catch (err) { | |
if (err instanceof TypeError) isFrozen = true;else throw err; | |
} | |
this.assert(isFrozen, 'expected #{this} to be frozen', 'expected #{this} to not be frozen'); | |
}); | |
}; | |
}); | |
var require$$3 = assertions && (typeof assertions === 'undefined' ? 'undefined' : babelHelpers.typeof(assertions)) === 'object' && 'default' in assertions ? assertions['default'] : assertions; | |
var config$1 = __commonjs(function (module) { | |
module.exports = { | |
/** | |
* ### config.includeStack | |
* | |
* User configurable property, influences whether stack trace | |
* is included in Assertion error message. Default of false | |
* suppresses stack trace in the error message. | |
* | |
* chai.config.includeStack = true; // enable stack on error | |
* | |
* @param {Boolean} | |
* @api public | |
*/ | |
includeStack: false, | |
/** | |
* ### config.showDiff | |
* | |
* User configurable property, influences whether or not | |
* the `showDiff` flag should be included in the thrown | |
* AssertionErrors. `false` will always be `false`; `true` | |
* will be true when the assertion has requested a diff | |
* be shown. | |
* | |
* @param {Boolean} | |
* @api public | |
*/ | |
showDiff: true, | |
/** | |
* ### config.truncateThreshold | |
* | |
* User configurable property, sets length threshold for actual and | |
* expected values in assertion errors. If this threshold is exceeded, for | |
* example for large data structures, the value is replaced with something | |
* like `[ Array(3) ]` or `{ Object (prop1, prop2) }`. | |
* | |
* Set it to zero if you want to disable truncating altogether. | |
* | |
* This is especially userful when doing assertions on arrays: having this | |
* set to a reasonable large value makes the failure messages readily | |
* inspectable. | |
* | |
* chai.config.truncateThreshold = 0; // disable truncating | |
* | |
* @param {Number} | |
* @api public | |
*/ | |
truncateThreshold: 40 | |
}; | |
}); | |
var require$$0$3 = config$1 && (typeof config$1 === 'undefined' ? 'undefined' : babelHelpers.typeof(config$1)) === 'object' && 'default' in config$1 ? config$1['default'] : config$1; | |
var assertion = __commonjs(function (module) { | |
/*! | |
* chai | |
* http://chaijs.com | |
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var config = require$$0$3; | |
module.exports = function (_chai, util) { | |
/*! | |
* Module dependencies. | |
*/ | |
var AssertionError = _chai.AssertionError, | |
flag = util.flag; | |
/*! | |
* Module export. | |
*/ | |
_chai.Assertion = Assertion; | |
/*! | |
* Assertion Constructor | |
* | |
* Creates object for chaining. | |
* | |
* @api private | |
*/ | |
function Assertion(obj, msg, stack) { | |
flag(this, 'ssfi', stack || arguments.callee); | |
flag(this, 'object', obj); | |
flag(this, 'message', msg); | |
} | |
Object.defineProperty(Assertion, 'includeStack', { | |
get: function get() { | |
console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); | |
return config.includeStack; | |
}, | |
set: function set(value) { | |
console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); | |
config.includeStack = value; | |
} | |
}); | |
Object.defineProperty(Assertion, 'showDiff', { | |
get: function get() { | |
console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); | |
return config.showDiff; | |
}, | |
set: function set(value) { | |
console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); | |
config.showDiff = value; | |
} | |
}); | |
Assertion.addProperty = function (name, fn) { | |
util.addProperty(this.prototype, name, fn); | |
}; | |
Assertion.addMethod = function (name, fn) { | |
util.addMethod(this.prototype, name, fn); | |
}; | |
Assertion.addChainableMethod = function (name, fn, chainingBehavior) { | |
util.addChainableMethod(this.prototype, name, fn, chainingBehavior); | |
}; | |
Assertion.overwriteProperty = function (name, fn) { | |
util.overwriteProperty(this.prototype, name, fn); | |
}; | |
Assertion.overwriteMethod = function (name, fn) { | |
util.overwriteMethod(this.prototype, name, fn); | |
}; | |
Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) { | |
util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior); | |
}; | |
/** | |
* ### .assert(expression, message, negateMessage, expected, actual, showDiff) | |
* | |
* Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass. | |
* | |
* @name assert | |
* @param {Philosophical} expression to be tested | |
* @param {String|Function} message or function that returns message to display if expression fails | |
* @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails | |
* @param {Mixed} expected value (remember to check for negation) | |
* @param {Mixed} actual (optional) will default to `this.obj` | |
* @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails | |
* @api private | |
*/ | |
Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) { | |
var ok = util.test(this, arguments); | |
if (true !== showDiff) showDiff = false; | |
if (true !== config.showDiff) showDiff = false; | |
if (!ok) { | |
var msg = util.getMessage(this, arguments), | |
actual = util.getActual(this, arguments); | |
throw new AssertionError(msg, { | |
actual: actual, | |
expected: expected, | |
showDiff: showDiff | |
}, config.includeStack ? this.assert : flag(this, 'ssfi')); | |
} | |
}; | |
/*! | |
* ### ._obj | |
* | |
* Quick reference to stored `actual` value for plugin developers. | |
* | |
* @api private | |
*/ | |
Object.defineProperty(Assertion.prototype, '_obj', { get: function get() { | |
return flag(this, 'object'); | |
}, | |
set: function set(val) { | |
flag(this, 'object', val); | |
} | |
}); | |
}; | |
}); | |
var require$$4 = assertion && (typeof assertion === 'undefined' ? 'undefined' : babelHelpers.typeof(assertion)) === 'object' && 'default' in assertion ? assertion['default'] : assertion; | |
var overwriteChainableMethod = __commonjs(function (module) { | |
/*! | |
* Chai - overwriteChainableMethod utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### overwriteChainableMethod (ctx, name, method, chainingBehavior) | |
* | |
* Overwites an already existing chainable method | |
* and provides access to the previous function or | |
* property. Must return functions to be used for | |
* name. | |
* | |
* utils.overwriteChainableMethod(chai.Assertion.prototype, 'length', | |
* function (_super) { | |
* } | |
* , function (_super) { | |
* } | |
* ); | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.overwriteChainableMethod('foo', fn, fn); | |
* | |
* Then can be used as any other assertion. | |
* | |
* expect(myFoo).to.have.length(3); | |
* expect(myFoo).to.have.length.above(3); | |
* | |
* @param {Object} ctx object whose method / property is to be overwritten | |
* @param {String} name of method / property to overwrite | |
* @param {Function} method function that returns a function to be used for name | |
* @param {Function} chainingBehavior function that returns a function to be used for property | |
* @namespace Utils | |
* @name overwriteChainableMethod | |
* @api public | |
*/ | |
module.exports = function (ctx, name, method, chainingBehavior) { | |
var chainableBehavior = ctx.__methods[name]; | |
var _chainingBehavior = chainableBehavior.chainingBehavior; | |
chainableBehavior.chainingBehavior = function () { | |
var result = chainingBehavior(_chainingBehavior).call(this); | |
return result === undefined ? this : result; | |
}; | |
var _method = chainableBehavior.method; | |
chainableBehavior.method = function () { | |
var result = method(_method).apply(this, arguments); | |
return result === undefined ? this : result; | |
}; | |
}; | |
}); | |
var require$$0$4 = overwriteChainableMethod && (typeof overwriteChainableMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteChainableMethod)) === 'object' && 'default' in overwriteChainableMethod ? overwriteChainableMethod['default'] : overwriteChainableMethod; | |
var flag = __commonjs(function (module) { | |
/*! | |
* Chai - flag utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### flag(object, key, [value]) | |
* | |
* Get or set a flag value on an object. If a | |
* value is provided it will be set, else it will | |
* return the currently set value or `undefined` if | |
* the value is not set. | |
* | |
* utils.flag(this, 'foo', 'bar'); // setter | |
* utils.flag(this, 'foo'); // getter, returns `bar` | |
* | |
* @param {Object} object constructed Assertion | |
* @param {String} key | |
* @param {Mixed} value (optional) | |
* @namespace Utils | |
* @name flag | |
* @api private | |
*/ | |
module.exports = function (obj, key, value) { | |
var flags = obj.__flags || (obj.__flags = Object.create(null)); | |
if (arguments.length === 3) { | |
flags[key] = value; | |
} else { | |
return flags[key]; | |
} | |
}; | |
}); | |
var require$$0$5 = flag && (typeof flag === 'undefined' ? 'undefined' : babelHelpers.typeof(flag)) === 'object' && 'default' in flag ? flag['default'] : flag; | |
var transferFlags = __commonjs(function (module) { | |
/*! | |
* Chai - transferFlags utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### transferFlags(assertion, object, includeAll = true) | |
* | |
* Transfer all the flags for `assertion` to `object`. If | |
* `includeAll` is set to `false`, then the base Chai | |
* assertion flags (namely `object`, `ssfi`, and `message`) | |
* will not be transferred. | |
* | |
* | |
* var newAssertion = new Assertion(); | |
* utils.transferFlags(assertion, newAssertion); | |
* | |
* var anotherAsseriton = new Assertion(myObj); | |
* utils.transferFlags(assertion, anotherAssertion, false); | |
* | |
* @param {Assertion} assertion the assertion to transfer the flags from | |
* @param {Object} object the object to transfer the flags to; usually a new assertion | |
* @param {Boolean} includeAll | |
* @namespace Utils | |
* @name transferFlags | |
* @api private | |
*/ | |
module.exports = function (assertion, object, includeAll) { | |
var flags = assertion.__flags || (assertion.__flags = Object.create(null)); | |
if (!object.__flags) { | |
object.__flags = Object.create(null); | |
} | |
includeAll = arguments.length === 3 ? includeAll : true; | |
for (var flag in flags) { | |
if (includeAll || flag !== 'object' && flag !== 'ssfi' && flag != 'message') { | |
object.__flags[flag] = flags[flag]; | |
} | |
} | |
}; | |
}); | |
var require$$2$1 = transferFlags && (typeof transferFlags === 'undefined' ? 'undefined' : babelHelpers.typeof(transferFlags)) === 'object' && 'default' in transferFlags ? transferFlags['default'] : transferFlags; | |
var addChainableMethod = __commonjs(function (module) { | |
/*! | |
* Chai - addChainingMethod utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Module dependencies | |
*/ | |
var transferFlags = require$$2$1; | |
var flag = require$$0$5; | |
var config = require$$0$3; | |
/*! | |
* Module variables | |
*/ | |
// Check whether `__proto__` is supported | |
var hasProtoSupport = '__proto__' in Object; | |
// Without `__proto__` support, this module will need to add properties to a function. | |
// However, some Function.prototype methods cannot be overwritten, | |
// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69). | |
var excludeNames = /^(?:length|name|arguments|caller)$/; | |
// Cache `Function` properties | |
var call = Function.prototype.call, | |
apply = Function.prototype.apply; | |
/** | |
* ### addChainableMethod (ctx, name, method, chainingBehavior) | |
* | |
* Adds a method to an object, such that the method can also be chained. | |
* | |
* utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) { | |
* var obj = utils.flag(this, 'object'); | |
* new chai.Assertion(obj).to.be.equal(str); | |
* }); | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.addChainableMethod('foo', fn, chainingBehavior); | |
* | |
* The result can then be used as both a method assertion, executing both `method` and | |
* `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`. | |
* | |
* expect(fooStr).to.be.foo('bar'); | |
* expect(fooStr).to.be.foo.equal('foo'); | |
* | |
* @param {Object} ctx object to which the method is added | |
* @param {String} name of method to add | |
* @param {Function} method function to be used for `name`, when called | |
* @param {Function} chainingBehavior function to be called every time the property is accessed | |
* @namespace Utils | |
* @name addChainableMethod | |
* @api public | |
*/ | |
module.exports = function (ctx, name, method, chainingBehavior) { | |
if (typeof chainingBehavior !== 'function') { | |
chainingBehavior = function chainingBehavior() {}; | |
} | |
var chainableBehavior = { | |
method: method, | |
chainingBehavior: chainingBehavior | |
}; | |
// save the methods so we can overwrite them later, if we need to. | |
if (!ctx.__methods) { | |
ctx.__methods = {}; | |
} | |
ctx.__methods[name] = chainableBehavior; | |
Object.defineProperty(ctx, name, { get: function get() { | |
chainableBehavior.chainingBehavior.call(this); | |
var assert = function assert() { | |
var old_ssfi = flag(this, 'ssfi'); | |
if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', assert); | |
var result = chainableBehavior.method.apply(this, arguments); | |
return result === undefined ? this : result; | |
}; | |
// Use `__proto__` if available | |
if (hasProtoSupport) { | |
// Inherit all properties from the object by replacing the `Function` prototype | |
var prototype = assert.__proto__ = Object.create(this); | |
// Restore the `call` and `apply` methods from `Function` | |
prototype.call = call; | |
prototype.apply = apply; | |
} | |
// Otherwise, redefine all properties (slow!) | |
else { | |
var asserterNames = Object.getOwnPropertyNames(ctx); | |
asserterNames.forEach(function (asserterName) { | |
if (!excludeNames.test(asserterName)) { | |
var pd = Object.getOwnPropertyDescriptor(ctx, asserterName); | |
Object.defineProperty(assert, asserterName, pd); | |
} | |
}); | |
} | |
transferFlags(this, assert); | |
return assert; | |
}, | |
configurable: true | |
}); | |
}; | |
}); | |
var require$$1$1 = addChainableMethod && (typeof addChainableMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(addChainableMethod)) === 'object' && 'default' in addChainableMethod ? addChainableMethod['default'] : addChainableMethod; | |
var overwriteMethod = __commonjs(function (module) { | |
/*! | |
* Chai - overwriteMethod utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### overwriteMethod (ctx, name, fn) | |
* | |
* Overwites an already existing method and provides | |
* access to previous function. Must return function | |
* to be used for name. | |
* | |
* utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) { | |
* return function (str) { | |
* var obj = utils.flag(this, 'object'); | |
* if (obj instanceof Foo) { | |
* new chai.Assertion(obj.value).to.equal(str); | |
* } else { | |
* _super.apply(this, arguments); | |
* } | |
* } | |
* }); | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.overwriteMethod('foo', fn); | |
* | |
* Then can be used as any other assertion. | |
* | |
* expect(myFoo).to.equal('bar'); | |
* | |
* @param {Object} ctx object whose method is to be overwritten | |
* @param {String} name of method to overwrite | |
* @param {Function} method function that returns a function to be used for name | |
* @namespace Utils | |
* @name overwriteMethod | |
* @api public | |
*/ | |
module.exports = function (ctx, name, method) { | |
var _method = ctx[name], | |
_super = function _super() { | |
return this; | |
}; | |
if (_method && 'function' === typeof _method) _super = _method; | |
ctx[name] = function () { | |
var result = method(_super).apply(this, arguments); | |
return result === undefined ? this : result; | |
}; | |
}; | |
}); | |
var require$$2$2 = overwriteMethod && (typeof overwriteMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteMethod)) === 'object' && 'default' in overwriteMethod ? overwriteMethod['default'] : overwriteMethod; | |
var overwriteProperty = __commonjs(function (module) { | |
/*! | |
* Chai - overwriteProperty utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### overwriteProperty (ctx, name, fn) | |
* | |
* Overwites an already existing property getter and provides | |
* access to previous value. Must return function to use as getter. | |
* | |
* utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) { | |
* return function () { | |
* var obj = utils.flag(this, 'object'); | |
* if (obj instanceof Foo) { | |
* new chai.Assertion(obj.name).to.equal('bar'); | |
* } else { | |
* _super.call(this); | |
* } | |
* } | |
* }); | |
* | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.overwriteProperty('foo', fn); | |
* | |
* Then can be used as any other assertion. | |
* | |
* expect(myFoo).to.be.ok; | |
* | |
* @param {Object} ctx object whose property is to be overwritten | |
* @param {String} name of property to overwrite | |
* @param {Function} getter function that returns a getter function to be used for name | |
* @namespace Utils | |
* @name overwriteProperty | |
* @api public | |
*/ | |
module.exports = function (ctx, name, getter) { | |
var _get = Object.getOwnPropertyDescriptor(ctx, name), | |
_super = function _super() {}; | |
if (_get && 'function' === typeof _get.get) _super = _get.get; | |
Object.defineProperty(ctx, name, { get: function get() { | |
var result = getter(_super).call(this); | |
return result === undefined ? this : result; | |
}, | |
configurable: true | |
}); | |
}; | |
}); | |
var require$$3$1 = overwriteProperty && (typeof overwriteProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteProperty)) === 'object' && 'default' in overwriteProperty ? overwriteProperty['default'] : overwriteProperty; | |
var addMethod = __commonjs(function (module) { | |
/*! | |
* Chai - addMethod utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var config = require$$0$3; | |
/** | |
* ### .addMethod (ctx, name, method) | |
* | |
* Adds a method to the prototype of an object. | |
* | |
* utils.addMethod(chai.Assertion.prototype, 'foo', function (str) { | |
* var obj = utils.flag(this, 'object'); | |
* new chai.Assertion(obj).to.be.equal(str); | |
* }); | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.addMethod('foo', fn); | |
* | |
* Then can be used as any other assertion. | |
* | |
* expect(fooStr).to.be.foo('bar'); | |
* | |
* @param {Object} ctx object to which the method is added | |
* @param {String} name of method to add | |
* @param {Function} method function to be used for name | |
* @namespace Utils | |
* @name addMethod | |
* @api public | |
*/ | |
var flag = require$$0$5; | |
module.exports = function (ctx, name, method) { | |
ctx[name] = function () { | |
var old_ssfi = flag(this, 'ssfi'); | |
if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', ctx[name]); | |
var result = method.apply(this, arguments); | |
return result === undefined ? this : result; | |
}; | |
}; | |
}); | |
var require$$4$1 = addMethod && (typeof addMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(addMethod)) === 'object' && 'default' in addMethod ? addMethod['default'] : addMethod; | |
var addProperty = __commonjs(function (module) { | |
/*! | |
* Chai - addProperty utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var config = require$$0$3; | |
var flag = require$$0$5; | |
/** | |
* ### addProperty (ctx, name, getter) | |
* | |
* Adds a property to the prototype of an object. | |
* | |
* utils.addProperty(chai.Assertion.prototype, 'foo', function () { | |
* var obj = utils.flag(this, 'object'); | |
* new chai.Assertion(obj).to.be.instanceof(Foo); | |
* }); | |
* | |
* Can also be accessed directly from `chai.Assertion`. | |
* | |
* chai.Assertion.addProperty('foo', fn); | |
* | |
* Then can be used as any other assertion. | |
* | |
* expect(myFoo).to.be.foo; | |
* | |
* @param {Object} ctx object to which the property is added | |
* @param {String} name of property to add | |
* @param {Function} getter function to be used for name | |
* @namespace Utils | |
* @name addProperty | |
* @api public | |
*/ | |
module.exports = function (ctx, name, getter) { | |
Object.defineProperty(ctx, name, { get: function addProperty() { | |
var old_ssfi = flag(this, 'ssfi'); | |
if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', addProperty); | |
var result = getter.call(this); | |
return result === undefined ? this : result; | |
}, | |
configurable: true | |
}); | |
}; | |
}); | |
var require$$5 = addProperty && (typeof addProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(addProperty)) === 'object' && 'default' in addProperty ? addProperty['default'] : addProperty; | |
var getName = __commonjs(function (module) { | |
/*! | |
* Chai - getName utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* # getName(func) | |
* | |
* Gets the name of a function, in a cross-browser way. | |
* | |
* @param {Function} a function (usually a constructor) | |
* @namespace Utils | |
* @name getName | |
*/ | |
module.exports = function (func) { | |
if (func.name) return func.name; | |
var match = /^\s?function ([^(]*)\(/.exec(func); | |
return match && match[1] ? match[1] : ""; | |
}; | |
}); | |
var require$$2$3 = getName && (typeof getName === 'undefined' ? 'undefined' : babelHelpers.typeof(getName)) === 'object' && 'default' in getName ? getName['default'] : getName; | |
var type = __commonjs(function (module) { | |
/*! | |
* type-detect | |
* Copyright(c) 2013 jake luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Primary Exports | |
*/ | |
var exports = module.exports = getType; | |
/** | |
* ### typeOf (obj) | |
* | |
* Use several different techniques to determine | |
* the type of object being tested. | |
* | |
* | |
* @param {Mixed} object | |
* @return {String} object type | |
* @api public | |
*/ | |
var objectTypeRegexp = /^\[object (.*)\]$/; | |
function getType(obj) { | |
var type = Object.prototype.toString.call(obj).match(objectTypeRegexp)[1].toLowerCase(); | |
// Let "new String('')" return 'object' | |
if (typeof Promise === 'function' && obj instanceof Promise) return 'promise'; | |
// PhantomJS has type "DOMWindow" for null | |
if (obj === null) return 'null'; | |
// PhantomJS has type "DOMWindow" for undefined | |
if (obj === undefined) return 'undefined'; | |
return type; | |
} | |
exports.Library = Library; | |
/** | |
* ### Library | |
* | |
* Create a repository for custom type detection. | |
* | |
* ```js | |
* var lib = new type.Library; | |
* ``` | |
* | |
*/ | |
function Library() { | |
if (!(this instanceof Library)) return new Library(); | |
this.tests = {}; | |
} | |
/** | |
* #### .of (obj) | |
* | |
* Expose replacement `typeof` detection to the library. | |
* | |
* ```js | |
* if ('string' === lib.of('hello world')) { | |
* // ... | |
* } | |
* ``` | |
* | |
* @param {Mixed} object to test | |
* @return {String} type | |
*/ | |
Library.prototype.of = getType; | |
/** | |
* #### .define (type, test) | |
* | |
* Add a test to for the `.test()` assertion. | |
* | |
* Can be defined as a regular expression: | |
* | |
* ```js | |
* lib.define('int', /^[0-9]+$/); | |
* ``` | |
* | |
* ... or as a function: | |
* | |
* ```js | |
* lib.define('bln', function (obj) { | |
* if ('boolean' === lib.of(obj)) return true; | |
* var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ]; | |
* if ('string' === lib.of(obj)) obj = obj.toLowerCase(); | |
* return !! ~blns.indexOf(obj); | |
* }); | |
* ``` | |
* | |
* @param {String} type | |
* @param {RegExp|Function} test | |
* @api public | |
*/ | |
Library.prototype.define = function (type, test) { | |
if (arguments.length === 1) return this.tests[type]; | |
this.tests[type] = test; | |
return this; | |
}; | |
/** | |
* #### .test (obj, test) | |
* | |
* Assert that an object is of type. Will first | |
* check natives, and if that does not pass it will | |
* use the user defined custom tests. | |
* | |
* ```js | |
* assert(lib.test('1', 'int')); | |
* assert(lib.test('yes', 'bln')); | |
* ``` | |
* | |
* @param {Mixed} object | |
* @param {String} type | |
* @return {Boolean} result | |
* @api public | |
*/ | |
Library.prototype.test = function (obj, type) { | |
if (type === getType(obj)) return true; | |
var test = this.tests[type]; | |
if (test && 'regexp' === getType(test)) { | |
return test.test(obj); | |
} else if (test && 'function' === getType(test)) { | |
return test(obj); | |
} else { | |
throw new ReferenceError('Type test "' + type + '" not defined or invalid.'); | |
} | |
}; | |
}); | |
var require$$0$8 = type && (typeof type === 'undefined' ? 'undefined' : babelHelpers.typeof(type)) === 'object' && 'default' in type ? type['default'] : type; | |
var index$3 = __commonjs(function (module) { | |
module.exports = require$$0$8; | |
}); | |
var require$$0$7 = index$3 && (typeof index$3 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$3)) === 'object' && 'default' in index$3 ? index$3['default'] : index$3; | |
var hasProperty = __commonjs(function (module) { | |
/*! | |
* Chai - hasProperty utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var type = require$$0$7; | |
/** | |
* ### .hasProperty(object, name) | |
* | |
* This allows checking whether an object has | |
* named property or numeric array index. | |
* | |
* Basically does the same thing as the `in` | |
* operator but works properly with natives | |
* and null/undefined values. | |
* | |
* var obj = { | |
* arr: ['a', 'b', 'c'] | |
* , str: 'Hello' | |
* } | |
* | |
* The following would be the results. | |
* | |
* hasProperty('str', obj); // true | |
* hasProperty('constructor', obj); // true | |
* hasProperty('bar', obj); // false | |
* | |
* hasProperty('length', obj.str); // true | |
* hasProperty(1, obj.str); // true | |
* hasProperty(5, obj.str); // false | |
* | |
* hasProperty('length', obj.arr); // true | |
* hasProperty(2, obj.arr); // true | |
* hasProperty(3, obj.arr); // false | |
* | |
* @param {Objuect} object | |
* @param {String|Number} name | |
* @returns {Boolean} whether it exists | |
* @namespace Utils | |
* @name getPathInfo | |
* @api public | |
*/ | |
var literals = { | |
'number': Number, | |
'string': String | |
}; | |
module.exports = function hasProperty(name, obj) { | |
var ot = type(obj); | |
// Bad Object, obviously no props at all | |
if (ot === 'null' || ot === 'undefined') return false; | |
// The `in` operator does not work with certain literals | |
// box these before the check | |
if (literals[ot] && (typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) !== 'object') obj = new literals[ot](obj); | |
return name in obj; | |
}; | |
}); | |
var require$$0$6 = hasProperty && (typeof hasProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(hasProperty)) === 'object' && 'default' in hasProperty ? hasProperty['default'] : hasProperty; | |
var getPathInfo = __commonjs(function (module) { | |
/*! | |
* Chai - getPathInfo utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var hasProperty = require$$0$6; | |
/** | |
* ### .getPathInfo(path, object) | |
* | |
* This allows the retrieval of property info in an | |
* object given a string path. | |
* | |
* The path info consists of an object with the | |
* following properties: | |
* | |
* * parent - The parent object of the property referenced by `path` | |
* * name - The name of the final property, a number if it was an array indexer | |
* * value - The value of the property, if it exists, otherwise `undefined` | |
* * exists - Whether the property exists or not | |
* | |
* @param {String} path | |
* @param {Object} object | |
* @returns {Object} info | |
* @namespace Utils | |
* @name getPathInfo | |
* @api public | |
*/ | |
module.exports = function getPathInfo(path, obj) { | |
var parsed = parsePath(path), | |
last = parsed[parsed.length - 1]; | |
var info = { | |
parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj, | |
name: last.p || last.i, | |
value: _getPathValue(parsed, obj) | |
}; | |
info.exists = hasProperty(info.name, info.parent); | |
return info; | |
}; | |
/*! | |
* ## parsePath(path) | |
* | |
* Helper function used to parse string object | |
* paths. Use in conjunction with `_getPathValue`. | |
* | |
* var parsed = parsePath('myobject.property.subprop'); | |
* | |
* ### Paths: | |
* | |
* * Can be as near infinitely deep and nested | |
* * Arrays are also valid using the formal `myobject.document[3].property`. | |
* * Literal dots and brackets (not delimiter) must be backslash-escaped. | |
* | |
* @param {String} path | |
* @returns {Object} parsed | |
* @api private | |
*/ | |
function parsePath(path) { | |
var str = path.replace(/([^\\])\[/g, '$1.['), | |
parts = str.match(/(\\\.|[^.]+?)+/g); | |
return parts.map(function (value) { | |
var re = /^\[(\d+)\]$/, | |
mArr = re.exec(value); | |
if (mArr) return { i: parseFloat(mArr[1]) };else return { p: value.replace(/\\([.\[\]])/g, '$1') }; | |
}); | |
} | |
/*! | |
* ## _getPathValue(parsed, obj) | |
* | |
* Helper companion function for `.parsePath` that returns | |
* the value located at the parsed address. | |
* | |
* var value = getPathValue(parsed, obj); | |
* | |
* @param {Object} parsed definition from `parsePath`. | |
* @param {Object} object to search against | |
* @param {Number} object to search against | |
* @returns {Object|Undefined} value | |
* @api private | |
*/ | |
function _getPathValue(parsed, obj, index) { | |
var tmp = obj, | |
res; | |
index = index === undefined ? parsed.length : index; | |
for (var i = 0, l = index; i < l; i++) { | |
var part = parsed[i]; | |
if (tmp) { | |
if ('undefined' !== typeof part.p) tmp = tmp[part.p];else if ('undefined' !== typeof part.i) tmp = tmp[part.i]; | |
if (i == l - 1) res = tmp; | |
} else { | |
res = undefined; | |
} | |
} | |
return res; | |
} | |
}); | |
var require$$0$9 = getPathInfo && (typeof getPathInfo === 'undefined' ? 'undefined' : babelHelpers.typeof(getPathInfo)) === 'object' && 'default' in getPathInfo ? getPathInfo['default'] : getPathInfo; | |
var getPathValue = __commonjs(function (module) { | |
/*! | |
* Chai - getPathValue utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* @see https://github.com/logicalparadox/filtr | |
* MIT Licensed | |
*/ | |
var getPathInfo = require$$0$9; | |
/** | |
* ### .getPathValue(path, object) | |
* | |
* This allows the retrieval of values in an | |
* object given a string path. | |
* | |
* var obj = { | |
* prop1: { | |
* arr: ['a', 'b', 'c'] | |
* , str: 'Hello' | |
* } | |
* , prop2: { | |
* arr: [ { nested: 'Universe' } ] | |
* , str: 'Hello again!' | |
* } | |
* } | |
* | |
* The following would be the results. | |
* | |
* getPathValue('prop1.str', obj); // Hello | |
* getPathValue('prop1.att[2]', obj); // b | |
* getPathValue('prop2.arr[0].nested', obj); // Universe | |
* | |
* @param {String} path | |
* @param {Object} object | |
* @returns {Object} value or `undefined` | |
* @namespace Utils | |
* @name getPathValue | |
* @api public | |
*/ | |
module.exports = function (path, obj) { | |
var info = getPathInfo(path, obj); | |
return info.value; | |
}; | |
}); | |
var require$$9 = getPathValue && (typeof getPathValue === 'undefined' ? 'undefined' : babelHelpers.typeof(getPathValue)) === 'object' && 'default' in getPathValue ? getPathValue['default'] : getPathValue; | |
var type$1 = __commonjs(function (module) { | |
/*! | |
* type-detect | |
* Copyright(c) 2013 jake luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Primary Exports | |
*/ | |
var exports = module.exports = getType; | |
/*! | |
* Detectable javascript natives | |
*/ | |
var natives = { | |
'[object Array]': 'array', | |
'[object RegExp]': 'regexp', | |
'[object Function]': 'function', | |
'[object Arguments]': 'arguments', | |
'[object Date]': 'date' | |
}; | |
/** | |
* ### typeOf (obj) | |
* | |
* Use several different techniques to determine | |
* the type of object being tested. | |
* | |
* | |
* @param {Mixed} object | |
* @return {String} object type | |
* @api public | |
*/ | |
function getType(obj) { | |
var str = Object.prototype.toString.call(obj); | |
if (natives[str]) return natives[str]; | |
if (obj === null) return 'null'; | |
if (obj === undefined) return 'undefined'; | |
if (obj === Object(obj)) return 'object'; | |
return typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj); | |
} | |
exports.Library = Library; | |
/** | |
* ### Library | |
* | |
* Create a repository for custom type detection. | |
* | |
* ```js | |
* var lib = new type.Library; | |
* ``` | |
* | |
*/ | |
function Library() { | |
this.tests = {}; | |
} | |
/** | |
* #### .of (obj) | |
* | |
* Expose replacement `typeof` detection to the library. | |
* | |
* ```js | |
* if ('string' === lib.of('hello world')) { | |
* // ... | |
* } | |
* ``` | |
* | |
* @param {Mixed} object to test | |
* @return {String} type | |
*/ | |
Library.prototype.of = getType; | |
/** | |
* #### .define (type, test) | |
* | |
* Add a test to for the `.test()` assertion. | |
* | |
* Can be defined as a regular expression: | |
* | |
* ```js | |
* lib.define('int', /^[0-9]+$/); | |
* ``` | |
* | |
* ... or as a function: | |
* | |
* ```js | |
* lib.define('bln', function (obj) { | |
* if ('boolean' === lib.of(obj)) return true; | |
* var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ]; | |
* if ('string' === lib.of(obj)) obj = obj.toLowerCase(); | |
* return !! ~blns.indexOf(obj); | |
* }); | |
* ``` | |
* | |
* @param {String} type | |
* @param {RegExp|Function} test | |
* @api public | |
*/ | |
Library.prototype.define = function (type, test) { | |
if (arguments.length === 1) return this.tests[type]; | |
this.tests[type] = test; | |
return this; | |
}; | |
/** | |
* #### .test (obj, test) | |
* | |
* Assert that an object is of type. Will first | |
* check natives, and if that does not pass it will | |
* use the user defined custom tests. | |
* | |
* ```js | |
* assert(lib.test('1', 'int')); | |
* assert(lib.test('yes', 'bln')); | |
* ``` | |
* | |
* @param {Mixed} object | |
* @param {String} type | |
* @return {Boolean} result | |
* @api public | |
*/ | |
Library.prototype.test = function (obj, type) { | |
if (type === getType(obj)) return true; | |
var test = this.tests[type]; | |
if (test && 'regexp' === getType(test)) { | |
return test.test(obj); | |
} else if (test && 'function' === getType(test)) { | |
return test(obj); | |
} else { | |
throw new ReferenceError('Type test "' + type + '" not defined or invalid.'); | |
} | |
}; | |
}); | |
var require$$0$11 = type$1 && (typeof type$1 === 'undefined' ? 'undefined' : babelHelpers.typeof(type$1)) === 'object' && 'default' in type$1 ? type$1['default'] : type$1; | |
var index$5 = __commonjs(function (module) { | |
module.exports = require$$0$11; | |
}); | |
var require$$1$2 = index$5 && (typeof index$5 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$5)) === 'object' && 'default' in index$5 ? index$5['default'] : index$5; | |
var eql = __commonjs(function (module) { | |
/*! | |
* deep-eql | |
* Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Module dependencies | |
*/ | |
var type = require$$1$2; | |
/*! | |
* Buffer.isBuffer browser shim | |
*/ | |
var Buffer; | |
try { | |
Buffer = require$$0.Buffer; | |
} catch (ex) { | |
Buffer = {}; | |
Buffer.isBuffer = function () { | |
return false; | |
}; | |
} | |
/*! | |
* Primary Export | |
*/ | |
module.exports = deepEqual; | |
/** | |
* Assert super-strict (egal) equality between | |
* two objects of any type. | |
* | |
* @param {Mixed} a | |
* @param {Mixed} b | |
* @param {Array} memoised (optional) | |
* @return {Boolean} equal match | |
*/ | |
function deepEqual(a, b, m) { | |
if (sameValue(a, b)) { | |
return true; | |
} else if ('date' === type(a)) { | |
return dateEqual(a, b); | |
} else if ('regexp' === type(a)) { | |
return regexpEqual(a, b); | |
} else if (Buffer.isBuffer(a)) { | |
return bufferEqual(a, b); | |
} else if ('arguments' === type(a)) { | |
return argumentsEqual(a, b, m); | |
} else if (!typeEqual(a, b)) { | |
return false; | |
} else if ('object' !== type(a) && 'object' !== type(b) && 'array' !== type(a) && 'array' !== type(b)) { | |
return sameValue(a, b); | |
} else { | |
return objectEqual(a, b, m); | |
} | |
} | |
/*! | |
* Strict (egal) equality test. Ensures that NaN always | |
* equals NaN and `-0` does not equal `+0`. | |
* | |
* @param {Mixed} a | |
* @param {Mixed} b | |
* @return {Boolean} equal match | |
*/ | |
function sameValue(a, b) { | |
if (a === b) return a !== 0 || 1 / a === 1 / b; | |
return a !== a && b !== b; | |
} | |
/*! | |
* Compare the types of two given objects and | |
* return if they are equal. Note that an Array | |
* has a type of `array` (not `object`) and arguments | |
* have a type of `arguments` (not `array`/`object`). | |
* | |
* @param {Mixed} a | |
* @param {Mixed} b | |
* @return {Boolean} result | |
*/ | |
function typeEqual(a, b) { | |
return type(a) === type(b); | |
} | |
/*! | |
* Compare two Date objects by asserting that | |
* the time values are equal using `saveValue`. | |
* | |
* @param {Date} a | |
* @param {Date} b | |
* @return {Boolean} result | |
*/ | |
function dateEqual(a, b) { | |
if ('date' !== type(b)) return false; | |
return sameValue(a.getTime(), b.getTime()); | |
} | |
/*! | |
* Compare two regular expressions by converting them | |
* to string and checking for `sameValue`. | |
* | |
* @param {RegExp} a | |
* @param {RegExp} b | |
* @return {Boolean} result | |
*/ | |
function regexpEqual(a, b) { | |
if ('regexp' !== type(b)) return false; | |
return sameValue(a.toString(), b.toString()); | |
} | |
/*! | |
* Assert deep equality of two `arguments` objects. | |
* Unfortunately, these must be sliced to arrays | |
* prior to test to ensure no bad behavior. | |
* | |
* @param {Arguments} a | |
* @param {Arguments} b | |
* @param {Array} memoize (optional) | |
* @return {Boolean} result | |
*/ | |
function argumentsEqual(a, b, m) { | |
if ('arguments' !== type(b)) return false; | |
a = [].slice.call(a); | |
b = [].slice.call(b); | |
return deepEqual(a, b, m); | |
} | |
/*! | |
* Get enumerable properties of a given object. | |
* | |
* @param {Object} a | |
* @return {Array} property names | |
*/ | |
function enumerable(a) { | |
var res = []; | |
for (var key in a) { | |
res.push(key); | |
}return res; | |
} | |
/*! | |
* Simple equality for flat iterable objects | |
* such as Arrays or Node.js buffers. | |
* | |
* @param {Iterable} a | |
* @param {Iterable} b | |
* @return {Boolean} result | |
*/ | |
function iterableEqual(a, b) { | |
if (a.length !== b.length) return false; | |
var i = 0; | |
var match = true; | |
for (; i < a.length; i++) { | |
if (a[i] !== b[i]) { | |
match = false; | |
break; | |
} | |
} | |
return match; | |
} | |
/*! | |
* Extension to `iterableEqual` specifically | |
* for Node.js Buffers. | |
* | |
* @param {Buffer} a | |
* @param {Mixed} b | |
* @return {Boolean} result | |
*/ | |
function bufferEqual(a, b) { | |
if (!Buffer.isBuffer(b)) return false; | |
return iterableEqual(a, b); | |
} | |
/*! | |
* Block for `objectEqual` ensuring non-existing | |
* values don't get in. | |
* | |
* @param {Mixed} object | |
* @return {Boolean} result | |
*/ | |
function isValue(a) { | |
return a !== null && a !== undefined; | |
} | |
/*! | |
* Recursively check the equality of two objects. | |
* Once basic sameness has been established it will | |
* defer to `deepEqual` for each enumerable key | |
* in the object. | |
* | |
* @param {Mixed} a | |
* @param {Mixed} b | |
* @return {Boolean} result | |
*/ | |
function objectEqual(a, b, m) { | |
if (!isValue(a) || !isValue(b)) { | |
return false; | |
} | |
if (a.prototype !== b.prototype) { | |
return false; | |
} | |
var i; | |
if (m) { | |
for (i = 0; i < m.length; i++) { | |
if (m[i][0] === a && m[i][1] === b || m[i][0] === b && m[i][1] === a) { | |
return true; | |
} | |
} | |
} else { | |
m = []; | |
} | |
try { | |
var ka = enumerable(a); | |
var kb = enumerable(b); | |
} catch (ex) { | |
return false; | |
} | |
ka.sort(); | |
kb.sort(); | |
if (!iterableEqual(ka, kb)) { | |
return false; | |
} | |
m.push([a, b]); | |
var key; | |
for (i = ka.length - 1; i >= 0; i--) { | |
key = ka[i]; | |
if (!deepEqual(a[key], b[key], m)) { | |
return false; | |
} | |
} | |
return true; | |
} | |
}); | |
var require$$0$10 = eql && (typeof eql === 'undefined' ? 'undefined' : babelHelpers.typeof(eql)) === 'object' && 'default' in eql ? eql['default'] : eql; | |
var index$4 = __commonjs(function (module) { | |
module.exports = require$$0$10; | |
}); | |
var require$$10 = index$4 && (typeof index$4 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$4)) === 'object' && 'default' in index$4 ? index$4['default'] : index$4; | |
var getEnumerableProperties = __commonjs(function (module) { | |
/*! | |
* Chai - getEnumerableProperties utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### .getEnumerableProperties(object) | |
* | |
* This allows the retrieval of enumerable property names of an object, | |
* inherited or not. | |
* | |
* @param {Object} object | |
* @returns {Array} | |
* @namespace Utils | |
* @name getEnumerableProperties | |
* @api public | |
*/ | |
module.exports = function getEnumerableProperties(object) { | |
var result = []; | |
for (var name in object) { | |
result.push(name); | |
} | |
return result; | |
}; | |
}); | |
var require$$0$13 = getEnumerableProperties && (typeof getEnumerableProperties === 'undefined' ? 'undefined' : babelHelpers.typeof(getEnumerableProperties)) === 'object' && 'default' in getEnumerableProperties ? getEnumerableProperties['default'] : getEnumerableProperties; | |
var getProperties = __commonjs(function (module) { | |
/*! | |
* Chai - getProperties utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### .getProperties(object) | |
* | |
* This allows the retrieval of property names of an object, enumerable or not, | |
* inherited or not. | |
* | |
* @param {Object} object | |
* @returns {Array} | |
* @namespace Utils | |
* @name getProperties | |
* @api public | |
*/ | |
module.exports = function getProperties(object) { | |
var result = Object.getOwnPropertyNames(object); | |
function addProperty(property) { | |
if (result.indexOf(property) === -1) { | |
result.push(property); | |
} | |
} | |
var proto = Object.getPrototypeOf(object); | |
while (proto !== null) { | |
Object.getOwnPropertyNames(proto).forEach(addProperty); | |
proto = Object.getPrototypeOf(proto); | |
} | |
return result; | |
}; | |
}); | |
var require$$1$4 = getProperties && (typeof getProperties === 'undefined' ? 'undefined' : babelHelpers.typeof(getProperties)) === 'object' && 'default' in getProperties ? getProperties['default'] : getProperties; | |
var inspect = __commonjs(function (module, exports) { | |
// This is (almost) directly from Node.js utils | |
// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js | |
var getName = require$$2$3; | |
var getProperties = require$$1$4; | |
var getEnumerableProperties = require$$0$13; | |
module.exports = inspect; | |
/** | |
* Echos the value of a value. Trys to print the value out | |
* in the best way possible given the different types. | |
* | |
* @param {Object} obj The object to print out. | |
* @param {Boolean} showHidden Flag that shows hidden (not enumerable) | |
* properties of objects. | |
* @param {Number} depth Depth in which to descend in object. Default is 2. | |
* @param {Boolean} colors Flag to turn on ANSI escape codes to color the | |
* output. Default is false (no coloring). | |
* @namespace Utils | |
* @name inspect | |
*/ | |
function inspect(obj, showHidden, depth, colors) { | |
var ctx = { | |
showHidden: showHidden, | |
seen: [], | |
stylize: function stylize(str) { | |
return str; | |
} | |
}; | |
return formatValue(ctx, obj, typeof depth === 'undefined' ? 2 : depth); | |
} | |
// Returns true if object is a DOM element. | |
var isDOMElement = function isDOMElement(object) { | |
if ((typeof HTMLElement === 'undefined' ? 'undefined' : babelHelpers.typeof(HTMLElement)) === 'object') { | |
return object instanceof HTMLElement; | |
} else { | |
return object && (typeof object === 'undefined' ? 'undefined' : babelHelpers.typeof(object)) === 'object' && object.nodeType === 1 && typeof object.nodeName === 'string'; | |
} | |
}; | |
function formatValue(ctx, value, recurseTimes) { | |
// Provide a hook for user-specified inspect functions. | |
// Check that value is an object with an inspect function on it | |
if (value && typeof value.inspect === 'function' && | |
// Filter out the util module, it's inspect function is special | |
value.inspect !== exports.inspect && | |
// Also filter out any prototype objects using the circular check. | |
!(value.constructor && value.constructor.prototype === value)) { | |
var ret = value.inspect(recurseTimes); | |
if (typeof ret !== 'string') { | |
ret = formatValue(ctx, ret, recurseTimes); | |
} | |
return ret; | |
} | |
// Primitive types cannot have properties | |
var primitive = formatPrimitive(ctx, value); | |
if (primitive) { | |
return primitive; | |
} | |
// If this is a DOM element, try to get the outer HTML. | |
if (isDOMElement(value)) { | |
if ('outerHTML' in value) { | |
return value.outerHTML; | |
// This value does not have an outerHTML attribute, | |
// it could still be an XML element | |
} else { | |
// Attempt to serialize it | |
try { | |
if (document.xmlVersion) { | |
var xmlSerializer = new XMLSerializer(); | |
return xmlSerializer.serializeToString(value); | |
} else { | |
// Firefox 11- do not support outerHTML | |
// It does, however, support innerHTML | |
// Use the following to render the element | |
var ns = "http://www.w3.org/1999/xhtml"; | |
var container = document.createElementNS(ns, '_'); | |
container.appendChild(value.cloneNode(false)); | |
html = container.innerHTML.replace('><', '>' + value.innerHTML + '<'); | |
container.innerHTML = ''; | |
return html; | |
} | |
} catch (err) { | |
// This could be a non-native DOM implementation, | |
// continue with the normal flow: | |
// printing the element as if it is an object. | |
} | |
} | |
} | |
// Look up the keys of the object. | |
var visibleKeys = getEnumerableProperties(value); | |
var keys = ctx.showHidden ? getProperties(value) : visibleKeys; | |
// Some type of object without properties can be shortcutted. | |
// In IE, errors have a single `stack` property, or if they are vanilla `Error`, | |
// a `stack` plus `description` property; ignore those for consistency. | |
if (keys.length === 0 || isError(value) && (keys.length === 1 && keys[0] === 'stack' || keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')) { | |
if (typeof value === 'function') { | |
var name = getName(value); | |
var nameSuffix = name ? ': ' + name : ''; | |
return ctx.stylize('[Function' + nameSuffix + ']', 'special'); | |
} | |
if (isRegExp(value)) { | |
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
} | |
if (isDate(value)) { | |
return ctx.stylize(Date.prototype.toUTCString.call(value), 'date'); | |
} | |
if (isError(value)) { | |
return formatError(value); | |
} | |
} | |
var base = '', | |
array = false, | |
braces = ['{', '}']; | |
// Make Array say that they are Array | |
if (isArray(value)) { | |
array = true; | |
braces = ['[', ']']; | |
} | |
// Make functions say that they are functions | |
if (typeof value === 'function') { | |
var name = getName(value); | |
var nameSuffix = name ? ': ' + name : ''; | |
base = ' [Function' + nameSuffix + ']'; | |
} | |
// Make RegExps say that they are RegExps | |
if (isRegExp(value)) { | |
base = ' ' + RegExp.prototype.toString.call(value); | |
} | |
// Make dates with properties first say the date | |
if (isDate(value)) { | |
base = ' ' + Date.prototype.toUTCString.call(value); | |
} | |
// Make error with message first say the error | |
if (isError(value)) { | |
return formatError(value); | |
} | |
if (keys.length === 0 && (!array || value.length == 0)) { | |
return braces[0] + base + braces[1]; | |
} | |
if (recurseTimes < 0) { | |
if (isRegExp(value)) { | |
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
} else { | |
return ctx.stylize('[Object]', 'special'); | |
} | |
} | |
ctx.seen.push(value); | |
var output; | |
if (array) { | |
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); | |
} else { | |
output = keys.map(function (key) { | |
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); | |
}); | |
} | |
ctx.seen.pop(); | |
return reduceToSingleString(output, base, braces); | |
} | |
function formatPrimitive(ctx, value) { | |
switch (typeof value === 'undefined' ? 'undefined' : babelHelpers.typeof(value)) { | |
case 'undefined': | |
return ctx.stylize('undefined', 'undefined'); | |
case 'string': | |
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\''; | |
return ctx.stylize(simple, 'string'); | |
case 'number': | |
if (value === 0 && 1 / value === -Infinity) { | |
return ctx.stylize('-0', 'number'); | |
} | |
return ctx.stylize('' + value, 'number'); | |
case 'boolean': | |
return ctx.stylize('' + value, 'boolean'); | |
} | |
// For some reason typeof null is "object", so special case here. | |
if (value === null) { | |
return ctx.stylize('null', 'null'); | |
} | |
} | |
function formatError(value) { | |
return '[' + Error.prototype.toString.call(value) + ']'; | |
} | |
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { | |
var output = []; | |
for (var i = 0, l = value.length; i < l; ++i) { | |
if (Object.prototype.hasOwnProperty.call(value, String(i))) { | |
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true)); | |
} else { | |
output.push(''); | |
} | |
} | |
keys.forEach(function (key) { | |
if (!key.match(/^\d+$/)) { | |
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true)); | |
} | |
}); | |
return output; | |
} | |
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { | |
var name, str; | |
if (value.__lookupGetter__) { | |
if (value.__lookupGetter__(key)) { | |
if (value.__lookupSetter__(key)) { | |
str = ctx.stylize('[Getter/Setter]', 'special'); | |
} else { | |
str = ctx.stylize('[Getter]', 'special'); | |
} | |
} else { | |
if (value.__lookupSetter__(key)) { | |
str = ctx.stylize('[Setter]', 'special'); | |
} | |
} | |
} | |
if (visibleKeys.indexOf(key) < 0) { | |
name = '[' + key + ']'; | |
} | |
if (!str) { | |
if (ctx.seen.indexOf(value[key]) < 0) { | |
if (recurseTimes === null) { | |
str = formatValue(ctx, value[key], null); | |
} else { | |
str = formatValue(ctx, value[key], recurseTimes - 1); | |
} | |
if (str.indexOf('\n') > -1) { | |
if (array) { | |
str = str.split('\n').map(function (line) { | |
return ' ' + line; | |
}).join('\n').substr(2); | |
} else { | |
str = '\n' + str.split('\n').map(function (line) { | |
return ' ' + line; | |
}).join('\n'); | |
} | |
} | |
} else { | |
str = ctx.stylize('[Circular]', 'special'); | |
} | |
} | |
if (typeof name === 'undefined') { | |
if (array && key.match(/^\d+$/)) { | |
return str; | |
} | |
name = JSON.stringify('' + key); | |
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { | |
name = name.substr(1, name.length - 2); | |
name = ctx.stylize(name, 'name'); | |
} else { | |
name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"); | |
name = ctx.stylize(name, 'string'); | |
} | |
} | |
return name + ': ' + str; | |
} | |
function reduceToSingleString(output, base, braces) { | |
var numLinesEst = 0; | |
var length = output.reduce(function (prev, cur) { | |
numLinesEst++; | |
if (cur.indexOf('\n') >= 0) numLinesEst++; | |
return prev + cur.length + 1; | |
}, 0); | |
if (length > 60) { | |
return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n ') + ' ' + braces[1]; | |
} | |
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; | |
} | |
function isArray(ar) { | |
return Array.isArray(ar) || (typeof ar === 'undefined' ? 'undefined' : babelHelpers.typeof(ar)) === 'object' && objectToString(ar) === '[object Array]'; | |
} | |
function isRegExp(re) { | |
return (typeof re === 'undefined' ? 'undefined' : babelHelpers.typeof(re)) === 'object' && objectToString(re) === '[object RegExp]'; | |
} | |
function isDate(d) { | |
return (typeof d === 'undefined' ? 'undefined' : babelHelpers.typeof(d)) === 'object' && objectToString(d) === '[object Date]'; | |
} | |
function isError(e) { | |
return (typeof e === 'undefined' ? 'undefined' : babelHelpers.typeof(e)) === 'object' && objectToString(e) === '[object Error]'; | |
} | |
function objectToString(o) { | |
return Object.prototype.toString.call(o); | |
} | |
}); | |
var require$$1$3 = inspect && (typeof inspect === 'undefined' ? 'undefined' : babelHelpers.typeof(inspect)) === 'object' && 'default' in inspect ? inspect['default'] : inspect; | |
var objDisplay = __commonjs(function (module) { | |
/*! | |
* Chai - flag utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Module dependancies | |
*/ | |
var inspect = require$$1$3; | |
var config = require$$0$3; | |
/** | |
* ### .objDisplay (object) | |
* | |
* Determines if an object or an array matches | |
* criteria to be inspected in-line for error | |
* messages or should be truncated. | |
* | |
* @param {Mixed} javascript object to inspect | |
* @name objDisplay | |
* @namespace Utils | |
* @api public | |
*/ | |
module.exports = function (obj) { | |
var str = inspect(obj), | |
type = Object.prototype.toString.call(obj); | |
if (config.truncateThreshold && str.length >= config.truncateThreshold) { | |
if (type === '[object Function]') { | |
return !obj.name || obj.name === '' ? '[Function]' : '[Function: ' + obj.name + ']'; | |
} else if (type === '[object Array]') { | |
return '[ Array(' + obj.length + ') ]'; | |
} else if (type === '[object Object]') { | |
var keys = Object.keys(obj), | |
kstr = keys.length > 2 ? keys.splice(0, 2).join(', ') + ', ...' : keys.join(', '); | |
return '{ Object (' + kstr + ') }'; | |
} else { | |
return str; | |
} | |
} else { | |
return str; | |
} | |
}; | |
}); | |
var require$$0$12 = objDisplay && (typeof objDisplay === 'undefined' ? 'undefined' : babelHelpers.typeof(objDisplay)) === 'object' && 'default' in objDisplay ? objDisplay['default'] : objDisplay; | |
var getActual = __commonjs(function (module) { | |
/*! | |
* Chai - getActual utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* # getActual(object, [actual]) | |
* | |
* Returns the `actual` value for an Assertion | |
* | |
* @param {Object} object (constructed Assertion) | |
* @param {Arguments} chai.Assertion.prototype.assert arguments | |
* @namespace Utils | |
* @name getActual | |
*/ | |
module.exports = function (obj, args) { | |
return args.length > 4 ? args[4] : obj._obj; | |
}; | |
}); | |
var require$$2$4 = getActual && (typeof getActual === 'undefined' ? 'undefined' : babelHelpers.typeof(getActual)) === 'object' && 'default' in getActual ? getActual['default'] : getActual; | |
var getMessage = __commonjs(function (module) { | |
/*! | |
* Chai - message composition utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Module dependancies | |
*/ | |
var flag = require$$0$5, | |
getActual = require$$2$4, | |
inspect = require$$1$3, | |
objDisplay = require$$0$12; | |
/** | |
* ### .getMessage(object, message, negateMessage) | |
* | |
* Construct the error message based on flags | |
* and template tags. Template tags will return | |
* a stringified inspection of the object referenced. | |
* | |
* Message template tags: | |
* - `#{this}` current asserted object | |
* - `#{act}` actual value | |
* - `#{exp}` expected value | |
* | |
* @param {Object} object (constructed Assertion) | |
* @param {Arguments} chai.Assertion.prototype.assert arguments | |
* @namespace Utils | |
* @name getMessage | |
* @api public | |
*/ | |
module.exports = function (obj, args) { | |
var negate = flag(obj, 'negate'), | |
val = flag(obj, 'object'), | |
expected = args[3], | |
actual = getActual(obj, args), | |
msg = negate ? args[2] : args[1], | |
flagMsg = flag(obj, 'message'); | |
if (typeof msg === "function") msg = msg(); | |
msg = msg || ''; | |
msg = msg.replace(/#\{this\}/g, function () { | |
return objDisplay(val); | |
}).replace(/#\{act\}/g, function () { | |
return objDisplay(actual); | |
}).replace(/#\{exp\}/g, function () { | |
return objDisplay(expected); | |
}); | |
return flagMsg ? flagMsg + ': ' + msg : msg; | |
}; | |
}); | |
var require$$16 = getMessage && (typeof getMessage === 'undefined' ? 'undefined' : babelHelpers.typeof(getMessage)) === 'object' && 'default' in getMessage ? getMessage['default'] : getMessage; | |
var index$6 = __commonjs(function (module) { | |
/*! | |
* assertion-error | |
* Copyright(c) 2013 Jake Luer <jake@qualiancy.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Return a function that will copy properties from | |
* one object to another excluding any originally | |
* listed. Returned function will create a new `{}`. | |
* | |
* @param {String} excluded properties ... | |
* @return {Function} | |
*/ | |
function exclude() { | |
var excludes = [].slice.call(arguments); | |
function excludeProps(res, obj) { | |
Object.keys(obj).forEach(function (key) { | |
if (! ~excludes.indexOf(key)) res[key] = obj[key]; | |
}); | |
} | |
return function extendExclude() { | |
var args = [].slice.call(arguments), | |
i = 0, | |
res = {}; | |
for (; i < args.length; i++) { | |
excludeProps(res, args[i]); | |
} | |
return res; | |
}; | |
}; | |
/*! | |
* Primary Exports | |
*/ | |
module.exports = AssertionError; | |
/** | |
* ### AssertionError | |
* | |
* An extension of the JavaScript `Error` constructor for | |
* assertion and validation scenarios. | |
* | |
* @param {String} message | |
* @param {Object} properties to include (optional) | |
* @param {callee} start stack function (optional) | |
*/ | |
function AssertionError(message, _props, ssf) { | |
var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON'), | |
props = extend(_props || {}); | |
// default values | |
this.message = message || 'Unspecified AssertionError'; | |
this.showDiff = false; | |
// copy from properties | |
for (var key in props) { | |
this[key] = props[key]; | |
} | |
// capture stack trace | |
ssf = ssf || arguments.callee; | |
if (ssf && Error.captureStackTrace) { | |
Error.captureStackTrace(this, ssf); | |
} else { | |
this.stack = new Error().stack; | |
} | |
} | |
/*! | |
* Inherit from Error.prototype | |
*/ | |
AssertionError.prototype = Object.create(Error.prototype); | |
/*! | |
* Statically set name | |
*/ | |
AssertionError.prototype.name = 'AssertionError'; | |
/*! | |
* Ensure correct constructor | |
*/ | |
AssertionError.prototype.constructor = AssertionError; | |
/** | |
* Allow errors to be converted to JSON for static transfer. | |
* | |
* @param {Boolean} include stack (default: `true`) | |
* @return {Object} object that can be `JSON.stringify` | |
*/ | |
AssertionError.prototype.toJSON = function (stack) { | |
var extend = exclude('constructor', 'toJSON', 'stack'), | |
props = extend({ name: this.name }, this); | |
// include stack if exists and not turned off | |
if (false !== stack && this.stack) { | |
props.stack = this.stack; | |
} | |
return props; | |
}; | |
}); | |
var require$$2$5 = index$6 && (typeof index$6 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$6)) === 'object' && 'default' in index$6 ? index$6['default'] : index$6; | |
var expectTypes = __commonjs(function (module) { | |
/*! | |
* Chai - expectTypes utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/** | |
* ### expectTypes(obj, types) | |
* | |
* Ensures that the object being tested against is of a valid type. | |
* | |
* utils.expectTypes(this, ['array', 'object', 'string']); | |
* | |
* @param {Mixed} obj constructed Assertion | |
* @param {Array} type A list of allowed types for this assertion | |
* @namespace Utils | |
* @name expectTypes | |
* @api public | |
*/ | |
var AssertionError = require$$2$5; | |
var flag = require$$0$5; | |
var type = require$$0$7; | |
module.exports = function (obj, types) { | |
var obj = flag(obj, 'object'); | |
types = types.map(function (t) { | |
return t.toLowerCase(); | |
}); | |
types.sort(); | |
// Transforms ['lorem', 'ipsum'] into 'a lirum, or an ipsum' | |
var str = types.map(function (t, index) { | |
var art = ~['a', 'e', 'i', 'o', 'u'].indexOf(t.charAt(0)) ? 'an' : 'a'; | |
var or = types.length > 1 && index === types.length - 1 ? 'or ' : ''; | |
return or + art + ' ' + t; | |
}).join(', '); | |
if (!types.some(function (expected) { | |
return type(obj) === expected; | |
})) { | |
throw new AssertionError('object tested must be ' + str + ', but ' + type(obj) + ' given'); | |
} | |
}; | |
}); | |
var require$$17 = expectTypes && (typeof expectTypes === 'undefined' ? 'undefined' : babelHelpers.typeof(expectTypes)) === 'object' && 'default' in expectTypes ? expectTypes['default'] : expectTypes; | |
var test = __commonjs(function (module) { | |
/*! | |
* Chai - test utility | |
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Module dependancies | |
*/ | |
var flag = require$$0$5; | |
/** | |
* # test(object, expression) | |
* | |
* Test and object for expression. | |
* | |
* @param {Object} object (constructed Assertion) | |
* @param {Arguments} chai.Assertion.prototype.assert arguments | |
* @namespace Utils | |
* @name test | |
*/ | |
module.exports = function (obj, args) { | |
var negate = flag(obj, 'negate'), | |
expr = args[0]; | |
return negate ? !expr : expr; | |
}; | |
}); | |
var require$$19 = test && (typeof test === 'undefined' ? 'undefined' : babelHelpers.typeof(test)) === 'object' && 'default' in test ? test['default'] : test; | |
var index$2 = __commonjs(function (module) { | |
/*! | |
* chai | |
* Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
/*! | |
* Main exports | |
*/ | |
var exports = module.exports = {}; | |
/*! | |
* test utility | |
*/ | |
exports.test = require$$19; | |
/*! | |
* type utility | |
*/ | |
exports.type = require$$0$7; | |
/*! | |
* expectTypes utility | |
*/ | |
exports.expectTypes = require$$17; | |
/*! | |
* message utility | |
*/ | |
exports.getMessage = require$$16; | |
/*! | |
* actual utility | |
*/ | |
exports.getActual = require$$2$4; | |
/*! | |
* Inspect util | |
*/ | |
exports.inspect = require$$1$3; | |
/*! | |
* Object Display util | |
*/ | |
exports.objDisplay = require$$0$12; | |
/*! | |
* Flag utility | |
*/ | |
exports.flag = require$$0$5; | |
/*! | |
* Flag transferring utility | |
*/ | |
exports.transferFlags = require$$2$1; | |
/*! | |
* Deep equal utility | |
*/ | |
exports.eql = require$$10; | |
/*! | |
* Deep path value | |
*/ | |
exports.getPathValue = require$$9; | |
/*! | |
* Deep path info | |
*/ | |
exports.getPathInfo = require$$0$9; | |
/*! | |
* Check if a property exists | |
*/ | |
exports.hasProperty = require$$0$6; | |
/*! | |
* Function name | |
*/ | |
exports.getName = require$$2$3; | |
/*! | |
* add Property | |
*/ | |
exports.addProperty = require$$5; | |
/*! | |
* add Method | |
*/ | |
exports.addMethod = require$$4$1; | |
/*! | |
* overwrite Property | |
*/ | |
exports.overwriteProperty = require$$3$1; | |
/*! | |
* overwrite Method | |
*/ | |
exports.overwriteMethod = require$$2$2; | |
/*! | |
* Add a chainable method | |
*/ | |
exports.addChainableMethod = require$$1$1; | |
/*! | |
* Overwrite chainable method | |
*/ | |
exports.overwriteChainableMethod = require$$0$4; | |
}); | |
var require$$6 = index$2 && (typeof index$2 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$2)) === 'object' && 'default' in index$2 ? index$2['default'] : index$2; | |
var chai = __commonjs(function (module, exports) { | |
/*! | |
* chai | |
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> | |
* MIT Licensed | |
*/ | |
var used = [], | |
exports = module.exports = {}; | |
/*! | |
* Chai version | |
*/ | |
exports.version = '3.5.0'; | |
/*! | |
* Assertion Error | |
*/ | |
exports.AssertionError = require$$2$5; | |
/*! | |
* Utils for plugins (not exported) | |
*/ | |
var util = require$$6; | |
/** | |
* # .use(function) | |
* | |
* Provides a way to extend the internals of Chai | |
* | |
* @param {Function} | |
* @returns {this} for chaining | |
* @api public | |
*/ | |
exports.use = function (fn) { | |
if (! ~used.indexOf(fn)) { | |
fn(this, util); | |
used.push(fn); | |
} | |
return this; | |
}; | |
/*! | |
* Utility Functions | |
*/ | |
exports.util = util; | |
/*! | |
* Configuration | |
*/ | |
var config = require$$0$3; | |
exports.config = config; | |
/*! | |
* Primary `Assertion` prototype | |
*/ | |
var assertion = require$$4; | |
exports.use(assertion); | |
/*! | |
* Core Assertions | |
*/ | |
var core = require$$3; | |
exports.use(core); | |
/*! | |
* Expect interface | |
*/ | |
var expect = require$$2; | |
exports.use(expect); | |
/*! | |
* Should interface | |
*/ | |
var should = require$$1; | |
exports.use(should); | |
/*! | |
* Assert interface | |
*/ | |
var assert = require$$0$2; | |
exports.use(assert); | |
}); | |
var require$$0$1 = chai && (typeof chai === 'undefined' ? 'undefined' : babelHelpers.typeof(chai)) === 'object' && 'default' in chai ? chai['default'] : chai; | |
var index = __commonjs(function (module) { | |
module.exports = require$$0$1; | |
}); | |
index && (typeof index === 'undefined' ? 'undefined' : babelHelpers.typeof(index)) === 'object' && 'default' in index ? index['default'] : index; | |
//import {jQuery as $, input as $input, expect} from '../support/fixture' | |
//import {jQuery, input, expect} from '../support/fixture' | |
var $ = window.jQuery; | |
var $input = $('input'); | |
}(require$$0)); | |
//# sourceMappingURL=picker-tests.js.iife.js.map |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment