New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
jasmine-expect
Advanced tools
jasmine-expect - npm Package Compare versions
Comparing version 2.0.0-beta1 to 2.0.0-beta2
@@ -1,962 +0,1757 @@ | ||
| /* | ||
| * Copyright © Jamie Mason, @fold_left, | ||
| * https://github.com/JamieMason | ||
| * | ||
| * Permission is hereby granted, free of charge, to any person | ||
| * obtaining a copy of this software and associated documentation files | ||
| * (the "Software"), to deal in the Software without restriction, | ||
| * including without limitation the rights to use, copy, modify, merge, | ||
| * publish, distribute, sublicense, and/or sell copies of the Software, | ||
| * and to permit persons to whom the Software is furnished to do so, | ||
| * subject to the following conditions: | ||
| * | ||
| * The above copyright notice and this permission notice shall be | ||
| * included in all copies or substantial portions of the Software. | ||
| * | ||
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | ||
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| * SOFTWARE. | ||
| */ | ||
| (function e(t, n, r) { | ||
| function s(o, u) { | ||
| if (!n[o]) { | ||
| if (!t[o]) { | ||
| var a = typeof require == 'function' && require; | ||
| if (!u && a) { | ||
| return a(o, !0); | ||
| } | ||
| if (i) { | ||
| return i(o, !0); | ||
| } | ||
| var f = new Error('Cannot find module \'' + o + '\''); | ||
| throw f.code = 'MODULE_NOT_FOUND', f | ||
| } | ||
| var l = n[o] = { | ||
| exports: {} | ||
| }; | ||
| t[o][0].call(l.exports, function(e) { | ||
| var n = t[o][1][e]; | ||
| return s(n ? n : e); | ||
| }, l, l.exports, e, t, n, r); | ||
| } | ||
| return n[o].exports; | ||
| } | ||
| var i = typeof require == 'function' && require; | ||
| for (var o = 0; o < r.length; o++) { | ||
| s(r[o]); | ||
| } | ||
| return s; | ||
| })({ | ||
| 1: [function(require, module, exports) { | ||
| 'use strict'; | ||
| (function() { | ||
| /* | ||
| * Copyright © Jamie Mason, @fold_left, | ||
| * https://github.com/JamieMason | ||
| * | ||
| * Permission is hereby granted, free of charge, to any person | ||
| * obtaining a copy of this software and associated documentation files | ||
| * (the "Software"), to deal in the Software without restriction, | ||
| * including without limitation the rights to use, copy, modify, merge, | ||
| * publish, distribute, sublicense, and/or sell copies of the Software, | ||
| * and to permit persons to whom the Software is furnished to do so, | ||
| * subject to the following conditions: | ||
| * | ||
| * The above copyright notice and this permission notice shall be | ||
| * included in all copies or substantial portions of the Software. | ||
| * | ||
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | ||
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| * SOFTWARE. | ||
| */ | ||
| var matchers = {}; | ||
| var priv = {}; | ||
| var factory = require('./lib/factory'); | ||
| /** | ||
| * @inner | ||
| * @param {Object} object | ||
| * @param {Function} fn | ||
| */ | ||
| priv.each = function(object, fn) { | ||
| for (var key in object) { | ||
| if (object.hasOwnProperty(key)) { | ||
| fn.call(this, object[key], key, object); | ||
| } | ||
| } | ||
| }; | ||
| var matchers = { | ||
| toBeAfter: require('./toBeAfter'), | ||
| toBeArray: require('./toBeArray'), | ||
| toBeArrayOfBooleans: require('./toBeArrayOfBooleans'), | ||
| toBeArrayOfNumbers: require('./toBeArrayOfNumbers'), | ||
| toBeArrayOfObjects: require('./toBeArrayOfObjects'), | ||
| toBeArrayOfSize: require('./toBeArrayOfSize'), | ||
| toBeArrayOfStrings: require('./toBeArrayOfStrings'), | ||
| toBeBefore: require('./toBeBefore'), | ||
| toBeBoolean: require('./toBeBoolean'), | ||
| toBeCalculable: require('./toBeCalculable'), | ||
| toBeDate: require('./toBeDate'), | ||
| toBeEmptyArray: require('./toBeEmptyArray'), | ||
| toBeEmptyObject: require('./toBeEmptyObject'), | ||
| toBeEmptyString: require('./toBeEmptyString'), | ||
| toBeEvenNumber: require('./toBeEvenNumber'), | ||
| toBeFalse: require('./toBeFalse'), | ||
| toBeFunction: require('./toBeFunction'), | ||
| toBeHtmlString: require('./toBeHtmlString'), | ||
| toBeIso8601: require('./toBeIso8601'), | ||
| toBeJsonString: require('./toBeJsonString'), | ||
| toBeLongerThan: require('./toBeLongerThan'), | ||
| toBeNonEmptyArray: require('./toBeNonEmptyArray'), | ||
| toBeNonEmptyObject: require('./toBeNonEmptyObject'), | ||
| toBeNonEmptyString: require('./toBeNonEmptyString'), | ||
| toBeNumber: require('./toBeNumber'), | ||
| toBeObject: require('./toBeObject'), | ||
| toBeOddNumber: require('./toBeOddNumber'), | ||
| toBeSameLengthAs: require('./toBeSameLengthAs'), | ||
| toBeShorterThan: require('./toBeShorterThan'), | ||
| toBeString: require('./toBeString'), | ||
| toBeTrue: require('./toBeTrue'), | ||
| toBeWhitespace: require('./toBeWhitespace'), | ||
| toBeWholeNumber: require('./toBeWholeNumber'), | ||
| toBeWithinRange: require('./toBeWithinRange'), | ||
| toEndWith: require('./toEndWith'), | ||
| toImplement: require('./toImplement'), | ||
| toStartWith: require('./toStartWith'), | ||
| toThrowAnyError: require('./toThrowAnyError'), | ||
| toThrowErrorOfType: require('./toThrowErrorOfType'), | ||
| toHaveArray: require('./toHaveArray'), | ||
| toHaveArrayOfBooleans: require('./toHaveArrayOfBooleans'), | ||
| toHaveArrayOfNumbers: require('./toHaveArrayOfNumbers'), | ||
| toHaveArrayOfObjects: require('./toHaveArrayOfObjects'), | ||
| toHaveArrayOfSize: require('./toHaveArrayOfSize'), | ||
| toHaveArrayOfStrings: require('./toHaveArrayOfStrings'), | ||
| toHaveBoolean: require('./toHaveBoolean'), | ||
| toHaveCalculable: require('./toHaveCalculable'), | ||
| toHaveDate: require('./toHaveDate'), | ||
| toHaveDateAfter: require('./toHaveDateAfter'), | ||
| toHaveDateBefore: require('./toHaveDateBefore'), | ||
| toHaveEmptyArray: require('./toHaveEmptyArray'), | ||
| toHaveEmptyObject: require('./toHaveEmptyObject'), | ||
| toHaveEmptyString: require('./toHaveEmptyString'), | ||
| toHaveEvenNumber: require('./toHaveEvenNumber'), | ||
| toHaveFalse: require('./toHaveFalse'), | ||
| toHaveHtmlString: require('./toHaveHtmlString'), | ||
| toHaveIso8601: require('./toHaveIso8601'), | ||
| toHaveJsonString: require('./toHaveJsonString'), | ||
| toHaveMember: require('./toHaveMember'), | ||
| toHaveMethod: require('./toHaveMethod'), | ||
| toHaveNonEmptyArray: require('./toHaveNonEmptyArray'), | ||
| toHaveNonEmptyObject: require('./toHaveNonEmptyObject'), | ||
| toHaveNonEmptyString: require('./toHaveNonEmptyString'), | ||
| toHaveNumber: require('./toHaveNumber'), | ||
| toHaveNumberWithinRange: require('./toHaveNumberWithinRange'), | ||
| toHaveObject: require('./toHaveObject'), | ||
| toHaveOddNumber: require('./toHaveOddNumber'), | ||
| toHaveString: require('./toHaveString'), | ||
| toHaveStringLongerThan: require('./toHaveStringLongerThan'), | ||
| toHaveStringSameLengthAs: require('./toHaveStringSameLengthAs'), | ||
| toHaveStringShorterThan: require('./toHaveStringShorterThan'), | ||
| toHaveTrue: require('./toHaveTrue'), | ||
| toHaveWhitespaceString: require('./toHaveWhitespaceString'), | ||
| toHaveWholeNumber: require('./toHaveWholeNumber') | ||
| }; | ||
| /** | ||
| * @inner | ||
| * @param {Object} object | ||
| * @param {Function} fn | ||
| * @param {*} memo | ||
| * @return {*} memo | ||
| */ | ||
| priv.reduce = function(object, fn, memo) { | ||
| priv.each.call(this, object, function(el, ix, list) { | ||
| memo = fn(memo, el, ix, list); | ||
| }); | ||
| return memo; | ||
| }; | ||
| for (var matcherName in matchers) { | ||
| factory(matcherName, matchers[matcherName]); | ||
| } | ||
| /** | ||
| * @inner | ||
| * @param {Array} array | ||
| * @param {Function} fn | ||
| * @return {Boolean} | ||
| */ | ||
| priv.all = function(array, fn) { | ||
| var i; | ||
| var len = array.length; | ||
| for (i = 0; i < len; i++) { | ||
| if (fn.call(this, array[i], i, array) === false) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| module.exports = matchers; | ||
| /** | ||
| * @inner | ||
| * @param {String} matcherName | ||
| * @return {Boolean} | ||
| */ | ||
| priv.expectAllMembers = function(matcherName) { | ||
| return priv.all.call(this, this.actual, function(item) { | ||
| return matchers[matcherName].call({ | ||
| actual: item | ||
| }); | ||
| }); | ||
| }; | ||
| }, { | ||
| './lib/factory': 3, | ||
| './toBeAfter': 10, | ||
| './toBeArray': 11, | ||
| './toBeArrayOfBooleans': 12, | ||
| './toBeArrayOfNumbers': 13, | ||
| './toBeArrayOfObjects': 14, | ||
| './toBeArrayOfSize': 15, | ||
| './toBeArrayOfStrings': 16, | ||
| './toBeBefore': 17, | ||
| './toBeBoolean': 18, | ||
| './toBeCalculable': 19, | ||
| './toBeDate': 20, | ||
| './toBeEmptyArray': 21, | ||
| './toBeEmptyObject': 22, | ||
| './toBeEmptyString': 23, | ||
| './toBeEvenNumber': 24, | ||
| './toBeFalse': 25, | ||
| './toBeFunction': 26, | ||
| './toBeHtmlString': 27, | ||
| './toBeIso8601': 28, | ||
| './toBeJsonString': 29, | ||
| './toBeLongerThan': 30, | ||
| './toBeNonEmptyArray': 31, | ||
| './toBeNonEmptyObject': 32, | ||
| './toBeNonEmptyString': 33, | ||
| './toBeNumber': 34, | ||
| './toBeObject': 35, | ||
| './toBeOddNumber': 36, | ||
| './toBeSameLengthAs': 37, | ||
| './toBeShorterThan': 38, | ||
| './toBeString': 39, | ||
| './toBeTrue': 40, | ||
| './toBeWhitespace': 41, | ||
| './toBeWholeNumber': 42, | ||
| './toBeWithinRange': 43, | ||
| './toEndWith': 44, | ||
| './toHaveArray': 45, | ||
| './toHaveArrayOfBooleans': 46, | ||
| './toHaveArrayOfNumbers': 47, | ||
| './toHaveArrayOfObjects': 48, | ||
| './toHaveArrayOfSize': 49, | ||
| './toHaveArrayOfStrings': 50, | ||
| './toHaveBoolean': 51, | ||
| './toHaveCalculable': 52, | ||
| './toHaveDate': 53, | ||
| './toHaveDateAfter': 54, | ||
| './toHaveDateBefore': 55, | ||
| './toHaveEmptyArray': 56, | ||
| './toHaveEmptyObject': 57, | ||
| './toHaveEmptyString': 58, | ||
| './toHaveEvenNumber': 59, | ||
| './toHaveFalse': 60, | ||
| './toHaveHtmlString': 61, | ||
| './toHaveIso8601': 62, | ||
| './toHaveJsonString': 63, | ||
| './toHaveMember': 64, | ||
| './toHaveMethod': 65, | ||
| './toHaveNonEmptyArray': 66, | ||
| './toHaveNonEmptyObject': 67, | ||
| './toHaveNonEmptyString': 68, | ||
| './toHaveNumber': 69, | ||
| './toHaveNumberWithinRange': 70, | ||
| './toHaveObject': 71, | ||
| './toHaveOddNumber': 72, | ||
| './toHaveString': 73, | ||
| './toHaveStringLongerThan': 74, | ||
| './toHaveStringSameLengthAs': 75, | ||
| './toHaveStringShorterThan': 76, | ||
| './toHaveTrue': 77, | ||
| './toHaveWhitespaceString': 78, | ||
| './toHaveWholeNumber': 79, | ||
| './toImplement': 80, | ||
| './toStartWith': 81, | ||
| './toThrowAnyError': 82, | ||
| './toThrowErrorOfType': 83 | ||
| }], | ||
| 2: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * Assert subject is of type | ||
| * @inner | ||
| * @param {*} subject | ||
| * @param {String} type | ||
| * @return {Boolean} | ||
| */ | ||
| priv.is = function(subject, type) { | ||
| return Object.prototype.toString.call(subject) === '[object ' + type + ']'; | ||
| }; | ||
| module.exports = every; | ||
| /** | ||
| * Assert subject is an HTML Element with the given node type | ||
| * @inner | ||
| * @param {*} subject | ||
| * @param {String} type | ||
| * @return {Boolean} | ||
| */ | ||
| priv.isHtmlElementOfType = function(subject, type) { | ||
| return subject && | ||
| subject.nodeType === type; | ||
| }; | ||
| function every(array, truthTest) { | ||
| for (var i = 0, len = array.length; i < len; i++) { | ||
| if (!truthTest(array[i])) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
| /** | ||
| * Convert Array-like Object to true Array | ||
| * @inner | ||
| * @param {*} list | ||
| * @return {Array} | ||
| */ | ||
| priv.toArray = function(list) { | ||
| return [].slice.call(list); | ||
| }; | ||
| }, {}], | ||
| 3: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @inner | ||
| * @param {String} matcherName | ||
| * @param {String} memberName | ||
| * @return {Boolean} | ||
| */ | ||
| priv.assertMember = function( /* matcherName, memberName, ... */ ) { | ||
| var args = priv.toArray(arguments); | ||
| var matcherName = args.shift(); | ||
| var memberName = args.shift(); | ||
| return priv.is(this.actual, 'Object') && | ||
| matchers[matcherName].apply({ | ||
| actual: this.actual[memberName] | ||
| }, args); | ||
| }; | ||
| var adapters = typeof jasmine.addMatchers === 'function' ? | ||
| require('./jasmine-v2') : | ||
| require('./jasmine-v1'); | ||
| /** | ||
| * @summary | ||
| * Format the failure message for member matchers such as toHaveString('surname'). | ||
| * | ||
| * @inner | ||
| * @param {Object} util Provided by Jasmine. | ||
| * @param {String} name Name of the matcher, such as toBeString. | ||
| * @param {Array} args converted arguments. | ||
| * @param {Boolean} pass Whether the test passed. | ||
| * @param {*} actual The expected value. | ||
| * @return {String} The message to display on failure. | ||
| */ | ||
| priv.formatFailMessage = function(util, name, args, pass, actual) { | ||
| if (name.search(/^toHave/) === -1) { | ||
| return util.buildFailureMessage.apply(null, [name, pass, actual].concat(args)); | ||
| } | ||
| var memberName = args.shift(); | ||
| return util.buildFailureMessage.apply(null, [name, pass, actual].concat(args)) | ||
| .replace('Expected', 'Expected member "' + memberName + '" of') | ||
| .replace(' to have ', ' to be '); | ||
| }; | ||
| module.exports = function(name, matcher) { | ||
| var adapter = adapters[matcher.length]; | ||
| return adapter(name, matcher); | ||
| }; | ||
| /** | ||
| * @summary | ||
| * Convert Jasmine 1.0 matchers into the format introduced in Jasmine 2.0. | ||
| * | ||
| * @inner | ||
| * @param {Object} v1Matchers | ||
| * @return {Object} v2Matchers | ||
| */ | ||
| priv.adaptMatchers = function(v1Matchers) { | ||
| return priv.reduce(v1Matchers, function(v2Matchers, matcher, name) { | ||
| v2Matchers[name] = function(util) { | ||
| return { | ||
| compare: function(actual /*, expected, ...*/ ) { | ||
| var args = priv.toArray(arguments).slice(1); | ||
| var pass = matcher.apply({ | ||
| actual: actual | ||
| }, args); | ||
| return { | ||
| pass: pass, | ||
| message: priv.formatFailMessage(util, name, args, pass, actual) | ||
| }, { | ||
| './jasmine-v1': 4, | ||
| './jasmine-v2': 5 | ||
| }], | ||
| 4: [function(require, module, exports) { | ||
| 'use strict'; | ||
| module.exports = { | ||
| 1: createFactory(forActual), | ||
| 2: createFactory(forActualAndExpected), | ||
| 3: createFactory(forActualAndTwoExpected), | ||
| 4: createFactory(forKeyAndActualAndTwoExpected) | ||
| }; | ||
| function createFactory(adapter) { | ||
| return function jasmineV1MatcherFactory(name, matcher) { | ||
| var matcherByName = new JasmineV1Matcher(name, adapter, matcher); | ||
| beforeEach(function() { | ||
| this.addMatchers(matcherByName); | ||
| }); | ||
| return matcherByName; | ||
| }; | ||
| } | ||
| } | ||
| function JasmineV1Matcher(name, adapter, matcher) { | ||
| this[name] = adapter(name, matcher); | ||
| } | ||
| function forActual(name, matcher) { | ||
| return function(optionalMessage) { | ||
| return matcher(this.actual, optionalMessage); | ||
| }; | ||
| } | ||
| function forActualAndExpected(name, matcher) { | ||
| return function(expected, optionalMessage) { | ||
| return matcher(expected, this.actual, optionalMessage); | ||
| }; | ||
| } | ||
| function forActualAndTwoExpected(name, matcher) { | ||
| return function(expected1, expected2, optionalMessage) { | ||
| return matcher(expected1, expected2, this.actual, optionalMessage); | ||
| }; | ||
| } | ||
| function forKeyAndActualAndTwoExpected(name, matcher) { | ||
| return function(key, expected1, expected2, optionalMessage) { | ||
| return matcher(key, expected1, expected2, this.actual, optionalMessage); | ||
| }; | ||
| } | ||
| }, {}], | ||
| 5: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var matcherFactory = require('./matcherFactory'); | ||
| var memberMatcherFactory = require('./memberMatcherFactory'); | ||
| module.exports = { | ||
| 1: createFactory(getAdapter(1)), | ||
| 2: createFactory(getAdapter(2)), | ||
| 3: createFactory(getAdapter(3)), | ||
| 4: createFactory(getAdapter(4)) | ||
| }; | ||
| }; | ||
| return v2Matchers; | ||
| }, {}); | ||
| }; | ||
| /** | ||
| * @inner | ||
| * @param {String} toBeX | ||
| * @return {Function} | ||
| */ | ||
| priv.createToBeArrayOfXsMatcher = function(toBeX) { | ||
| return function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| priv.expectAllMembers.call(this, toBeX); | ||
| }; | ||
| }; | ||
| function createFactory(adapter) { | ||
| return function jasmineV2MatcherFactory(name, matcher) { | ||
| var matcherByName = new JasmineV2Matcher(name, adapter, matcher); | ||
| beforeEach(function() { | ||
| jasmine.addMatchers(matcherByName); | ||
| }); | ||
| return matcherByName; | ||
| }; | ||
| } | ||
| /** | ||
| * @inner | ||
| * | ||
| * @summary | ||
| * Report how many instance members the given Object has. | ||
| * | ||
| * @param {Object} object | ||
| * @return {Number} | ||
| */ | ||
| priv.countMembers = function(object) { | ||
| return priv.reduce(object, function(memo /*, el, ix*/ ) { | ||
| return memo + 1; | ||
| }, 0); | ||
| }; | ||
| function JasmineV2Matcher(name, adapter, matcher) { | ||
| this[name] = adapter(name, matcher); | ||
| } | ||
| /** | ||
| * @alias toBeArray | ||
| * @summary <code>expect(array).toBeArray();</code> | ||
| */ | ||
| matchers.toBeArray = function() { | ||
| return priv.is(this.actual, 'Array'); | ||
| }; | ||
| function getAdapter(argsCount) { | ||
| return function adapter(name, matcher) { | ||
| var factory = isMemberMatcher(name) ? memberMatcherFactory : matcherFactory; | ||
| return factory[argsCount](name, matcher); | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeArrayOfSize | ||
| * @summary <code>expect(array).toBeArrayOfSize(size:Number);</code> | ||
| */ | ||
| matchers.toBeArrayOfSize = function(size) { | ||
| return priv.is(this.actual, 'Array') && | ||
| this.actual.length === size; | ||
| }; | ||
| function isMemberMatcher(name) { | ||
| return name.search(/^toHave/) !== -1; | ||
| } | ||
| /** | ||
| * @alias toBeEmptyArray | ||
| * @summary <code>expect(array).toBeEmptyArray();</code> | ||
| */ | ||
| matchers.toBeEmptyArray = function() { | ||
| return matchers.toBeArrayOfSize.call(this, 0); | ||
| }; | ||
| }, { | ||
| './matcherFactory': 6, | ||
| './memberMatcherFactory': 7 | ||
| }], | ||
| 6: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeNonEmptyArray | ||
| * @summary <code>expect(array).toBeNonEmptyArray();</code> | ||
| */ | ||
| matchers.toBeNonEmptyArray = function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| this.actual.length > 0; | ||
| }; | ||
| module.exports = { | ||
| 1: forActual, | ||
| 2: forActualAndExpected, | ||
| 3: forActualAndTwoExpected | ||
| }; | ||
| /** | ||
| * @alias toBeArrayOfObjects | ||
| * @summary <code>expect(array).toBeArrayOfObjects();</code> | ||
| */ | ||
| matchers.toBeArrayOfObjects = function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| priv.expectAllMembers.call(this, 'toBeObject'); | ||
| }; | ||
| function forActual(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, optionalMessage) { | ||
| var passes = matcher(actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeArrayOfStrings | ||
| * @summary <code>expect(array).toBeArrayOfStrings();</code> | ||
| */ | ||
| matchers.toBeArrayOfStrings = function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| priv.expectAllMembers.call(this, 'toBeString'); | ||
| }; | ||
| function forActualAndExpected(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, expected, optionalMessage) { | ||
| var passes = matcher(expected, actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, expected, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual, expected) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeArrayOfNumbers | ||
| * @summary <code>expect(array).toBeArrayOfNumbers();</code> | ||
| */ | ||
| matchers.toBeArrayOfNumbers = function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| priv.expectAllMembers.call(this, 'toBeNumber'); | ||
| }; | ||
| function forActualAndTwoExpected(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, expected1, expected2, optionalMessage) { | ||
| var passes = matcher(expected1, expected2, actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, expected1, expected2, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual, expected1, expected2) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeArrayOfBooleans | ||
| * @summary <code>expect(array).toBeArrayOfBooleans();</code> | ||
| */ | ||
| matchers.toBeArrayOfBooleans = function() { | ||
| return priv.is(this.actual, 'Array') && | ||
| priv.expectAllMembers.call(this, 'toBeBoolean'); | ||
| }; | ||
| }, {}], | ||
| 7: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeTrue | ||
| * @summary <code>expect(boolean).toBeTrue();</code> | ||
| */ | ||
| matchers.toBeTrue = function() { | ||
| return this.actual === true || | ||
| priv.is(this.actual, 'Boolean') && | ||
| this.actual.valueOf(); | ||
| }; | ||
| module.exports = { | ||
| 2: forKeyAndActual, | ||
| 3: forKeyAndActualAndExpected, | ||
| 4: forKeyAndActualAndTwoExpected | ||
| }; | ||
| /** | ||
| * @alias toBeFalse | ||
| * @summary <code>expect(boolean).toBeFalse();</code> | ||
| */ | ||
| matchers.toBeFalse = function() { | ||
| return this.actual === false || | ||
| priv.is(this.actual, 'Boolean') && | ||
| !this.actual.valueOf(); | ||
| }; | ||
| function forKeyAndActual(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, key, optionalMessage) { | ||
| var passes = matcher(key, actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeBoolean | ||
| * @summary <code>expect(boolean).toBeBoolean();</code> | ||
| */ | ||
| matchers.toBeBoolean = function() { | ||
| return priv.is(this.actual, 'Boolean'); | ||
| }; | ||
| function forKeyAndActualAndExpected(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, key, expected, optionalMessage) { | ||
| var passes = matcher(key, expected, actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, expected, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual, expected) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * @alias toBeDate | ||
| * @summary <code>expect(date).toBeDate();</code> | ||
| */ | ||
| matchers.toBeDate = function() { | ||
| return priv.is(this.actual, 'Date'); | ||
| }; | ||
| function forKeyAndActualAndTwoExpected(name, matcher) { | ||
| return function(util) { | ||
| return { | ||
| compare: function(actual, key, expected1, expected2, optionalMessage) { | ||
| var passes = matcher(key, expected1, expected2, actual); | ||
| return { | ||
| pass: passes, | ||
| message: ( | ||
| optionalMessage ? | ||
| util.buildFailureMessage(name, passes, actual, expected1, expected2, optionalMessage) : | ||
| util.buildFailureMessage(name, passes, actual, expected1, expected2) | ||
| ) | ||
| }; | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| function isIso8601(string, pattern) { | ||
| var returnValue = string.search( | ||
| new RegExp('^' + pattern.map(function(term) { | ||
| if (term === '-') { | ||
| return '\\-'; | ||
| } else if (typeof term === 'string') { | ||
| return term; | ||
| } else { | ||
| return '([0-9]{' + term + '})'; | ||
| }, {}], | ||
| 8: [function(require, module, exports) { | ||
| 'use strict'; | ||
| module.exports = is; | ||
| function is(value, type) { | ||
| return Object.prototype.toString.call(value) === '[object ' + type + ']'; | ||
| } | ||
| }).join('') + '$') | ||
| ) !== -1; | ||
| return returnValue; | ||
| } | ||
| /** | ||
| * @alias toBeIso8601 | ||
| * @summary <code>expect(string).toBeIso8601();</code> | ||
| */ | ||
| matchers.toBeIso8601 = function() { | ||
| }, {}], | ||
| 9: [function(require, module, exports) { | ||
| 'use strict'; | ||
| if (!matchers.toBeString.call(this)) { | ||
| return false; | ||
| } | ||
| module.exports = keys; | ||
| if (isIso8601(this.actual, [ | ||
| // 2013-07-08 | ||
| 4, '-', 2, '-', 2 | ||
| ]) || isIso8601(this.actual, [ | ||
| // 2013-07-08T07:29 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2 | ||
| ]) || isIso8601(this.actual, [ | ||
| // 2013-07-08T07:29:15 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2 | ||
| ]) || isIso8601(this.actual, [ | ||
| // 2013-07-08T07:29:15.863 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3 | ||
| ]) || isIso8601(this.actual, [ | ||
| // 2013-07-08T07:29:15.863Z | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3, 'Z' | ||
| ])) { | ||
| return new Date(this.actual).toString() !== 'Invalid Date'; | ||
| } | ||
| function keys(object) { | ||
| var list = []; | ||
| for (var key in object) { | ||
| if (object.hasOwnProperty(key)) { | ||
| list.push(key); | ||
| } | ||
| } | ||
| return list; | ||
| } | ||
| return false; | ||
| }, {}], | ||
| 10: [function(require, module, exports) { | ||
| 'use strict'; | ||
| }; | ||
| var toBeBefore = require('./toBeBefore'); | ||
| /** | ||
| * @alias toBeBefore | ||
| * @summary <code>expect(date).toBeBefore(date);</code> | ||
| */ | ||
| matchers.toBeBefore = function(date) { | ||
| return matchers.toBeDate.call(this) && | ||
| matchers.toBeDate.call({ | ||
| actual: date | ||
| }) && | ||
| this.actual.getTime() < date.getTime(); | ||
| }; | ||
| module.exports = toBeAfter; | ||
| /** | ||
| * @alias toBeAfter | ||
| * @summary <code>expect(date).toBeAfter(date);</code> | ||
| */ | ||
| matchers.toBeAfter = function(date) { | ||
| return matchers.toBeBefore.call({ | ||
| actual: date | ||
| }, this.actual); | ||
| }; | ||
| function toBeAfter(otherDate, actual) { | ||
| return toBeBefore(actual, otherDate); | ||
| } | ||
| /** | ||
| * @alias toThrowAnyError | ||
| * @summary <code>expect(function).toThrowAnyError();</code> | ||
| */ | ||
| matchers.toThrowAnyError = function() { | ||
| var threwError = false; | ||
| try { | ||
| this.actual(); | ||
| } catch (e) { | ||
| threwError = true; | ||
| } | ||
| return threwError; | ||
| }; | ||
| }, { | ||
| './toBeBefore': 17 | ||
| }], | ||
| 11: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toThrowErrorOfType | ||
| * @summary <code>expect(function).toThrowErrorOfType(type:String);</code> | ||
| */ | ||
| matchers.toThrowErrorOfType = function(type) { | ||
| var threwErrorOfType = false; | ||
| try { | ||
| this.actual(); | ||
| } catch (e) { | ||
| threwErrorOfType = (e.name === type); | ||
| } | ||
| return threwErrorOfType; | ||
| }; | ||
| var is = require('./lib/is'); | ||
| /** | ||
| * @alias toBeNumber | ||
| * @summary <code>expect(number).toBeNumber();</code> | ||
| */ | ||
| matchers.toBeNumber = function() { | ||
| return !isNaN(parseFloat(this.actual)) && | ||
| !priv.is(this.actual, 'String'); | ||
| }; | ||
| module.exports = toBeArray; | ||
| /** | ||
| * @alias toBeEvenNumber | ||
| * @summary <code>expect(number).toBeEvenNumber();</code> | ||
| */ | ||
| matchers.toBeEvenNumber = function() { | ||
| return matchers.toBeNumber.call(this) && | ||
| this.actual % 2 === 0; | ||
| }; | ||
| function toBeArray(actual) { | ||
| return is(actual, 'Array'); | ||
| } | ||
| /** | ||
| * @alias toBeOddNumber | ||
| * @summary <code>expect(number).toBeOddNumber();</code> | ||
| */ | ||
| matchers.toBeOddNumber = function() { | ||
| return matchers.toBeNumber.call(this) && | ||
| this.actual % 2 !== 0; | ||
| }; | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 12: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeCalculable | ||
| * @summary <code>expect(mixed).toBeCalculable();</code> | ||
| * @description | ||
| * Assert subject can be used in Mathemetic calculations despite not being a | ||
| * Number, for example <code>"1" * "2" === 2</code> but | ||
| * <code>"wut?" * 2 === NaN</code>. | ||
| */ | ||
| matchers.toBeCalculable = function() { | ||
| return !isNaN(this.actual * 2); | ||
| }; | ||
| var every = require('./lib/every'); | ||
| var toBeArray = require('./toBeArray'); | ||
| var toBeBoolean = require('./toBeBoolean'); | ||
| /** | ||
| * @alias toBeWithinRange | ||
| * @summary <code>expect(number).toBeWithinRange(floor:Number, ceiling:Number);</code> | ||
| */ | ||
| matchers.toBeWithinRange = function(floor, ceiling) { | ||
| return matchers.toBeNumber.call(this) && | ||
| this.actual >= floor && | ||
| this.actual <= ceiling; | ||
| }; | ||
| module.exports = toBeArrayOfBooleans; | ||
| /** | ||
| * @alias toBeWholeNumber | ||
| * @summary <code>expect(number).toBeWholeNumber();</code> | ||
| */ | ||
| matchers.toBeWholeNumber = function() { | ||
| return matchers.toBeNumber.call(this) && | ||
| (this.actual === 0 || this.actual % 1 === 0); | ||
| }; | ||
| function toBeArrayOfBooleans(actual) { | ||
| return toBeArray(actual) && | ||
| every(actual, toBeBoolean); | ||
| } | ||
| /** | ||
| * @alias toBeObject | ||
| * @summary <code>expect(object).toBeObject();</code> | ||
| */ | ||
| matchers.toBeObject = function() { | ||
| return priv.is(this.actual, 'Object'); | ||
| }; | ||
| }, { | ||
| './lib/every': 2, | ||
| './toBeArray': 11, | ||
| './toBeBoolean': 18 | ||
| }], | ||
| 13: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeEmptyObject | ||
| * @summary <code>expect(object).toBeEmptyObject();</code> | ||
| */ | ||
| matchers.toBeEmptyObject = function() { | ||
| return priv.is(this.actual, 'Object') && | ||
| priv.countMembers(this.actual) === 0; | ||
| }; | ||
| var every = require('./lib/every'); | ||
| var toBeArray = require('./toBeArray'); | ||
| var toBeNumber = require('./toBeNumber'); | ||
| /** | ||
| * @alias toBeNonEmptyObject | ||
| * @summary <code>expect(object).toBeNonEmptyObject();</code> | ||
| */ | ||
| matchers.toBeNonEmptyObject = function() { | ||
| return priv.is(this.actual, 'Object') && | ||
| priv.countMembers(this.actual) > 0; | ||
| }; | ||
| module.exports = toBeArrayOfBooleans; | ||
| /** | ||
| * @alias toImplement | ||
| * @summary <code>expect(object).toImplement(interface:Object);</code> | ||
| * @description | ||
| * Assert subject is a true Object which features at least the same keys as | ||
| * <code>other</code> regardless of whether it also has other members. | ||
| */ | ||
| matchers.toImplement = function(other) { | ||
| if (!priv.is(this.actual, 'Object') || !priv.is(other, 'Object')) { | ||
| return false; | ||
| } | ||
| for (var key in other) { | ||
| if (other.hasOwnProperty(key)) { | ||
| if (key in this.actual) { | ||
| continue; | ||
| function toBeArrayOfBooleans(actual) { | ||
| return toBeArray(actual) && | ||
| every(actual, toBeNumber); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| /** | ||
| * @alias toBeFunction | ||
| * @summary <code>expect(function).toBeFunction();</code> | ||
| */ | ||
| matchers.toBeFunction = function() { | ||
| return typeof this.actual === 'function'; | ||
| }; | ||
| }, { | ||
| './lib/every': 2, | ||
| './toBeArray': 11, | ||
| './toBeNumber': 34 | ||
| }], | ||
| 14: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeString | ||
| * @summary <code>expect(string).toBeString();</code> | ||
| */ | ||
| matchers.toBeString = function() { | ||
| return priv.is(this.actual, 'String'); | ||
| }; | ||
| var every = require('./lib/every'); | ||
| var toBeArray = require('./toBeArray'); | ||
| var toBeObject = require('./toBeObject'); | ||
| /** | ||
| * @alias toBeEmptyString | ||
| * @summary <code>expect(string).toBeEmptyString();</code> | ||
| */ | ||
| matchers.toBeEmptyString = function() { | ||
| return this.actual === ''; | ||
| }; | ||
| module.exports = toBeArrayOfBooleans; | ||
| /** | ||
| * @alias toBeNonEmptyString | ||
| * @summary <code>expect(string).toBeNonEmptyString();</code> | ||
| */ | ||
| matchers.toBeNonEmptyString = function() { | ||
| return matchers.toBeString.call(this) && | ||
| this.actual.length > 0; | ||
| }; | ||
| function toBeArrayOfBooleans(actual) { | ||
| return toBeArray(actual) && | ||
| every(actual, toBeObject); | ||
| } | ||
| /** | ||
| * @alias toBeHtmlString | ||
| * @summary <code>expect(string).toBeHtmlString();</code> | ||
| */ | ||
| matchers.toBeHtmlString = function() { | ||
| // < start with opening tag "<" | ||
| // ( start group 1 | ||
| // "[^"]*" allow string in "double quotes" | ||
| // | OR | ||
| // '[^']*' allow string in "single quotes" | ||
| // | OR | ||
| // [^'">] cant contains one single quotes, double quotes and ">" | ||
| // ) end group 1 | ||
| // * 0 or more | ||
| // > end with closing tag ">" | ||
| return matchers.toBeString.call(this) && | ||
| this.actual.search(/<("[^"]*"|'[^']*'|[^'">])*>/) !== -1; | ||
| }; | ||
| }, { | ||
| './lib/every': 2, | ||
| './toBeArray': 11, | ||
| './toBeObject': 35 | ||
| }], | ||
| 15: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeJsonString | ||
| * @summary <code>expect(string).toBeJsonString();</code> | ||
| */ | ||
| matchers.toBeJsonString = function() { | ||
| var isParseable; | ||
| var json; | ||
| try { | ||
| json = JSON.parse(this.actual); | ||
| } catch (e) { | ||
| isParseable = false; | ||
| } | ||
| return isParseable !== false && | ||
| json !== null; | ||
| }; | ||
| var toBeArray = require('./toBeArray'); | ||
| /** | ||
| * @alias toBeWhitespace | ||
| * @summary <code>expect(string).toBeWhitespace();</code> | ||
| */ | ||
| matchers.toBeWhitespace = function() { | ||
| return matchers.toBeString.call(this) && | ||
| this.actual.search(/\S/) === -1; | ||
| }; | ||
| module.exports = toBeArrayOfSize; | ||
| /** | ||
| * @alias toStartWith | ||
| * @summary <code>expect(string).toStartWith(expected:String);</code> | ||
| */ | ||
| matchers.toStartWith = function(expected) { | ||
| if (!matchers.toBeNonEmptyString.call(this) || !matchers.toBeNonEmptyString.call({ | ||
| actual: expected | ||
| })) { | ||
| return false; | ||
| } | ||
| return this.actual.slice(0, expected.length) === expected; | ||
| }; | ||
| function toBeArrayOfSize(size, actual) { | ||
| return toBeArray(actual) && | ||
| actual.length === size; | ||
| } | ||
| /** | ||
| * @alias toEndWith | ||
| * @summary <code>expect(string).toEndWith(expected:String);</code> | ||
| */ | ||
| matchers.toEndWith = function(expected) { | ||
| if (!matchers.toBeNonEmptyString.call(this) || !matchers.toBeNonEmptyString.call({ | ||
| actual: expected | ||
| })) { | ||
| return false; | ||
| } | ||
| return this.actual.slice(this.actual.length - expected.length, this.actual.length) === expected; | ||
| }; | ||
| }, { | ||
| './toBeArray': 11 | ||
| }], | ||
| 16: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toBeLongerThan | ||
| * @summary <code>expect(string).toBeLongerThan(other:String);</code> | ||
| */ | ||
| matchers.toBeLongerThan = function(other) { | ||
| return matchers.toBeString.call(this) && | ||
| matchers.toBeString.call({ | ||
| actual: other | ||
| }) && | ||
| this.actual.length > other.length; | ||
| }; | ||
| var every = require('./lib/every'); | ||
| var toBeArray = require('./toBeArray'); | ||
| var toBeString = require('./toBeString'); | ||
| /** | ||
| * @alias toBeShorterThan | ||
| * @summary <code>expect(string).toBeShorterThan(other:String);</code> | ||
| */ | ||
| matchers.toBeShorterThan = function(other) { | ||
| return matchers.toBeString.call(this) && | ||
| matchers.toBeString.call({ | ||
| actual: other | ||
| }) && | ||
| this.actual.length < other.length; | ||
| }; | ||
| module.exports = toBeArrayOfStrings; | ||
| /** | ||
| * @alias toBeSameLengthAs | ||
| * @summary <code>expect(string).toBeSameLengthAs(other:String);</code> | ||
| */ | ||
| matchers.toBeSameLengthAs = function(other) { | ||
| return matchers.toBeString.call(this) && | ||
| matchers.toBeString.call({ | ||
| actual: other | ||
| }) && | ||
| this.actual.length === other.length; | ||
| }; | ||
| function toBeArrayOfStrings(actual) { | ||
| return toBeArray(actual) && | ||
| every(actual, toBeString); | ||
| } | ||
| /** | ||
| * @alias toHaveArray | ||
| * @summary <code>expect(object).toHaveArray(key:String);</code> | ||
| */ | ||
| matchers.toHaveArray = function(key) { | ||
| return priv.assertMember.call(this, 'toBeArray', key); | ||
| }; | ||
| }, { | ||
| './lib/every': 2, | ||
| './toBeArray': 11, | ||
| './toBeString': 39 | ||
| }], | ||
| 17: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveArrayOfBooleans | ||
| * @summary <code>expect(object).toHaveArrayOfBooleans(key:String);</code> | ||
| */ | ||
| matchers.toHaveArrayOfBooleans = function(key) { | ||
| return priv.assertMember.call(this, 'toBeArrayOfBooleans', key); | ||
| }; | ||
| var toBeDate = require('./toBeDate'); | ||
| /** | ||
| * @alias toHaveArrayOfNumbers | ||
| * @summary <code>expect(object).toHaveArrayOfNumbers(key:String);</code> | ||
| */ | ||
| matchers.toHaveArrayOfNumbers = function(key) { | ||
| return priv.assertMember.call(this, 'toBeArrayOfNumbers', key); | ||
| }; | ||
| module.exports = toBeBefore; | ||
| /** | ||
| * @alias toHaveArrayOfObjects | ||
| * @summary <code>expect(object).toHaveArrayOfObjects(key:String);</code> | ||
| */ | ||
| matchers.toHaveArrayOfObjects = function(key) { | ||
| return priv.assertMember.call(this, 'toBeArrayOfObjects', key); | ||
| }; | ||
| function toBeBefore(otherDate, actual) { | ||
| return toBeDate(actual) && | ||
| toBeDate(otherDate) && | ||
| actual.getTime() < otherDate.getTime(); | ||
| } | ||
| /** | ||
| * @alias toHaveArrayOfSize | ||
| * @summary <code>expect(object).toHaveArrayOfSize(key:String, size:Number);</code> | ||
| */ | ||
| matchers.toHaveArrayOfSize = function(key, size) { | ||
| return priv.assertMember.call(this, 'toBeArrayOfSize', key, size); | ||
| }; | ||
| }, { | ||
| './toBeDate': 20 | ||
| }], | ||
| 18: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveNonEmptyArray | ||
| * @summary <code>expect(object).toHaveNonEmptyArray(key:String);</code> | ||
| */ | ||
| matchers.toHaveNonEmptyArray = function(key) { | ||
| return priv.assertMember.call(this, 'toBeNonEmptyArray', key); | ||
| }; | ||
| var is = require('./lib/is'); | ||
| /** | ||
| * @alias toHaveEmptyArray | ||
| * @summary <code>expect(object).toHaveEmptyArray(key:String);</code> | ||
| */ | ||
| matchers.toHaveEmptyArray = function(key) { | ||
| return priv.assertMember.call(this, 'toBeEmptyArray', key); | ||
| }; | ||
| module.exports = toBeBoolean; | ||
| /** | ||
| * @alias toHaveArrayOfStrings | ||
| * @summary <code>expect(object).toHaveArrayOfStrings(key:String);</code> | ||
| */ | ||
| matchers.toHaveArrayOfStrings = function(key) { | ||
| return priv.assertMember.call(this, 'toBeArrayOfStrings', key); | ||
| }; | ||
| function toBeBoolean(actual) { | ||
| return is(actual, 'Boolean'); | ||
| } | ||
| /** | ||
| * @alias toHaveBoolean | ||
| * @summary <code>expect(object).toHaveBoolean(key:String);</code> | ||
| */ | ||
| matchers.toHaveBoolean = function(key) { | ||
| return priv.assertMember.call(this, 'toBeBoolean', key); | ||
| }; | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 19: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveFalse | ||
| * @summary <code>expect(object).toHaveFalse(key:String);</code> | ||
| */ | ||
| matchers.toHaveFalse = function(key) { | ||
| return priv.assertMember.call(this, 'toBeFalse', key); | ||
| }; | ||
| module.exports = toBeCalculable; | ||
| /** | ||
| * @alias toHaveTrue | ||
| * @summary <code>expect(object).toHaveTrue(key:String);</code> | ||
| */ | ||
| matchers.toHaveTrue = function(key) { | ||
| return priv.assertMember.call(this, 'toBeTrue', key); | ||
| }; | ||
| // Assert subject can be used in Mathemetic | ||
| // calculations despite not being a Number, | ||
| // for example `"1" * "2" === 2` whereas | ||
| // `"wut?" * 2 === NaN`. | ||
| function toBeCalculable(actual) { | ||
| return !isNaN(actual * 2); | ||
| } | ||
| /** | ||
| * @alias toHaveDate | ||
| * @summary <code>expect(object):toHaveDate(key:String);</code> | ||
| */ | ||
| matchers.toHaveDate = function(key) { | ||
| return priv.assertMember.call(this, 'toBeDate', key); | ||
| }; | ||
| }, {}], | ||
| 20: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveDateAfter | ||
| * @summary <code>expect(object):toHaveDateAfter(key:String, date:Date);</code> | ||
| */ | ||
| matchers.toHaveDateAfter = function(key, date) { | ||
| return priv.assertMember.call(this, 'toBeAfter', key, date); | ||
| }; | ||
| var is = require('./lib/is'); | ||
| /** | ||
| * @alias toHaveDateBefore | ||
| * @summary <code>expect(object):toHaveDateBefore(key:String, date:Date);</code> | ||
| */ | ||
| matchers.toHaveDateBefore = function(key, date) { | ||
| return priv.assertMember.call(this, 'toBeBefore', key, date); | ||
| }; | ||
| module.exports = toBeDate; | ||
| /** | ||
| * @alias toHaveIso8601 | ||
| * @summary <code>expect(object):toHaveIso8601(key:String);</code> | ||
| */ | ||
| matchers.toHaveIso8601 = function(key) { | ||
| return priv.assertMember.call(this, 'toBeIso8601', key); | ||
| }; | ||
| function toBeDate(actual) { | ||
| return is(actual, 'Date'); | ||
| } | ||
| /** | ||
| * @alias toHaveNumber | ||
| * @summary <code>expect(object):toHaveNumber(key:String);</code> | ||
| */ | ||
| matchers.toHaveNumber = function(key) { | ||
| return priv.assertMember.call(this, 'toBeNumber', key); | ||
| }; | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 21: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveNumberWithinRange | ||
| * @summary <code>expect(object):toHaveNumberWithinRange(key:String, floor:Number, ceiling:Number);</code> | ||
| */ | ||
| matchers.toHaveNumberWithinRange = function(key, floor, ceiling) { | ||
| return priv.assertMember.call(this, 'toBeWithinRange', key, floor, ceiling); | ||
| }; | ||
| var toBeArrayOfSize = require('./toBeArrayOfSize'); | ||
| /** | ||
| * @alias toHaveCalculable | ||
| * @summary <code>expect(object):toHaveCalculable(key:String);</code> | ||
| */ | ||
| matchers.toHaveCalculable = function(key) { | ||
| return priv.assertMember.call(this, 'toBeCalculable', key); | ||
| }; | ||
| module.exports = toBeEmptyArray; | ||
| /** | ||
| * @alias toHaveEvenNumber | ||
| * @summary <code>expect(object):toHaveEvenNumber(key:String);</code> | ||
| */ | ||
| matchers.toHaveEvenNumber = function(key) { | ||
| return priv.assertMember.call(this, 'toBeEvenNumber', key); | ||
| }; | ||
| function toBeEmptyArray(actual) { | ||
| return toBeArrayOfSize(0, actual); | ||
| } | ||
| /** | ||
| * @alias toHaveOddNumber | ||
| * @summary <code>expect(object):toHaveOddNumber(key:String);</code> | ||
| */ | ||
| matchers.toHaveOddNumber = function(key) { | ||
| return priv.assertMember.call(this, 'toBeOddNumber', key); | ||
| }; | ||
| }, { | ||
| './toBeArrayOfSize': 15 | ||
| }], | ||
| 22: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveWholeNumber | ||
| * @summary <code>expect(object):toHaveWholeNumber(key:String);</code> | ||
| */ | ||
| matchers.toHaveWholeNumber = function(key) { | ||
| return priv.assertMember.call(this, 'toBeWholeNumber', key); | ||
| }; | ||
| var keys = require('./lib/keys'); | ||
| var is = require('./lib/is'); | ||
| /** | ||
| * @alias toHaveMethod | ||
| * @summary <code>expect(object).toHaveMethod(key:String);</code> | ||
| */ | ||
| matchers.toHaveMethod = function(key) { | ||
| return priv.assertMember.call(this, 'toBeFunction', key); | ||
| }; | ||
| module.exports = toBeEmptyObject; | ||
| /** | ||
| * @alias toHaveObject | ||
| * @summary <code>expect(object).toHaveObject(key:String);</code> | ||
| */ | ||
| matchers.toHaveObject = function(key) { | ||
| return priv.assertMember.call(this, 'toBeObject', key); | ||
| }; | ||
| function toBeEmptyObject(actual) { | ||
| return is(actual, 'Object') && | ||
| keys(actual).length === 0; | ||
| } | ||
| /** | ||
| * @alias toHaveEmptyObject | ||
| * @summary <code>expect(object).toHaveEmptyObject(key:String);</code> | ||
| */ | ||
| matchers.toHaveEmptyObject = function(key) { | ||
| return priv.assertMember.call(this, 'toBeEmptyObject', key); | ||
| }; | ||
| }, { | ||
| './lib/is': 8, | ||
| './lib/keys': 9 | ||
| }], | ||
| 23: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveNonEmptyObject | ||
| * @summary <code>expect(object).toHaveNonEmptyObject(key:String);</code> | ||
| */ | ||
| matchers.toHaveNonEmptyObject = function(key) { | ||
| return priv.assertMember.call(this, 'toBeNonEmptyObject', key); | ||
| }; | ||
| module.exports = toBeEmptyString; | ||
| /** | ||
| * @alias toHaveMember | ||
| * @summary <code>expect(object).toHaveMember(key:String);</code> | ||
| */ | ||
| matchers.toHaveMember = function(key) { | ||
| return key && priv.is(this.actual, 'Object') && | ||
| key in this.actual; | ||
| }; | ||
| function toBeEmptyString(actual) { | ||
| return actual === ''; | ||
| } | ||
| /** | ||
| * @alias toHaveEmptyString | ||
| * @summary <code>expect(object):toHaveEmptyString(key:String);</code> | ||
| */ | ||
| matchers.toHaveEmptyString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeEmptyString', key); | ||
| }; | ||
| }, {}], | ||
| 24: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveHtmlString | ||
| * @summary <code>expect(object):toHaveHtmlString(key:String);</code> | ||
| */ | ||
| matchers.toHaveHtmlString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeHtmlString', key); | ||
| }; | ||
| var toBeNumber = require('./toBeNumber'); | ||
| /** | ||
| * @alias toHaveJsonString | ||
| * @summary <code>expect(object):toHaveJsonString(key:String);</code> | ||
| */ | ||
| matchers.toHaveJsonString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeJsonString', key); | ||
| }; | ||
| module.exports = toBeEvenNumber; | ||
| /** | ||
| * @alias toHaveNonEmptyString | ||
| * @summary <code>expect(object):toHaveNonEmptyString(key:String);</code> | ||
| */ | ||
| matchers.toHaveNonEmptyString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeNonEmptyString', key); | ||
| }; | ||
| function toBeEvenNumber(actual) { | ||
| return toBeNumber(actual) && | ||
| actual % 2 === 0; | ||
| } | ||
| /** | ||
| * @alias toHaveString | ||
| * @summary <code>expect(object):toHaveString(key:String);</code> | ||
| */ | ||
| matchers.toHaveString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeString', key); | ||
| }; | ||
| }, { | ||
| './toBeNumber': 34 | ||
| }], | ||
| 25: [function(require, module, exports) { | ||
| 'use strict'; | ||
| /** | ||
| * @alias toHaveStringLongerThan | ||
| * @summary <code>expect(object):toHaveStringLongerThan(key:String, other:String);</code> | ||
| */ | ||
| matchers.toHaveStringLongerThan = function(key, other) { | ||
| return priv.assertMember.call(this, 'toBeLongerThan', key, other); | ||
| }; | ||
| var is = require('./lib/is'); | ||
| /** | ||
| * @alias toHaveStringSameLengthAs | ||
| * @summary <code>expect(object):toHaveStringSameLengthAs(key:String, other:String);</code> | ||
| */ | ||
| matchers.toHaveStringSameLengthAs = function(key, other) { | ||
| return priv.assertMember.call(this, 'toBeSameLengthAs', key, other); | ||
| }; | ||
| module.exports = toBeFalse; | ||
| /** | ||
| * @alias toHaveStringShorterThan | ||
| * @summary <code>expect(object):toHaveStringShorterThan(key:String, other:String);</code> | ||
| */ | ||
| matchers.toHaveStringShorterThan = function(key, other) { | ||
| return priv.assertMember.call(this, 'toBeShorterThan', key, other); | ||
| }; | ||
| function toBeFalse(actual) { | ||
| return actual === false || | ||
| is(actual, 'Boolean') && | ||
| !actual.valueOf(); | ||
| } | ||
| /** | ||
| * @alias toHaveWhitespaceString | ||
| * @summary <code>expect(object):toHaveWhitespaceString(key:String);</code> | ||
| */ | ||
| matchers.toHaveWhitespaceString = function(key) { | ||
| return priv.assertMember.call(this, 'toBeWhitespace', key); | ||
| }; | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 26: [function(require, module, exports) { | ||
| 'use strict'; | ||
| if (typeof jasmine.addMatchers === 'function') { | ||
| module.exports = toBeFunction; | ||
| // Create adapters for the original matchers so | ||
| // they can be compatible with Jasmine 2.0. | ||
| var matchersV2 = priv.adaptMatchers(matchers); | ||
| function toBeFunction(actual) { | ||
| return typeof actual === 'function'; | ||
| } | ||
| beforeEach(function() { | ||
| jasmine.addMatchers(matchersV2); | ||
| }); | ||
| }, {}], | ||
| 27: [function(require, module, exports) { | ||
| 'use strict'; | ||
| } else { | ||
| var toBeString = require('./toBeString'); | ||
| beforeEach(function() { | ||
| this.addMatchers(matchers); | ||
| }); | ||
| module.exports = toBeHtmlString; | ||
| } | ||
| function toBeHtmlString(actual) { | ||
| // < start with opening tag "<" | ||
| // ( start group 1 | ||
| // "[^"]*" allow string in "double quotes" | ||
| // | OR | ||
| // '[^']*' allow string in "single quotes" | ||
| // | OR | ||
| // [^'">] cant contains one single quotes, double quotes and ">" | ||
| // ) end group 1 | ||
| // * 0 or more | ||
| // > end with closing tag ">" | ||
| return toBeString(actual) && | ||
| actual.search(/<("[^"]*"|'[^']*'|[^'">])*>/) !== -1; | ||
| } | ||
| }()); | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 28: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeIso8601; | ||
| function toBeIso8601(actual) { | ||
| if (!toBeString(actual)) { | ||
| return false; | ||
| } | ||
| if ( | ||
| isIso8601(actual, [ | ||
| // 2013-07-08 | ||
| 4, '-', 2, '-', 2 | ||
| ]) || isIso8601(actual, [ | ||
| // 2013-07-08T07:29 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2 | ||
| ]) || isIso8601(actual, [ | ||
| // 2013-07-08T07:29:15 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2 | ||
| ]) || isIso8601(actual, [ | ||
| // 2013-07-08T07:29:15.863 | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3 | ||
| ]) || isIso8601(actual, [ | ||
| // 2013-07-08T07:29:15.863Z | ||
| 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3, 'Z' | ||
| ]) | ||
| ) { | ||
| return new Date(actual).toString() !== 'Invalid Date'; | ||
| } | ||
| return false; | ||
| } | ||
| function isIso8601(string, pattern) { | ||
| var returnValue = string.search( | ||
| new RegExp('^' + pattern.map(function(term) { | ||
| if (term === '-') { | ||
| return '\\-'; | ||
| } else if (typeof term === 'string') { | ||
| return term; | ||
| } else { | ||
| return '([0-9]{' + term + '})'; | ||
| } | ||
| }).join('') + '$') | ||
| ) !== -1; | ||
| return returnValue; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 29: [function(require, module, exports) { | ||
| 'use strict'; | ||
| module.exports = toBeJsonString; | ||
| function toBeJsonString(actual) { | ||
| var isParseable; | ||
| var json; | ||
| try { | ||
| json = JSON.parse(actual); | ||
| } catch (e) { | ||
| isParseable = false; | ||
| } | ||
| return isParseable !== false && | ||
| json !== null; | ||
| } | ||
| }, {}], | ||
| 30: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeLongerThan; | ||
| function toBeLongerThan(otherString, actual) { | ||
| return toBeString(actual) && | ||
| toBeString(otherString) && | ||
| actual.length > otherString.length; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 31: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeNonEmptyArray; | ||
| function toBeNonEmptyArray(actual) { | ||
| return is(actual, 'Array') && | ||
| actual.length > 0; | ||
| } | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 32: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var keys = require('./lib/keys'); | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeNonEmptyObject; | ||
| function toBeNonEmptyObject(actual) { | ||
| return is(actual, 'Object') && | ||
| keys(actual).length > 0; | ||
| } | ||
| }, { | ||
| './lib/is': 8, | ||
| './lib/keys': 9 | ||
| }], | ||
| 33: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeNonEmptyString; | ||
| function toBeNonEmptyString(actual) { | ||
| return toBeString(actual) && | ||
| actual.length > 0; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 34: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeNumber; | ||
| function toBeNumber(actual) { | ||
| return !isNaN(parseFloat(actual)) && | ||
| !is(actual, 'String'); | ||
| } | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 35: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeObject; | ||
| function toBeObject(actual) { | ||
| return is(actual, 'Object'); | ||
| } | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 36: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeNumber = require('./toBeNumber'); | ||
| module.exports = toBeOddNumber; | ||
| function toBeOddNumber(actual) { | ||
| return toBeNumber(actual) && | ||
| actual % 2 !== 0; | ||
| } | ||
| }, { | ||
| './toBeNumber': 34 | ||
| }], | ||
| 37: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeSameLengthAs; | ||
| function toBeSameLengthAs(otherString, actual) { | ||
| return toBeString(actual) && | ||
| toBeString(otherString) && | ||
| actual.length === otherString.length; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 38: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeShorterThan; | ||
| function toBeShorterThan(otherString, actual) { | ||
| return toBeString(actual) && | ||
| toBeString(otherString) && | ||
| actual.length < otherString.length; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 39: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeString; | ||
| function toBeString(actual) { | ||
| return is(actual, 'String'); | ||
| } | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 40: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var is = require('./lib/is'); | ||
| module.exports = toBeTrue; | ||
| function toBeTrue(actual) { | ||
| return actual === true || | ||
| is(actual, 'Boolean') && | ||
| actual.valueOf(); | ||
| } | ||
| }, { | ||
| './lib/is': 8 | ||
| }], | ||
| 41: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toBeWhitespace; | ||
| function toBeWhitespace(actual) { | ||
| return toBeString(actual) && | ||
| actual.search(/\S/) === -1; | ||
| } | ||
| }, { | ||
| './toBeString': 39 | ||
| }], | ||
| 42: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeNumber = require('./toBeNumber'); | ||
| module.exports = toBeWholeNumber; | ||
| function toBeWholeNumber(actual) { | ||
| return toBeNumber(actual) && ( | ||
| actual === 0 || actual % 1 === 0 | ||
| ); | ||
| } | ||
| }, { | ||
| './toBeNumber': 34 | ||
| }], | ||
| 43: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeNumber = require('./toBeNumber'); | ||
| module.exports = toBeWithinRange; | ||
| function toBeWithinRange(floor, ceiling, actual) { | ||
| return toBeNumber(actual) && | ||
| actual >= floor && | ||
| actual <= ceiling; | ||
| } | ||
| }, { | ||
| './toBeNumber': 34 | ||
| }], | ||
| 44: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeNonEmptyString = require('./toBeNonEmptyString'); | ||
| module.exports = toEndWith; | ||
| function toEndWith(subString, actual) { | ||
| if (!toBeNonEmptyString(actual) || !toBeNonEmptyString(subString)) { | ||
| return false; | ||
| } | ||
| return actual.slice(actual.length - subString.length, actual.length) === subString; | ||
| } | ||
| }, { | ||
| './toBeNonEmptyString': 33 | ||
| }], | ||
| 45: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArray = require('./toBeArray'); | ||
| module.exports = toHaveArray; | ||
| function toHaveArray(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArray(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArray': 11, | ||
| './toBeObject': 35 | ||
| }], | ||
| 46: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArrayOfBooleans = require('./toBeArrayOfBooleans'); | ||
| module.exports = toHaveArrayOfBooleans; | ||
| function toHaveArrayOfBooleans(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArrayOfBooleans(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArrayOfBooleans': 12, | ||
| './toBeObject': 35 | ||
| }], | ||
| 47: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArrayOfNumbers = require('./toBeArrayOfNumbers'); | ||
| module.exports = toHaveArrayOfNumbers; | ||
| function toHaveArrayOfNumbers(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArrayOfNumbers(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArrayOfNumbers': 13, | ||
| './toBeObject': 35 | ||
| }], | ||
| 48: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArrayOfObjects = require('./toBeArrayOfObjects'); | ||
| module.exports = toHaveArrayOfObjects; | ||
| function toHaveArrayOfObjects(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArrayOfObjects(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArrayOfObjects': 14, | ||
| './toBeObject': 35 | ||
| }], | ||
| 49: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArrayOfSize = require('./toBeArrayOfSize'); | ||
| module.exports = toHaveArrayOfSize; | ||
| function toHaveArrayOfSize(key, size, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArrayOfSize(size, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArrayOfSize': 15, | ||
| './toBeObject': 35 | ||
| }], | ||
| 50: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeArrayOfStrings = require('./toBeArrayOfStrings'); | ||
| module.exports = toHaveArrayOfStrings; | ||
| function toHaveArrayOfStrings(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeArrayOfStrings(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeArrayOfStrings': 16, | ||
| './toBeObject': 35 | ||
| }], | ||
| 51: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeBoolean = require('./toBeBoolean'); | ||
| module.exports = toHaveBoolean; | ||
| function toHaveBoolean(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeBoolean(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeBoolean': 18, | ||
| './toBeObject': 35 | ||
| }], | ||
| 52: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeCalculable = require('./toBeCalculable'); | ||
| module.exports = toHaveCalculable; | ||
| function toHaveCalculable(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeCalculable(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeCalculable': 19, | ||
| './toBeObject': 35 | ||
| }], | ||
| 53: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeDate = require('./toBeDate'); | ||
| module.exports = toHaveDate; | ||
| function toHaveDate(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeDate(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeDate': 20, | ||
| './toBeObject': 35 | ||
| }], | ||
| 54: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeAfter = require('./toBeAfter'); | ||
| module.exports = toHaveDateAfter; | ||
| function toHaveDateAfter(key, date, actual) { | ||
| return toBeObject(actual) && | ||
| toBeAfter(date, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeAfter': 10, | ||
| './toBeObject': 35 | ||
| }], | ||
| 55: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeBefore = require('./toBeBefore'); | ||
| module.exports = toHaveDateBefore; | ||
| function toHaveDateBefore(key, date, actual) { | ||
| return toBeObject(actual) && | ||
| toBeBefore(date, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeBefore': 17, | ||
| './toBeObject': 35 | ||
| }], | ||
| 56: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeEmptyArray = require('./toBeEmptyArray'); | ||
| module.exports = toHaveEmptyArray; | ||
| function toHaveEmptyArray(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeEmptyArray(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeEmptyArray': 21, | ||
| './toBeObject': 35 | ||
| }], | ||
| 57: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeEmptyObject = require('./toBeEmptyObject'); | ||
| module.exports = toHaveEmptyObject; | ||
| function toHaveEmptyObject(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeEmptyObject(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeEmptyObject': 22, | ||
| './toBeObject': 35 | ||
| }], | ||
| 58: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeEmptyString = require('./toBeEmptyString'); | ||
| module.exports = toHaveEmptyString; | ||
| function toHaveEmptyString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeEmptyString(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeEmptyString': 23, | ||
| './toBeObject': 35 | ||
| }], | ||
| 59: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeEvenNumber = require('./toBeEvenNumber'); | ||
| module.exports = toHaveEvenNumber; | ||
| function toHaveEvenNumber(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeEvenNumber(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeEvenNumber': 24, | ||
| './toBeObject': 35 | ||
| }], | ||
| 60: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeFalse = require('./toBeFalse'); | ||
| module.exports = toHaveFalse; | ||
| function toHaveFalse(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeFalse(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeFalse': 25, | ||
| './toBeObject': 35 | ||
| }], | ||
| 61: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeHtmlString = require('./toBeHtmlString'); | ||
| module.exports = toHaveHtmlString; | ||
| function toHaveHtmlString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeHtmlString(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeHtmlString': 27, | ||
| './toBeObject': 35 | ||
| }], | ||
| 62: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeIso8601 = require('./toBeIso8601'); | ||
| module.exports = toHaveIso8601; | ||
| function toHaveIso8601(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeIso8601(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeIso8601': 28, | ||
| './toBeObject': 35 | ||
| }], | ||
| 63: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeJsonString = require('./toBeJsonString'); | ||
| module.exports = toHaveJsonString; | ||
| function toHaveJsonString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeJsonString(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeJsonString': 29, | ||
| './toBeObject': 35 | ||
| }], | ||
| 64: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toHaveMember; | ||
| function toHaveMember(key, actual) { | ||
| return toBeString(key) && | ||
| toBeObject(actual) && | ||
| key in actual; | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeString': 39 | ||
| }], | ||
| 65: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeFunction = require('./toBeFunction'); | ||
| module.exports = toHaveMethod; | ||
| function toHaveMethod(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeFunction(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeFunction': 26, | ||
| './toBeObject': 35 | ||
| }], | ||
| 66: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeNonEmptyArray = require('./toBeNonEmptyArray'); | ||
| module.exports = toHaveNonEmptyArray; | ||
| function toHaveNonEmptyArray(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeNonEmptyArray(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeNonEmptyArray': 31, | ||
| './toBeObject': 35 | ||
| }], | ||
| 67: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeNonEmptyObject = require('./toBeNonEmptyObject'); | ||
| module.exports = toHaveNonEmptyObject; | ||
| function toHaveNonEmptyObject(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeNonEmptyObject(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeNonEmptyObject': 32, | ||
| './toBeObject': 35 | ||
| }], | ||
| 68: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeNonEmptyString = require('./toBeNonEmptyString'); | ||
| module.exports = toHaveNonEmptyString; | ||
| function toHaveNonEmptyString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeNonEmptyString(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeNonEmptyString': 33, | ||
| './toBeObject': 35 | ||
| }], | ||
| 69: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeNumber = require('./toBeNumber'); | ||
| module.exports = toHaveNumber; | ||
| function toHaveNumber(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeNumber(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeNumber': 34, | ||
| './toBeObject': 35 | ||
| }], | ||
| 70: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeWithinRange = require('./toBeWithinRange'); | ||
| module.exports = toHaveNumberWithinRange; | ||
| function toHaveNumberWithinRange(key, floor, ceiling, actual) { | ||
| return toBeObject(actual) && | ||
| toBeWithinRange(floor, ceiling, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeWithinRange': 43 | ||
| }], | ||
| 71: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| module.exports = toHaveObject; | ||
| function toHaveObject(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeObject(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35 | ||
| }], | ||
| 72: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeOddNumber = require('./toBeOddNumber'); | ||
| module.exports = toHaveOddNumber; | ||
| function toHaveOddNumber(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeOddNumber(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeOddNumber': 36 | ||
| }], | ||
| 73: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeString = require('./toBeString'); | ||
| module.exports = toHaveString; | ||
| function toHaveString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeString(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeString': 39 | ||
| }], | ||
| 74: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeLongerThan = require('./toBeLongerThan'); | ||
| module.exports = toHaveStringLongerThan; | ||
| function toHaveStringLongerThan(key, other, actual) { | ||
| return toBeObject(actual) && | ||
| toBeLongerThan(other, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeLongerThan': 30, | ||
| './toBeObject': 35 | ||
| }], | ||
| 75: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeSameLengthAs = require('./toBeSameLengthAs'); | ||
| module.exports = toHaveStringSameLengthAs; | ||
| function toHaveStringSameLengthAs(key, other, actual) { | ||
| return toBeObject(actual) && | ||
| toBeSameLengthAs(other, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeSameLengthAs': 37 | ||
| }], | ||
| 76: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeShorterThan = require('./toBeShorterThan'); | ||
| module.exports = toHaveStringShorterThan; | ||
| function toHaveStringShorterThan(key, other, actual) { | ||
| return toBeObject(actual) && | ||
| toBeShorterThan(other, actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeShorterThan': 38 | ||
| }], | ||
| 77: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeTrue = require('./toBeTrue'); | ||
| module.exports = toHaveTrue; | ||
| function toHaveTrue(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeTrue(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeTrue': 40 | ||
| }], | ||
| 78: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeWhitespace = require('./toBeWhitespace'); | ||
| module.exports = toHaveWhitespaceString; | ||
| function toHaveWhitespaceString(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeWhitespace(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeWhitespace': 41 | ||
| }], | ||
| 79: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| var toBeWholeNumber = require('./toBeWholeNumber'); | ||
| module.exports = toHaveWholeNumber; | ||
| function toHaveWholeNumber(key, actual) { | ||
| return toBeObject(actual) && | ||
| toBeWholeNumber(actual[key]); | ||
| } | ||
| }, { | ||
| './toBeObject': 35, | ||
| './toBeWholeNumber': 42 | ||
| }], | ||
| 80: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeObject = require('./toBeObject'); | ||
| module.exports = toImplement; | ||
| function toImplement(api, actual) { | ||
| return toBeObject(api) && | ||
| toBeObject(actual) && | ||
| featuresAll(api, actual); | ||
| } | ||
| function featuresAll(api, actual) { | ||
| for (var key in api) { | ||
| if (api.hasOwnProperty(key) && | ||
| key in actual === false) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
| }, { | ||
| './toBeObject': 35 | ||
| }], | ||
| 81: [function(require, module, exports) { | ||
| 'use strict'; | ||
| var toBeNonEmptyString = require('./toBeNonEmptyString'); | ||
| module.exports = toStartWith; | ||
| function toStartWith(subString, actual) { | ||
| if (!toBeNonEmptyString(actual) || !toBeNonEmptyString(subString)) { | ||
| return false; | ||
| } | ||
| return actual.slice(0, subString.length) === subString; | ||
| } | ||
| }, { | ||
| './toBeNonEmptyString': 33 | ||
| }], | ||
| 82: [function(require, module, exports) { | ||
| 'use strict'; | ||
| module.exports = toThrowAnyError; | ||
| function toThrowAnyError(actual) { | ||
| var threwError = false; | ||
| try { | ||
| actual(); | ||
| } catch (e) { | ||
| threwError = true; | ||
| } | ||
| return threwError; | ||
| } | ||
| }, {}], | ||
| 83: [function(require, module, exports) { | ||
| 'use strict'; | ||
| module.exports = toThrowErrorOfType; | ||
| function toThrowErrorOfType(type, actual) { | ||
| var threwErrorOfType = false; | ||
| try { | ||
| actual(); | ||
| } catch (e) { | ||
| threwErrorOfType = (e.name === type); | ||
| } | ||
| return threwErrorOfType; | ||
| } | ||
| }, {}] | ||
| }, {}, [1]); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| module.exports = require('./dist/jasmine-matchers'); |
125
package.json
| { | ||
| "name": "jasmine-expect", | ||
| "version": "2.0.0-beta1", | ||
| "description": "Additional matchers for the Jasmine BDD JavaScript testing library", | ||
| "homepage": "https://github.com/JamieMason/Jasmine-Matchers", | ||
| "author": "Jamie Mason (https://github.com/JamieMason)", | ||
| "license": "MIT", | ||
| "main": "index.js", | ||
| "contributors": [ | ||
| "Jamie Mason (https://github.com/JamieMason)", | ||
| "David Tanner (https://github.com/DavidTanner)" | ||
| ], | ||
| "authors": [ | ||
| "Jamie Mason <siunmaru@gmail.com>" | ||
| ], | ||
| "keywords": [ | ||
| "jasmine", | ||
| "BDD", | ||
| "TDD", | ||
| "testing" | ||
| ], | ||
| "devDependencies": { | ||
| "grunt": "0.4.5", | ||
| "grunt-contrib-concat": "0.5.0", | ||
| "grunt-contrib-jshint": "0.11.0", | ||
| "grunt-contrib-watch": "0.6.1", | ||
| "grunt-jsbeautifier": "0.2.7", | ||
| "grunt-jscs": "1.2.0", | ||
| "grunt-karma": "0.10.1", | ||
| "jsdoc-dash-template": "0.0.6", | ||
| "karma": "0.12.31", | ||
| "karma-chrome-launcher": "0.1.7", | ||
| "karma-coverage": "0.2.7", | ||
| "karma-firefox-launcher": "0.1.4", | ||
| "karma-jasmine": "0.3.5", | ||
| "karma-nested-reporter": "0.1.3", | ||
| "karma-opera-launcher": "0.1.0", | ||
| "karma-phantomjs-launcher": "0.1.4", | ||
| "karma-safari-launcher": "0.1.1", | ||
| "karma-sauce-launcher": "0.2.10", | ||
| "karma-script-launcher": "0.1.0" | ||
| }, | ||
| "scripts": { | ||
| "test": "./node_modules/karma/bin/karma start --single-run" | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "git://github.com/JamieMason/Jasmine-Matchers.git" | ||
| }, | ||
| "bugs": { | ||
| "url": "https://github.com/JamieMason/Jasmine-Matchers/issues" | ||
| } | ||
| "name": "jasmine-expect", | ||
| "version": "2.0.0-beta2", | ||
| "description": "Additional matchers for the Jasmine BDD JavaScript testing library", | ||
| "homepage": "https://github.com/JamieMason/Jasmine-Matchers", | ||
| "author": "Jamie Mason (https://github.com/JamieMason)", | ||
| "license": "MIT", | ||
| "main": "index.js", | ||
| "contributors": [ | ||
| "Jamie Mason (https://github.com/JamieMason)", | ||
| "David Tanner (https://github.com/DavidTanner)" | ||
| ], | ||
| "authors": [ | ||
| "Jamie Mason <siunmaru@gmail.com>" | ||
| ], | ||
| "keywords": [ | ||
| "jasmine", | ||
| "BDD", | ||
| "TDD", | ||
| "testing" | ||
| ], | ||
| "devDependencies": { | ||
| "browserify": "11.1.0", | ||
| "codeclimate-test-reporter": "0.1.1", | ||
| "esformatter": "0.7.3", | ||
| "esformatter-braces": "1.2.1", | ||
| "esformatter-dot-notation": "1.3.1", | ||
| "esformatter-jsx": "2.0.11", | ||
| "esformatter-parseint": "1.0.3", | ||
| "esformatter-quotes": "1.0.3", | ||
| "esformatter-remove-trailing-commas": "1.0.1", | ||
| "esformatter-semicolons": "1.1.1", | ||
| "esformatter-use-strict": "2.0.2", | ||
| "esformatter-var-each": "2.1.0", | ||
| "eslint": "1.4.1", | ||
| "eslint-plugin-smells": "1.0.1", | ||
| "gulp": "3.9.0", | ||
| "karma": "0.13.9", | ||
| "karma-chrome-launcher": "0.2.0", | ||
| "karma-coverage": "0.5.2", | ||
| "karma-firefox-launcher": "0.1.6", | ||
| "karma-jasmine": "0.3.6", | ||
| "karma-nested-reporter": "0.1.3", | ||
| "karma-opera-launcher": "0.3.0", | ||
| "karma-phantomjs-launcher": "0.2.1", | ||
| "karma-safari-launcher": "0.1.1", | ||
| "karma-sauce-launcher": "0.2.14", | ||
| "karma-script-launcher": "0.1.0", | ||
| "karma-threshold-reporter": "0.1.15", | ||
| "phantomjs": "1.9.18", | ||
| "vinyl-source-stream": "1.1.0" | ||
| }, | ||
| "scripts": { | ||
| "build": "npm run browserify && npm run formatter && npm run linter", | ||
| "browserify": "node_modules/gulp/bin/gulp.js browserify", | ||
| "development-watchers": "node_modules/gulp/bin/gulp.js development-watchers", | ||
| "formatter": "node_modules/esformatter/bin/esformatter -i --config .esformatter 'dist/**/*.js' 'src/**/*.js' 'test/**/*.js' 'tasks/**/*.js' '*.js'", | ||
| "linter": "node_modules/eslint/bin/eslint.js .", | ||
| "test": "node_modules/karma/bin/karma start karma.conf.js --single-run", | ||
| "test-ie10-ievms": "node_modules/karma/bin/karma start karma-ievms-ie10.conf.js --single-run", | ||
| "test-ie11-saucelabs": "node_modules/karma/bin/karma start karma-saucelabs-ie.conf.js --single-run", | ||
| "test-ie7-ievms": "node_modules/karma/bin/karma start karma-ievms-ie7.conf.js --single-run", | ||
| "test-ie8-ievms": "node_modules/karma/bin/karma start karma-ievms-ie8.conf.js --single-run", | ||
| "test-ie9-ievms": "node_modules/karma/bin/karma start karma-ievms-ie9.conf.js --single-run", | ||
| "test-local": "node_modules/karma/bin/karma start karma-local.conf.js --single-run", | ||
| "test-opera-emulator": "node_modules/karma/bin/karma start karma-opera-emulator.conf.js --single-run", | ||
| "test-watcher": "node_modules/karma/bin/karma start --no-single-run --auto-watch" | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "git://github.com/JamieMason/Jasmine-Matchers.git" | ||
| }, | ||
| "bugs": { | ||
| "url": "https://github.com/JamieMason/Jasmine-Matchers/issues" | ||
| } | ||
| } |
617
README.md
@@ -1,7 +0,27 @@ | ||
| # Jasmine-Matchers [](https://travis-ci.org/JamieMason/Jasmine-Matchers) | ||
| # Jasmine-Matchers | ||
| > Readable tests. | ||
| The [Jasmine testing framework](http://pivotal.github.com/jasmine/) from [Pivotal Labs](http://pivotallabs.com/) comes with this [default set of matchers](https://github.com/pivotal/jasmine/wiki/Matchers); | ||
| [](https://travis-ci.org/JamieMason/Jasmine-Matchers) [](https://www.npmjs.com/package/jasmine-expect) [](https://codeclimate.com/github/JamieMason/Jasmine-Matchers) [](https://twitter.com/intent/tweet?text=Additional%20matchers%20for%20the%20Jasmine%20BDD%20JavaScript%20testing%20library%20%23JavaScript%20%23NodeJS%20&url=https%3A%2F%2Fgithub.com%2FJamieMason%2FJasmine-Matchers) [](https://github.com/JamieMason/Jasmine-Matchers) [](https://github.com/JamieMason) | ||
| ## Contents | ||
| + [Purpose](#purpose) | ||
| + [Installation](#installation) | ||
| + [npm](#npm) | ||
| + [Bower](#bower) | ||
| + [Manual](#manual) | ||
| + [Integration](#integration) | ||
| + [Browser](#browser) | ||
| + [Karma](#karma) | ||
| + [Node.js](#node-js) | ||
| + [Sublime Text](#sublime-text) | ||
| + [Available Matchers](#available-matchers) | ||
| + [toBeArray](#tobearray), [toHaveArray](#tohavearray), [toBeArrayOfBooleans](#tobearrayofbooleans), [toHaveArrayOfBooleans](#tohavearrayofbooleans), [toBeArrayOfNumbers](#tobearrayofnumbers), [toHaveArrayOfNumbers](#tohavearrayofnumbers), [toBeArrayOfObjects](#tobearrayofobjects), [toHaveArrayOfObjects](#tohavearrayofobjects), [toBeArrayOfSize](#tobearrayofsize), [toHaveArrayOfSize](#tohavearrayofsize), [toBeArrayOfStrings](#tobearrayofstrings), [toHaveArrayOfStrings](#tohavearrayofstrings), [toBeEmptyArray](#tobeemptyarray), [toHaveEmptyArray](#tohaveemptyarray), [toBeNonEmptyArray](#tobenonemptyarray), [toHaveNonEmptyArray](#tohavenonemptyarray), [toBeBoolean](#tobeboolean), [toHaveBoolean](#tohaveboolean), [toBeFalse](#tobefalse), [toHaveFalse](#tohavefalse), [toBeTrue](#tobetrue), [toHaveTrue](#tohavetrue), [toBeAfter](#tobeafter), [toHaveDateAfter](#tohavedateafter), [toBeBefore](#tobebefore), [toHaveDateBefore](#tohavedatebefore), [toBeDate](#tobedate), [toHaveDate](#tohavedate), [toBeIso8601](#tobeiso8601), [toHaveIso8601](#tohaveiso8601), [toBeFunction](#tobefunction), [toHaveMethod](#tohavemethod), [toThrowAnyError](#tothrowanyerror), [toThrowErrorOfType](#tothrowerroroftype), [toBeCalculable](#tobecalculable), [toHaveCalculable](#tohavecalculable), [toBeEvenNumber](#tobeevennumber), [toHaveEvenNumber](#tohaveevennumber), [toBeNumber](#tobenumber), [toHaveNumber](#tohavenumber), [toBeOddNumber](#tobeoddnumber), [toHaveOddNumber](#tohaveoddnumber), [toBeWholeNumber](#tobewholenumber), [toHaveWholeNumber](#tohavewholenumber), [toBeWithinRange](#tobewithinrange), [toHaveNumberWithinRange](#tohavenumberwithinrange), [toBeEmptyObject](#tobeemptyobject), [toHaveEmptyObject](#tohaveemptyobject), [toBeNonEmptyObject](#tobenonemptyobject), [toHaveNonEmptyObject](#tohavenonemptyobject), [toBeObject](#tobeobject), [toHaveObject](#tohaveobject), [toHaveMember](#tohavemember), [toImplement](#toimplement), [toBeEmptyString](#tobeemptystring), [toHaveEmptyString](#tohaveemptystring), [toBeHtmlString](#tobehtmlstring), [toHaveHtmlString](#tohavehtmlstring), [toBeJsonString](#tobejsonstring), [toHaveJsonString](#tohavejsonstring), [toBeLongerThan](#tobelongerthan), [toHaveStringLongerThan](#tohavestringlongerthan), [toBeNonEmptyString](#tobenonemptystring), [toHaveNonEmptyString](#tohavenonemptystring), [toBeSameLengthAs](#tobesamelengthas), [toHaveStringSameLengthAs](#tohavestringsamelengthas), [toBeShorterThan](#tobeshorterthan), [toHaveStringShorterThan](#tohavestringshorterthan), [toBeString](#tobestring), [toHaveString](#tohavestring), [toBeWhitespace](#tobewhitespace), [toEndWith](#toendwith), [toStartWith](#tostartwith), [toHaveWhitespaceString](#tohavewhitespacestring) | ||
| + [Known Supported Devices](#known-supported-devices) | ||
| ## Purpose | ||
| The [Jasmine testing framework](http://jasmine.github.io/) from [Pivotal Labs](http://pivotallabs.com/) comes with this [default set of matchers](http://jasmine.github.io/edge/introduction.html#section-Expectations); | ||
| ```javascript | ||
@@ -111,121 +131,544 @@ expect(fn).toThrow(e); | ||
| ### Arrays | ||
| ### toBeArray | ||
| ```javascript | ||
| expect(array).toBeArray(); | ||
| expect(array).toBeArrayOfBooleans(); | ||
| expect(array).toBeArrayOfNumbers(); | ||
| expect(array).toBeArrayOfObjects(); | ||
| expect(array).toBeArrayOfSize(size); | ||
| expect(array).toBeArrayOfStrings(); | ||
| expect(array).toBeEmptyArray(); | ||
| expect(array).toBeNonEmptyArray(); | ||
| expect(object).toHaveArray(memberName); | ||
| expect(object).toHaveArrayOfBooleans(memberName); | ||
| expect(object).toHaveArrayOfNumbers(memberName); | ||
| expect(object).toHaveArrayOfObjects(memberName); | ||
| expect(object).toHaveArrayOfSize(memberName, size); | ||
| expect(object).toHaveArrayOfStrings(memberName); | ||
| expect(object).toHaveEmptyArray(memberName); | ||
| expect(object).toHaveNonEmptyArray(memberName); | ||
| expect([]).toBeArray(); | ||
| ``` | ||
| ### Booleans | ||
| ### toHaveArray | ||
| ```javascript | ||
| expect(boolean).toBeBoolean(); | ||
| expect(boolean).toBeFalse(); | ||
| expect(boolean).toBeTrue(); | ||
| expect(object).toHaveBoolean(memberName); | ||
| expect(object).toHaveFalse(memberName); | ||
| expect(object).toHaveTrue(memberName); | ||
| expect({ | ||
| memberName: [] | ||
| }).toHaveArray('memberName'); | ||
| ``` | ||
| ### Dates | ||
| ### toBeArrayOfBooleans | ||
| ```javascript | ||
| expect(date).toBeAfter(date); | ||
| expect(date).toBeBefore(date); | ||
| expect(date).toBeDate(); | ||
| expect(string).toBeIso8601(); | ||
| expect(object).toHaveDate(memberName); | ||
| expect(object).toHaveDateAfter(memberName, date); | ||
| expect(object).toHaveDateBefore(memberName, date); | ||
| expect(object).toHaveIso8601(memberName); | ||
| expect([true, false, true]).toBeArrayOfBooleans(); | ||
| ``` | ||
| ### Functions and Errors | ||
| ### toHaveArrayOfBooleans | ||
| ```javascript | ||
| expect(function).toBeFunction(); | ||
| expect(function).toThrowError(); | ||
| expect(function).toThrowErrorOfType(type); | ||
| expect(object).toHaveMethod(memberName); | ||
| expect({ | ||
| memberName: [true, false, true] | ||
| }).toHaveArrayOfBooleans('memberName'); | ||
| ``` | ||
| ### Numbers | ||
| ### toBeArrayOfNumbers | ||
| ```javascript | ||
| expect(mixed).toBeCalculable(); | ||
| expect(number).toBeEvenNumber(); | ||
| expect(number).toBeNumber(); | ||
| expect(number).toBeOddNumber(); | ||
| expect(number).toBeWholeNumber(); | ||
| expect(number).toBeWithinRange(floor, ceiling); | ||
| expect(object).toHaveCalculable(memberName); | ||
| expect(object).toHaveEvenNumber(memberName); | ||
| expect(object).toHaveNumber(memberName); | ||
| expect(object).toHaveNumberWithinRange(memberName, floor, ceiling); | ||
| expect(object).toHaveOddNumber(memberName); | ||
| expect(object).toHaveWholeNumber(memberName); | ||
| expect([12, 82, 7]).toBeArrayOfNumbers(); | ||
| ``` | ||
| ### Objects | ||
| ### toHaveArrayOfNumbers | ||
| ```javascript | ||
| expect(object).toBeEmptyObject(); | ||
| expect(object).toBeNonEmptyObject(); | ||
| expect(object).toBeObject(); | ||
| expect(object).toHaveEmptyObject(memberName); | ||
| expect(object).toHaveMember(memberName); | ||
| expect(object).toHaveNonEmptyObject(memberName); | ||
| expect(object).toHaveObject(memberName); | ||
| expect(object).toImplement(other); | ||
| expect({ | ||
| memberName: [12, 82, 7] | ||
| }).toHaveArrayOfNumbers('memberName'); | ||
| ``` | ||
| ### Strings | ||
| ### toBeArrayOfObjects | ||
| ```javascript | ||
| expect(string).toBeEmptyString(); | ||
| expect(string).toBeHtmlString(); | ||
| expect(string).toBeJsonString(); | ||
| expect(string).toBeLongerThan(other); | ||
| expect(string).toBeNonEmptyString(); | ||
| expect(string).toBeSameLengthAs(other); | ||
| expect(string).toBeShorterThan(other); | ||
| expect(string).toBeString(); | ||
| expect(string).toBeWhitespace(); | ||
| expect(string).toEndWith(expected); | ||
| expect(string).toStartWith(expected); | ||
| expect(object).toHaveEmptyString(memberName); | ||
| expect(object).toHaveHtmlString(memberName); | ||
| expect(object).toHaveJsonString(memberName); | ||
| expect(object).toHaveNonEmptyString(memberName); | ||
| expect(object).toHaveString(memberName); | ||
| expect(object).toHaveStringLongerThan(memberName, other); | ||
| expect(object).toHaveStringSameLengthAs(memberName, other); | ||
| expect(object).toHaveStringShorterThan(memberName, other); | ||
| expect(object).toHaveWhitespaceString(memberName); | ||
| expect([{}, {}]).toBeArrayOfObjects(); | ||
| ``` | ||
| ## Supported Devices | ||
| ### toHaveArrayOfObjects | ||
| Jasmine-Matchers has been tested against the following environments. | ||
| ```javascript | ||
| expect({ | ||
| memberName: [{}, {}] | ||
| }).toHaveArrayOfObjects('memberName'); | ||
| ``` | ||
| ### toBeArrayOfSize | ||
| ```javascript | ||
| expect([null, 31, 'hi']).toBeArrayOfSize(3); | ||
| ``` | ||
| ### toHaveArrayOfSize | ||
| ```javascript | ||
| expect({ | ||
| memberName: [null, 31, 'hi']).toBeArrayOfSi | ||
| }).toHaveArrayOfSize('memberName', size); | ||
| ``` | ||
| ### toBeArrayOfStrings | ||
| ```javascript | ||
| expect(['foo', 'bar']).toBeArrayOfStrings(); | ||
| ``` | ||
| ### toHaveArrayOfStrings | ||
| ```javascript | ||
| expect({ | ||
| memberName: ['foo', 'bar'] | ||
| }).toHaveArrayOfStrings('memberName'); | ||
| ``` | ||
| ### toBeEmptyArray | ||
| ```javascript | ||
| expect([]).toBeEmptyArray(); | ||
| ``` | ||
| ### toHaveEmptyArray | ||
| ```javascript | ||
| expect({ | ||
| memberName: [] | ||
| }).toHaveEmptyArray('memberName'); | ||
| ``` | ||
| ### toBeNonEmptyArray | ||
| ```javascript | ||
| expect([98, 'banana']).toBeNonEmptyArray(); | ||
| ``` | ||
| ### toHaveNonEmptyArray | ||
| ```javascript | ||
| expect({ | ||
| memberName: [98, 'banana'] | ||
| }).toHaveNonEmptyArray('memberName'); | ||
| ``` | ||
| ### toBeBoolean | ||
| ```javascript | ||
| expect(false).toBeBoolean(); | ||
| ``` | ||
| ### toHaveBoolean | ||
| ```javascript | ||
| expect({ | ||
| memberName: false | ||
| }).toHaveBoolean('memberName'); | ||
| ``` | ||
| ### toBeFalse | ||
| ```javascript | ||
| expect(false).toBeFalse(); | ||
| ``` | ||
| ### toHaveFalse | ||
| ```javascript | ||
| expect({ | ||
| memberName: false | ||
| }).toHaveFalse('memberName'); | ||
| ``` | ||
| ### toBeTrue | ||
| ```javascript | ||
| expect(true).toBeTrue(); | ||
| ``` | ||
| ### toHaveTrue | ||
| ```javascript | ||
| expect({ | ||
| memberName: true | ||
| }).toHaveTrue('memberName'); | ||
| ``` | ||
| ### toBeAfter | ||
| ```javascript | ||
| expect(new Date('2014-01-01')).toBeAfter(new Date('1975-01-01')); | ||
| ``` | ||
| ### toHaveDateAfter | ||
| ```javascript | ||
| expect({ | ||
| memberName: new Date('2014-01-01') | ||
| }).toHaveDateAfter('memberName', new Date('1975-01-01')); | ||
| ``` | ||
| ### toBeBefore | ||
| ```javascript | ||
| expect(new Date('1975-01-01')).toBeBefore(new Date('2014-01-01')); | ||
| ``` | ||
| ### toHaveDateBefore | ||
| ```javascript | ||
| expect({ | ||
| memberName: new Date('1975-01-01') | ||
| }).toHaveDateBefore('memberName', new Date('2014-01-01')); | ||
| ``` | ||
| ### toBeDate | ||
| ```javascript | ||
| expect(new Date()).toBeDate(); | ||
| ``` | ||
| ### toHaveDate | ||
| ```javascript | ||
| expect({ | ||
| memberName: new Date() | ||
| }).toHaveDate('memberName'); | ||
| ``` | ||
| ### toBeIso8601 | ||
| ```javascript | ||
| expect('2013-07-08T07:29:15').toBeIso8601(); | ||
| ``` | ||
| ### toHaveIso8601 | ||
| ```javascript | ||
| expect({ | ||
| memberName: '2013-07-08T07:29:15' | ||
| }).toHaveIso8601('memberName'); | ||
| ``` | ||
| ### toBeFunction | ||
| ```javascript | ||
| expect(function() {}).toBeFunction(); | ||
| ``` | ||
| ### toHaveMethod | ||
| ```javascript | ||
| expect({ | ||
| memberName: function() {} | ||
| }).toHaveMethod('memberName'); | ||
| ``` | ||
| ### toThrowAnyError | ||
| ```javascript | ||
| expect(function() { | ||
| return badReference.unreachable; | ||
| }).toThrowAnyError(); | ||
| ``` | ||
| ### toThrowErrorOfType | ||
| ```javascript | ||
| expect(function() { | ||
| return badReference.unreachable; | ||
| }).toThrowErrorOfType(ReferenceError); | ||
| ``` | ||
| ### toBeCalculable | ||
| ```javascript | ||
| expect('12').toBeCalculable(); | ||
| ``` | ||
| ### toHaveCalculable | ||
| ```javascript | ||
| expect({ | ||
| memberName: '14' | ||
| }).toHaveCalculable('memberName'); | ||
| ``` | ||
| ### toBeEvenNumber | ||
| ```javascript | ||
| expect(4).toBeEvenNumber(); | ||
| ``` | ||
| ### toHaveEvenNumber | ||
| ```javascript | ||
| expect({ | ||
| memberName: 4 | ||
| }).toHaveEvenNumber('memberName'); | ||
| ``` | ||
| ### toBeNumber | ||
| ```javascript | ||
| expect(66).toBeNumber(); | ||
| ``` | ||
| ### toHaveNumber | ||
| ```javascript | ||
| expect({ | ||
| memberName: 66 | ||
| }).toHaveNumber('memberName'); | ||
| ``` | ||
| ### toBeOddNumber | ||
| ```javascript | ||
| expect(3).toBeOddNumber(); | ||
| ``` | ||
| ### toHaveOddNumber | ||
| ```javascript | ||
| expect({ | ||
| memberName: 3 | ||
| }).toHaveOddNumber('memberName'); | ||
| ``` | ||
| ### toBeWholeNumber | ||
| ```javascript | ||
| expect(10).toBeWholeNumber(); | ||
| ``` | ||
| ### toHaveWholeNumber | ||
| ```javascript | ||
| expect({ | ||
| memberName: 10 | ||
| }).toHaveWholeNumber('memberName'); | ||
| ``` | ||
| ### toBeWithinRange | ||
| ```javascript | ||
| expect(6).toBeWithinRange(0, 10); | ||
| ``` | ||
| ### toHaveNumberWithinRange | ||
| ```javascript | ||
| expect({ | ||
| memberName: 6 | ||
| }).toHaveNumberWithinRange('memberName', 0, 10); | ||
| ``` | ||
| ### toBeEmptyObject | ||
| ```javascript | ||
| expect({}).toBeEmptyObject(); | ||
| ``` | ||
| ### toHaveEmptyObject | ||
| ```javascript | ||
| expect({ | ||
| memberName: {} | ||
| }).toHaveEmptyObject('memberName'); | ||
| ``` | ||
| ### toBeNonEmptyObject | ||
| ```javascript | ||
| expect({ | ||
| some: 'data' | ||
| }).toBeNonEmptyObject(); | ||
| ``` | ||
| ### toHaveNonEmptyObject | ||
| ```javascript | ||
| expect({ | ||
| memberName: { | ||
| some: 'data' | ||
| } | ||
| }).toHaveNonEmptyObject('memberName'); | ||
| ``` | ||
| ### toBeObject | ||
| ```javascript | ||
| expect({}).toBeObject(); | ||
| ``` | ||
| ### toHaveObject | ||
| ```javascript | ||
| expect({ | ||
| memberName: {} | ||
| }).toHaveObject('memberName'); | ||
| ``` | ||
| ### toHaveMember | ||
| ```javascript | ||
| expect({ | ||
| memberName: undefined | ||
| }).toHaveMember('memberName'); | ||
| ``` | ||
| ### toImplement | ||
| ```javascript | ||
| expect({ | ||
| name: 'Clive', | ||
| age: 72 | ||
| }).toImplement({ | ||
| name: String, | ||
| age: Number | ||
| }); | ||
| ``` | ||
| ### toBeEmptyString | ||
| ```javascript | ||
| expect('').toBeEmptyString(); | ||
| ``` | ||
| ### toHaveEmptyString | ||
| ```javascript | ||
| expect({ | ||
| memberName: '' | ||
| }).toHaveEmptyString('memberName'); | ||
| ``` | ||
| ### toBeHtmlString | ||
| ```javascript | ||
| expect('<div></div>').toBeHtmlString(); | ||
| ``` | ||
| ### toHaveHtmlString | ||
| ```javascript | ||
| expect({ | ||
| memberName: '<div></div>' | ||
| }).toHaveHtmlString('memberName'); | ||
| ``` | ||
| ### toBeJsonString | ||
| ```javascript | ||
| expect('{"name":"Winston"}').toBeJsonString(); | ||
| ``` | ||
| ### toHaveJsonString | ||
| ```javascript | ||
| expect({ | ||
| memberName: '{"name":"Winston"}' | ||
| }).toHaveJsonString('memberName'); | ||
| ``` | ||
| ### toBeLongerThan | ||
| ```javascript | ||
| expect('Antidisestablishmentarianism').toBeLongerThan('No'); | ||
| ``` | ||
| ### toHaveStringLongerThan | ||
| ```javascript | ||
| expect({ | ||
| memberName: 'Antidisestablishmentarianism' | ||
| }).toHaveStringLongerThan('memberName', 'No'); | ||
| ``` | ||
| ### toBeNonEmptyString | ||
| ```javascript | ||
| expect('filled up').toBeNonEmptyString(); | ||
| ``` | ||
| ### toHaveNonEmptyString | ||
| ```javascript | ||
| expect({ | ||
| memberName: 'filled up' | ||
| }).toHaveNonEmptyString('memberName'); | ||
| ``` | ||
| ### toBeSameLengthAs | ||
| ```javascript | ||
| expect('Paul').toBeSameLengthAs('Jean'); | ||
| ``` | ||
| ### toHaveStringSameLengthAs | ||
| ```javascript | ||
| expect({ | ||
| memberName: 'Paul' | ||
| }).toHaveStringSameLengthAs('memberName', 'Jean'); | ||
| ``` | ||
| ### toBeShorterThan | ||
| ```javascript | ||
| expect('No').toBeShorterThan('Antidisestablishmentarianism'); | ||
| ``` | ||
| ### toHaveStringShorterThan | ||
| ```javascript | ||
| expect({ | ||
| memberName: 'No' | ||
| }).toHaveStringShorterThan('memberName', 'Antidisestablishmentarianism'); | ||
| ``` | ||
| ### toBeString | ||
| ```javascript | ||
| expect('').toBeString(); | ||
| ``` | ||
| ### toHaveString | ||
| ```javascript | ||
| expect({ | ||
| memberName: '' | ||
| }).toHaveString('memberName'); | ||
| ``` | ||
| ### toBeWhitespace | ||
| ```javascript | ||
| expect(' ').toBeWhitespace(); | ||
| ``` | ||
| ### toEndWith | ||
| ```javascript | ||
| expect('grandmother').toEndWith('mother'); | ||
| ``` | ||
| ### toStartWith | ||
| ```javascript | ||
| expect('physiotherapy').toStartWith('physio'); | ||
| ``` | ||
| ### toHaveWhitespaceString | ||
| ```javascript | ||
| expect({ | ||
| memberName: ' ' | ||
| }).toHaveWhitespaceString('memberName'); | ||
| ``` | ||
| ## Known Supported Devices | ||
| During development, Jasmine-Matchers is tested against the following environments. | ||
| + Chrome 40.0.2214 (Mac OS X 10.10.1) | ||
| + Firefox 33.0.0 (Mac OS X 10.10) | ||
| + IE 10.0.0 (Windows 7) | ||
| + IE 9.0.0 (Windows 7) | ||
| + IE 7 (Windows XP on VirtualBox) | ||
| + IE 8 (Windows XP on VirtualBox) | ||
| + IE 9 (Windows 7 on VirtualBox) | ||
| + IE 10 (Windows 7 on VirtualBox) | ||
| + IE 11 (Windows 8.1 on SauceLabs) | ||
| + Opera 27.0.1689 (Mac OS X 10.10.1) | ||
| + Opera Mobile (Amazon Kindle Fire HD 8.9 on Opera Mobile Emulator) | ||
| + PhantomJS 1.9.8 (Mac OS X) | ||
| + Safari 8.0.2 (Mac OS X 10.10.1) |
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Dynamic require
Supply chain riskDynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.
Found 1 instance in 1 package
Fixed alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by100.48%
69113
- Lines of code
- increased by64.54%
1420
- Number of lines in readme file
- increased by191.77%
674
Worsened metrics
- Dev dependency count
- increased by52.63%
29
- Number of downloads
- decreased by-19.64%
31671
- Number of low supply chain risk alerts
- increased byInfinity%
2
No dependency changes